PageRenderTime 151ms CodeModel.GetById 23ms RepoModel.GetById 1ms app.codeStats 2ms

/usr/src/lib/libkmsagent/common/SOAP/stdsoap2.cpp

https://bitbucket.org/a3217055/illumos-gate
C++ | 15632 lines | 14532 code | 411 blank | 689 comment | 3825 complexity | 41313bb0cdd7fc221e1d79b312e6d6df MD5 | raw file
Possible License(s): BSD-2-Clause, BSD-3-Clause, LGPL-2.0, 0BSD, AGPL-3.0, GPL-2.0, GPL-3.0, LGPL-2.1, LGPL-3.0, BSD-3-Clause-No-Nuclear-License-2014, MPL-2.0-no-copyleft-exception, AGPL-1.0 
    

  1. /*
    2. 

  2.  * CDDL HEADER START
    3. 

  3.  *
    4. 

  4.  * The contents of this file are subject to the terms of the
    5. 

  5.  * Common Development and Distribution License (the "License").
    6. 

  6.  * You may not use this file except in compliance with the License.
    7. 

  7.  *
    8. 

  8.  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
    9. 

  9.  * or http://www.opensolaris.org/os/licensing.
    10. 

  10.  * See the License for the specific language governing permissions
    11. 

  11.  * and limitations under the License.
    12. 

  12.  *
    13. 

  13.  * When distributing Covered Code, include this CDDL HEADER in each
    14. 

  14.  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
    15. 

  15.  * If applicable, add the following below this CDDL HEADER, with the
    16. 

  16.  * fields enclosed by brackets "[]" replaced with your own identifying
    17. 

  17.  * information: Portions Copyright [yyyy] [name of copyright owner]
    18. 

  18.  *
    19. 

  19.  * CDDL HEADER END
    20. 

  20.  */
    21. 

  21. 

  22. /*
    23. 

  23.  * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
    24. 

  24.  */
    25. 

  25. /*
    26. 

  26. 	stdsoap2.c[pp] 2.7.17
    27. 

    28. 

  28. 	gSOAP runtime engine
    29. 

    30. 

  30. gSOAP XML Web services tools
    31. 

  31. Copyright (C) 2000-2010, Robert van Engelen, Genivia Inc., All Rights Reserved.
    32. 

  32. This part of the software is released under ONE of the following licenses:
    33. 

  33. GPL, or the gSOAP public license, or Genivia's license for commercial use.
    34. 

  34. --------------------------------------------------------------------------------
    35. 

  35. Contributors:
    36. 

    37. 

  37. Oracle, Inc. - additions are noted in the code commented with
    38. 

  38. "Oracle customization"
    39. 

  39.   - customization of the SSL accept timeout
    40. 

  40.   - work around for SSL_Sleep reporting closed connection
    41. 

  41.   - Function ssl_auth_init was static, but is now exported for external override
    42. 

  42.   - redirection of gSoap debug logs when debug builds enabled
    43. 

  43.   - added SSL_CTX_set_cipher_list call to restrict the cipher suite to RSA-2048/AES
    44. 

  44.     TLS_RSA_WITH_AES_256_CBC_SHA is defined in RFC 3268
    45. 

  45.     also see http://www.openssl.org/docs/apps/ciphers.html
    46. 

  46.   - Added SSL_OP_NO_SSLv3 to force use of TLS
    47. 

  47.   - bug fix: added call to close socket handle in various places noted in the code,
    48. 

  48.     since the caller overwrites soap->socket with the return value
    49. 

  49.   - compile warning cleanup
    50. 

    51. 

    52. 

  52.   Wind River Systems Inc., for the following additions under gSOAP public license:
    53. 

  53.   - vxWorks compatible
    54. 

  54. --------------------------------------------------------------------------------
    55. 

  55. gSOAP public license.
    56. 

    57. 

  57. The contents of this file are subject to the gSOAP Public License Version 1.3
    58. 

  58. (the "License"); you may not use this file except in compliance with the
    59. 

  59. License. You may obtain a copy of the License at
    60. 

  60. http://www.cs.fsu.edu/~engelen/soaplicense.html
    61. 

  61. Software distributed under the License is distributed on an "AS IS" basis,
    62. 

  62. WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
    63. 

  63. for the specific language governing rights and limitations under the License.
    64. 

    65. 

  65. The Initial Developer of the Original Code is Robert A. van Engelen.
    66. 

  66. Copyright (C) 2000-2010, Robert van Engelen, Genivia Inc., All Rights Reserved.
    67. 

  67. --------------------------------------------------------------------------------
    68. 

  68. GPL license.
    69. 

    70. 

  70. This program is free software; you can redistribute it and/or modify it under
    71. 

  71. the terms of the GNU General Public License as published by the Free Software
    72. 

  72. Foundation; either version 2 of the License, or (at your option) any later
    73. 

  73. version.
    74. 

    75. 

  75. This program is distributed in the hope that it will be useful, but WITHOUT ANY
    76. 

  76. WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
    77. 

  77. PARTICULAR PURPOSE. See the GNU General Public License for more details.
    78. 

    79. 

  79. You should have received a copy of the GNU General Public License along with
    80. 

  80. this program; if not, write to the Free Software Foundation, Inc., 59 Temple
    81. 

  81. Place, Suite 330, Boston, MA 02111-1307 USA
    82. 

    83. 

  83. Author contact information:
    84. 

  84. engelen@genivia.com / engelen@acm.org
    85. 

    86. 

  86. This program is released under the GPL with the additional exemption that
    87. 

  87. compiling, linking, and/or using OpenSSL is allowed.
    88. 

  88. --------------------------------------------------------------------------------
    89. 

  89. A commercial use license is available from Genivia, Inc., contact@genivia.com
    90. 

  90. --------------------------------------------------------------------------------
    91. 

    92. 

  92. Installation note:
    93. 

    94. 

  94. Win32 build needs winsock.dll (Visual C++ "wsock32.lib")
    95. 

  95. To do this in Visual C++ 6.0, go to "Project", "settings", select the "Link"
    96. 

  96. tab (the project file needs to be selected in the file view) and add
    97. 

  97. "wsock32.lib" to the "Object/library modules" entry
    98. 

    99. 

  99. On Mac OS X with gcc (GCC) 3.1 20020420 (prerelease) you MUST compile with
    100. 

  100. -fstack_check when using -O2 because gcc 3.1 has a bug that smashes the stack
    101. 

  101. when locally allocated data exceeds 64K.
    102. 

    103. 

  103. */
    104. 

  104. 

  105. #ifdef AS400
    106. 

  106. # pragma convert(819)	/* EBCDIC to ASCII */
    107. 

  107. #endif
    108. 

  108. 

  109. #include "stdsoap2.h"
    110. 

  110. 

  111. /*
    112. 

  112.  Oracle customization for OpenSSL 0.9.8 removal of deprecated function usage: RSA_generate_key
    113. 

  113. */
    114. 

  114. #ifdef WITH_OPENSSL
    115. 

  115. #ifdef OPENSSL_NO_DEPRECATED
    116. 

  116. #include <openssl/rsa.h>
    117. 

  117. #include <openssl/bn.h>
    118. 

  118. #include <openssl/dh.h>
    119. 

  119. #endif
    120. 

  120. #endif
    121. 

  121. 

  122. #ifdef SOAP_MEM_DEBUG
    123. 

  123. #ifndef WIN32
    124. 

  124. #include <ucontext.h>   /* Oracle customization (for printstack(3C)) */
    125. 

  125. #endif
    126. 

  126. #endif
    127. 

  127. 

  128. #ifdef __BORLANDC__
    129. 

  129. # pragma warn -8060
    130. 

  130. #else
    131. 

  131. # ifdef WIN32
    132. 

  132. #  ifdef UNDER_CE
    133. 

  133. #   pragma comment(lib, "winsock.lib")
    134. 

  134. #  else
    135. 

  135. #   pragma comment(lib, "wsock32.lib")
    136. 

  136. #  endif
    137. 

  137. #  pragma warning(disable : 4996) /* disable deprecation warnings */
    138. 

  138. # endif
    139. 

  139. #endif
    140. 

  140. 

  141. #ifdef __cplusplus
    142. 

  142. SOAP_SOURCE_STAMP("@(#) stdsoap2.cpp ver 2.7.17 2010-05-10 00:00:00 GMT")
    143. 

  143. extern "C" {
    144. 

  144. #else
    145. 

  145. SOAP_SOURCE_STAMP("@(#) stdsoap2.c ver 2.7.17 2010-05-10 00:00:00 GMT")
    146. 

  146. #endif
    147. 

  147. 

  148. /* 8bit character representing unknown/nonrepresentable character data (e.g. not supported by current locale with multibyte support enabled) */
    149. 

  149. #ifndef SOAP_UNKNOWN_CHAR
    150. 

  150. #define SOAP_UNKNOWN_CHAR (127)
    151. 

  151. #endif
    152. 

  152. 

  153. /*      EOF=-1 */
    154. 

  154. #define SOAP_LT (soap_wchar)(-2) /* XML character '<' */
    155. 

  155. #define SOAP_TT (soap_wchar)(-3) /* XML character '</' */
    156. 

  156. #define SOAP_GT (soap_wchar)(-4) /* XML character '>' */
    157. 

  157. #define SOAP_QT (soap_wchar)(-5) /* XML character '"' */
    158. 

  158. #define SOAP_AP (soap_wchar)(-6) /* XML character ''' */
    159. 

  159. 

  160. #define soap_blank(c)		((c) >= 0 && (c) <= 32)
    161. 

  161. #define soap_notblank(c)	((c) > 32)
    162. 

  162. 

  163. #if defined(WIN32) && !defined(UNDER_CE)
    164. 

  164. #define soap_hash_ptr(p)	((PtrToUlong(p) >> 3) & (SOAP_PTRHASH - 1))
    165. 

  165. #else
    166. 

  166. #define soap_hash_ptr(p)	((size_t)(((unsigned long)(p) >> 3) & (SOAP_PTRHASH-1)))
    167. 

  167. #endif
    168. 

  168. 

  169. #if !defined(WITH_LEAN) || defined(SOAP_DEBUG)
    170. 

  170. static void soap_init_logs(struct soap*);
    171. 

  171. #endif
    172. 

  172. #ifdef SOAP_DEBUG
    173. 

  173. static void soap_close_logfile(struct soap*, int);
    174. 

  174. static void soap_set_logfile(struct soap*, int, const char*);
    175. 

  175. #endif
    176. 

  176. 

  177. #ifdef SOAP_MEM_DEBUG
    178. 

  178. static void soap_init_mht(struct soap*);
    179. 

  179. static void soap_free_mht(struct soap*);
    180. 

  180. static void soap_track_unlink(struct soap*, const void*);
    181. 

  181. #endif
    182. 

  182. 

  183. #ifndef PALM_2
    184. 

  184. static int soap_set_error(struct soap*, const char*, const char*, const char*, const char*, int);
    185. 

  185. static int soap_copy_fault(struct soap*, const char*, const char*, const char*, const char*);
    186. 

  186. static int soap_getattrval(struct soap*, char*, size_t, soap_wchar);
    187. 

  187. #endif
    188. 

  188. 

  189. #ifndef PALM_1
    190. 

  190. static void soap_free_ns(struct soap *soap);
    191. 

  191. static soap_wchar soap_char(struct soap*);
    192. 

  192. static soap_wchar soap_get_pi(struct soap*);
    193. 

  193. static int soap_isxdigit(int);
    194. 

  194. static void *fplugin(struct soap*, const char*);
    195. 

  195. static char *soap_get_http_body(struct soap*);
    196. 

  196. static size_t soap_count_attachments(struct soap *soap);
    197. 

  197. static int soap_try_connect_command(struct soap*, int http_command, const char *endpoint, const char *action);
    198. 

  198. #ifndef WITH_NOIDREF
    199. 

  199. static void soap_update_ptrs(struct soap*, char*, char*, char*, char*);
    200. 

  200. static int soap_has_copies(struct soap*, const char*, const char*);
    201. 

  201. static void soap_init_iht(struct soap*);
    202. 

  202. static void soap_free_iht(struct soap*);
    203. 

  203. static void soap_init_pht(struct soap*);
    204. 

  204. static void soap_free_pht(struct soap*);
    205. 

  205. #endif
    206. 

  206. #endif
    207. 

  207. 

  208. #ifndef WITH_LEAN
    209. 

  209. static const char *soap_set_validation_fault(struct soap*, const char*, const char*);
    210. 

  210. static int soap_isnumeric(struct soap*, const char*);
    211. 

  211. static struct soap_nlist *soap_push_ns(struct soap *soap, const char *id, const char *ns, short utilized);
    212. 

  212. static void soap_utilize_ns(struct soap *soap, const char *tag, size_t n);
    213. 

  213. #endif
    214. 

  214. 

  215. #ifndef WITH_LEANER
    216. 

  216. #ifndef PALM_1
    217. 

  217. static struct soap_multipart *soap_new_multipart(struct soap*, struct soap_multipart**, struct soap_multipart**, char*, size_t);
    218. 

  218. static int soap_putdimefield(struct soap*, const char*, size_t);
    219. 

  219. static char *soap_getdimefield(struct soap*, size_t);
    220. 

  220. static void soap_select_mime_boundary(struct soap*);
    221. 

  221. static int soap_valid_mime_boundary(struct soap*);
    222. 

  222. static void soap_resolve_attachment(struct soap*, struct soap_multipart*);
    223. 

  223. #endif
    224. 

  224. #endif
    225. 

  225. 

  226. #ifdef WITH_GZIP
    227. 

  227. static int soap_getgziphdr(struct soap*);
    228. 

  228. #endif
    229. 

  229. 

  230. #ifdef WITH_OPENSSL
    231. 

  231. int soap_ssl_init_done = 0;
    232. 

  232. 

  233. //
    234. 

  234. // Oracle customization
    235. 

  235. //
    236. 

  236. // Function ssl_auth_init was static, but is now exported for external override
    237. 

  237. /*
    238. 

  238. static int ssl_auth_init(struct soap*);
    239. 

  239. */
    240. 

  240. int ssl_auth_init(struct soap*);
    241. 

  241. static int ssl_verify_callback(int, X509_STORE_CTX*);
    242. 

  242. static int ssl_verify_callback_allow_expired_certificate(int, X509_STORE_CTX*);
    243. 

  243. static int ssl_password(char*, int, int, void *);
    244. 

  244. #endif
    245. 

  245. 

  246. #if !defined(WITH_NOHTTP) || !defined(WITH_LEANER)
    247. 

  247. #ifndef PALM_1
    248. 

  248. static const char *soap_decode(char*, size_t, const char*, const char*);
    249. 

  249. #endif
    250. 

  250. #endif
    251. 

  251. 

  252. #ifndef WITH_NOHTTP
    253. 

  253. #ifndef PALM_1
    254. 

  254. static soap_wchar soap_getchunkchar(struct soap*);
    255. 

  255. static const char *http_error(struct soap*, int);
    256. 

  256. static int http_get(struct soap*);
    257. 

  257. static int http_405(struct soap*);
    258. 

  258. static int http_post(struct soap*, const char*, const char*, int, const char*, const char*, size_t);
    259. 

  259. static int http_send_header(struct soap*, const char*);
    260. 

  260. static int http_post_header(struct soap*, const char*, const char*);
    261. 

  261. static int http_response(struct soap*, int, size_t);
    262. 

  262. static int http_parse(struct soap*);
    263. 

  263. static int http_parse_header(struct soap*, const char*, const char*);
    264. 

  264. #endif
    265. 

  265. #endif
    266. 

  266. 

  267. #ifndef WITH_NOIO
    268. 

  268. 

  269. #ifndef PALM_1
    270. 

  270. static int fsend(struct soap*, const char*, size_t);
    271. 

  271. static size_t frecv(struct soap*, char*, size_t);
    272. 

  272. static int tcp_init(struct soap*);
    273. 

  273. static const char *tcp_error(struct soap*);
    274. 

  274. #ifndef WITH_IPV6
    275. 

  275. static int tcp_gethost(struct soap*, const char *addr, struct in_addr *inaddr);
    276. 

  276. #endif
    277. 

  277. static SOAP_SOCKET tcp_connect(struct soap*, const char *endpoint, const char *host, int port);
    278. 

  278. static SOAP_SOCKET tcp_accept(struct soap*, SOAP_SOCKET, struct sockaddr*, int*);
    279. 

  279. static int tcp_select(struct soap*, SOAP_SOCKET, int, int);
    280. 

  280. static int tcp_disconnect(struct soap*);
    281. 

  281. static int tcp_closesocket(struct soap*, SOAP_SOCKET);
    282. 

  282. static int tcp_shutdownsocket(struct soap*, SOAP_SOCKET, int);
    283. 

  283. static const char *soap_strerror(struct soap*);
    284. 

  284. #endif
    285. 

  285. 

  286. #define SOAP_TCP_SELECT_RCV 0x1
    287. 

  287. #define SOAP_TCP_SELECT_SND 0x2
    288. 

  288. #define SOAP_TCP_SELECT_ERR 0x4
    289. 

  289. #define SOAP_TCP_SELECT_ALL 0x7
    290. 

  290. 

  291. #if defined(WIN32)
    292. 

  292.   #define SOAP_SOCKBLOCK(fd) \
    293. 

  293.   { u_long blocking = 0; \
    294. 

  294.     ioctlsocket(fd, FIONBIO, &blocking); \
    295. 

  295.   }
    296. 

  296.   #define SOAP_SOCKNONBLOCK(fd) \
    297. 

  297.   { u_long nonblocking = 1; \
    298. 

  298.     ioctlsocket(fd, FIONBIO, &nonblocking); \
    299. 

  299.   }
    300. 

  300. #elif defined(VXWORKS)
    301. 

  301.   #define SOAP_SOCKBLOCK(fd) \
    302. 

  302.   { u_long blocking = 0; \
    303. 

  303.     ioctl(fd, FIONBIO, (int)(&blocking)); \
    304. 

  304.   }
    305. 

  305.   #define SOAP_SOCKNONBLOCK(fd) \
    306. 

  306.   { u_long nonblocking = 1; \
    307. 

  307.     ioctl(fd, FIONBIO, (int)(&nonblocking)); \
    308. 

  308.   }
    309. 

  309. #elif defined(PALM)
    310. 

  310.   #define SOAP_SOCKBLOCK(fd) fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0)&~O_NONBLOCK);
    311. 

  311.   #define SOAP_SOCKNONBLOCK(fd) fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0)|O_NONBLOCK);
    312. 

  312. #elif defined(SYMBIAN)
    313. 

  313.   #define SOAP_SOCKBLOCK(fd) \
    314. 

  314.   { long blocking = 0; \
    315. 

  315.     ioctl(fd, 0/*FIONBIO*/, &blocking); \
    316. 

  316.   }
    317. 

  317.   #define SOAP_SOCKNONBLOCK(fd) \
    318. 

  318.   { long nonblocking = 1; \
    319. 

  319.     ioctl(fd, 0/*FIONBIO*/, &nonblocking); \
    320. 

  320.   }
    321. 

  321. #else
    322. 

  322.   #define SOAP_SOCKBLOCK(fd) fcntl(fd, F_SETFL, fcntl(fd, F_GETFL)&~O_NONBLOCK);
    323. 

  323.   #define SOAP_SOCKNONBLOCK(fd) fcntl(fd, F_SETFL, fcntl(fd, F_GETFL)|O_NONBLOCK);
    324. 

  324. #endif
    325. 

  325. 

  326. #endif
    327. 

  327. 

  328. #if defined(PALM) && !defined(PALM_2)
    329. 

  329. unsigned short errno;
    330. 

  330. #endif
    331. 

  331. 

  332. #ifndef PALM_1
    333. 

  333. static const char soap_env1[42] = "http://schemas.xmlsoap.org/soap/envelope/";
    334. 

  334. static const char soap_enc1[42] = "http://schemas.xmlsoap.org/soap/encoding/";
    335. 

  335. static const char soap_env2[40] = "http://www.w3.org/2003/05/soap-envelope";
    336. 

  336. static const char soap_enc2[40] = "http://www.w3.org/2003/05/soap-encoding";
    337. 

  337. static const char soap_rpc[35] = "http://www.w3.org/2003/05/soap-rpc";
    338. 

  338. #endif
    339. 

  339. 

  340. #ifndef PALM_1
    341. 

  341. const struct soap_double_nan soap_double_nan = {0xFFFFFFFF, 0xFFFFFFFF};
    342. 

  342. static const char soap_base64o[65] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    343. 

  343. static 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";
    344. 

  344. #endif
    345. 

  345. 

  346. #ifndef WITH_LEAN
    347. 

  347. static const char soap_indent[11] = "\n\t\t\t\t\t\t\t\t\t";
    348. 

  348. /* Alternative indentation form for SOAP_XML_INDENT:
    349. 

  349. static const char soap_indent[21] = "\n                   ";
    350. 

  350. */
    351. 

  351. #endif
    352. 

  352. 

  353. #ifndef SOAP_CANARY
    354. 

  354. # define SOAP_CANARY (0xC0DE)
    355. 

  355. #endif
    356. 

  356. 

  357. static const char soap_padding[4] = "\0\0\0";
    358. 

  358. #define SOAP_STR_PADDING (soap_padding)
    359. 

  359. #define SOAP_STR_EOS (soap_padding)
    360. 

  360. #define SOAP_NON_NULL (soap_padding)
    361. 

  361. 

  362. #ifndef WITH_LEAN
    363. 

  363. static const struct soap_code_map html_entity_codes[] = /* entities for XHTML parsing */
    364. 

  364. { { 160, "nbsp" },
    365. 

  365.   { 161, "iexcl" },
    366. 

  366.   { 162, "cent" },
    367. 

  367.   { 163, "pound" },
    368. 

  368.   { 164, "curren" },
    369. 

  369.   { 165, "yen" },
    370. 

  370.   { 166, "brvbar" },
    371. 

  371.   { 167, "sect" },
    372. 

  372.   { 168, "uml" },
    373. 

  373.   { 169, "copy" },
    374. 

  374.   { 170, "ordf" },
    375. 

  375.   { 171, "laquo" },
    376. 

  376.   { 172, "not" },
    377. 

  377.   { 173, "shy" },
    378. 

  378.   { 174, "reg" },
    379. 

  379.   { 175, "macr" },
    380. 

  380.   { 176, "deg" },
    381. 

  381.   { 177, "plusmn" },
    382. 

  382.   { 178, "sup2" },
    383. 

  383.   { 179, "sup3" },
    384. 

  384.   { 180, "acute" },
    385. 

  385.   { 181, "micro" },
    386. 

  386.   { 182, "para" },
    387. 

  387.   { 183, "middot" },
    388. 

  388.   { 184, "cedil" },
    389. 

  389.   { 185, "sup1" },
    390. 

  390.   { 186, "ordm" },
    391. 

  391.   { 187, "raquo" },
    392. 

  392.   { 188, "frac14" },
    393. 

  393.   { 189, "frac12" },
    394. 

  394.   { 190, "frac34" },
    395. 

  395.   { 191, "iquest" },
    396. 

  396.   { 192, "Agrave" },
    397. 

  397.   { 193, "Aacute" },
    398. 

  398.   { 194, "Acirc" },
    399. 

  399.   { 195, "Atilde" },
    400. 

  400.   { 196, "Auml" },
    401. 

  401.   { 197, "Aring" },
    402. 

  402.   { 198, "AElig" },
    403. 

  403.   { 199, "Ccedil" },
    404. 

  404.   { 200, "Egrave" },
    405. 

  405.   { 201, "Eacute" },
    406. 

  406.   { 202, "Ecirc" },
    407. 

  407.   { 203, "Euml" },
    408. 

  408.   { 204, "Igrave" },
    409. 

  409.   { 205, "Iacute" },
    410. 

  410.   { 206, "Icirc" },
    411. 

  411.   { 207, "Iuml" },
    412. 

  412.   { 208, "ETH" },
    413. 

  413.   { 209, "Ntilde" },
    414. 

  414.   { 210, "Ograve" },
    415. 

  415.   { 211, "Oacute" },
    416. 

  416.   { 212, "Ocirc" },
    417. 

  417.   { 213, "Otilde" },
    418. 

  418.   { 214, "Ouml" },
    419. 

  419.   { 215, "times" },
    420. 

  420.   { 216, "Oslash" },
    421. 

  421.   { 217, "Ugrave" },
    422. 

  422.   { 218, "Uacute" },
    423. 

  423.   { 219, "Ucirc" },
    424. 

  424.   { 220, "Uuml" },
    425. 

  425.   { 221, "Yacute" },
    426. 

  426.   { 222, "THORN" },
    427. 

  427.   { 223, "szlig" },
    428. 

  428.   { 224, "agrave" },
    429. 

  429.   { 225, "aacute" },
    430. 

  430.   { 226, "acirc" },
    431. 

  431.   { 227, "atilde" },
    432. 

  432.   { 228, "auml" },
    433. 

  433.   { 229, "aring" },
    434. 

  434.   { 230, "aelig" },
    435. 

  435.   { 231, "ccedil" },
    436. 

  436.   { 232, "egrave" },
    437. 

  437.   { 233, "eacute" },
    438. 

  438.   { 234, "ecirc" },
    439. 

  439.   { 235, "euml" },
    440. 

  440.   { 236, "igrave" },
    441. 

  441.   { 237, "iacute" },
    442. 

  442.   { 238, "icirc" },
    443. 

  443.   { 239, "iuml" },
    444. 

  444.   { 240, "eth" },
    445. 

  445.   { 241, "ntilde" },
    446. 

  446.   { 242, "ograve" },
    447. 

  447.   { 243, "oacute" },
    448. 

  448.   { 244, "ocirc" },
    449. 

  449.   { 245, "otilde" },
    450. 

  450.   { 246, "ouml" },
    451. 

  451.   { 247, "divide" },
    452. 

  452.   { 248, "oslash" },
    453. 

  453.   { 249, "ugrave" },
    454. 

  454.   { 250, "uacute" },
    455. 

  455.   { 251, "ucirc" },
    456. 

  456.   { 252, "uuml" },
    457. 

  457.   { 253, "yacute" },
    458. 

  458.   { 254, "thorn" },
    459. 

  459.   { 255, "yuml" },
    460. 

  460.   {   0, NULL }
    461. 

  461. };
    462. 

  462. #endif
    463. 

  463. 

  464. #ifndef WITH_NOIO
    465. 

  465. #ifndef WITH_LEAN
    466. 

  466. static const struct soap_code_map h_error_codes[] =
    467. 

  467. {
    468. 

  468. #ifdef HOST_NOT_FOUND   
    469. 

  469.   { HOST_NOT_FOUND, "Host not found" },
    470. 

  470. #endif
    471. 

  471. #ifdef TRY_AGAIN
    472. 

  472.   { TRY_AGAIN, "Try Again" },
    473. 

  473. #endif
    474. 

  474. #ifdef NO_RECOVERY  
    475. 

  475.   { NO_RECOVERY, "No Recovery" },
    476. 

  476. #endif
    477. 

  477. #ifdef NO_DATA
    478. 

  478.   { NO_DATA, "No Data" },
    479. 

  479. #endif
    480. 

  480. #ifdef NO_ADDRESS
    481. 

  481.   { NO_ADDRESS, "No Address" },
    482. 

  482. #endif
    483. 

  483.   { 0, NULL }
    484. 

  484. };
    485. 

  485. #endif
    486. 

  486. #endif
    487. 

  487. 

  488. #ifndef WITH_NOHTTP
    489. 

  489. #ifndef WITH_LEAN
    490. 

  490. static const struct soap_code_map h_http_error_codes[] =
    491. 

  491. { { 200, "OK" },
    492. 

  492.   { 201, "Created" },
    493. 

  493.   { 202, "Accepted" },
    494. 

  494.   { 203, "Non-Authoritative Information" },
    495. 

  495.   { 204, "No Content" },
    496. 

  496.   { 205, "Reset Content" },
    497. 

  497.   { 206, "Partial Content" },
    498. 

  498.   { 300, "Multiple Choices" },
    499. 

  499.   { 301, "Moved Permanently" },
    500. 

  500.   { 302, "Found" },
    501. 

  501.   { 303, "See Other" },
    502. 

  502.   { 304, "Not Modified" },
    503. 

  503.   { 305, "Use Proxy" },
    504. 

  504.   { 307, "Temporary Redirect" },
    505. 

  505.   { 400, "Bad Request" },
    506. 

  506.   { 401, "Unauthorized" },
    507. 

  507.   { 402, "Payment Required" },
    508. 

  508.   { 403, "Forbidden" },
    509. 

  509.   { 404, "Not Found" },
    510. 

  510.   { 405, "Method Not Allowed" },
    511. 

  511.   { 406, "Not Acceptable" },
    512. 

  512.   { 407, "Proxy Authentication Required" },
    513. 

  513.   { 408, "Request Time-out" },
    514. 

  514.   { 409, "Conflict" },
    515. 

  515.   { 410, "Gone" },
    516. 

  516.   { 411, "Length Required" },
    517. 

  517.   { 412, "Precondition Failed" },
    518. 

  518.   { 413, "Request Entity Too Large" },
    519. 

  519.   { 414, "Request-URI Too Large" },
    520. 

  520.   { 415, "Unsupported Media Type" },
    521. 

  521.   { 416, "Requested range not satisfiable" },
    522. 

  522.   { 417, "Expectation Failed" },
    523. 

  523.   { 500, "Internal Server Error" },
    524. 

  524.   { 501, "Not Implemented" },
    525. 

  525.   { 502, "Bad Gateway" },
    526. 

  526.   { 503, "Service Unavailable" },
    527. 

  527.   { 504, "Gateway Time-out" },
    528. 

  528.   { 505, "HTTP Version not supported" },
    529. 

  529.   {   0, NULL }
    530. 

  530. };
    531. 

  531. #endif
    532. 

  532. #endif
    533. 

  533. 

  534. #ifdef WITH_OPENSSL
    535. 

  535. static const struct soap_code_map h_ssl_error_codes[] =
    536. 

  536. {
    537. 

  537. #define _SSL_ERROR(e) { e, #e }
    538. 

  538.   _SSL_ERROR(SSL_ERROR_SSL),
    539. 

  539.   _SSL_ERROR(SSL_ERROR_ZERO_RETURN),
    540. 

  540.   _SSL_ERROR(SSL_ERROR_WANT_READ),
    541. 

  541.   _SSL_ERROR(SSL_ERROR_WANT_WRITE),
    542. 

  542.   _SSL_ERROR(SSL_ERROR_WANT_CONNECT),
    543. 

  543.   _SSL_ERROR(SSL_ERROR_WANT_X509_LOOKUP),
    544. 

  544.   _SSL_ERROR(SSL_ERROR_SYSCALL),
    545. 

  545.   { 0, NULL }
    546. 

  546. };
    547. 

  547. #endif
    548. 

  548. 

  549. #ifndef WITH_LEANER
    550. 

  550. static const struct soap_code_map mime_codes[] =
    551. 

  551. { { SOAP_MIME_7BIT,		"7bit" },
    552. 

  552.   { SOAP_MIME_8BIT,		"8bit" },
    553. 

  553.   { SOAP_MIME_BINARY,		"binary" },
    554. 

  554.   { SOAP_MIME_QUOTED_PRINTABLE, "quoted-printable" },
    555. 

  555.   { SOAP_MIME_BASE64,		"base64" },
    556. 

  556.   { SOAP_MIME_IETF_TOKEN,	"ietf-token" },
    557. 

  557.   { SOAP_MIME_X_TOKEN,		"x-token" },
    558. 

  558.   { 0,				NULL }
    559. 

  559. };
    560. 

  560. #endif
    561. 

  561. 

  562. #ifdef WIN32
    563. 

  563. static int tcp_done = 0;
    564. 

  564. #endif
    565. 

  565. 

  566. #if defined(HP_UX) && defined(HAVE_GETHOSTBYNAME_R)
    567. 

  567. extern int h_errno;
    568. 

  568. #endif
    569. 

  569. 

  570. /******************************************************************************/
    571. 

  571. #ifndef WITH_NOIO
    572. 

  572. #ifndef PALM_1
    573. 

  573. static int
    574. 

  574. fsend(struct soap *soap, const char *s, size_t n)
    575. 

  575. { register int nwritten, err;
    576. 

  576. #if defined(__cplusplus) && !defined(WITH_LEAN) && !defined(WITH_COMPAT)
    577. 

  577.   if (soap->os)
    578. 

  578.   { soap->os->write(s, (std::streamsize)n);
    579. 

  579.     if (soap->os->good())
    580. 

  580.       return SOAP_OK;
    581. 

  581.     soap->errnum = 0;
    582. 

  582.     return SOAP_EOF;
    583. 

  583.   }
    584. 

  584. #endif
    585. 

  585.   while (n)
    586. 

  586.   { if (soap_valid_socket(soap->socket))
    587. 

  587.     { 
    588. 

  588.       if (soap->send_timeout)
    589. 

  589.       { for (;;)
    590. 

  590.         { register int r;
    591. 

  591. #ifdef WITH_OPENSSL
    592. 

  592.           if (soap->ssl)
    593. 

  593.             r = tcp_select(soap, soap->socket, SOAP_TCP_SELECT_ALL, soap->send_timeout);
    594. 

  594.           else
    595. 

  595. #endif
    596. 

  596.             r = tcp_select(soap, soap->socket, SOAP_TCP_SELECT_SND | SOAP_TCP_SELECT_ERR, soap->send_timeout);
    597. 

  597.           if (r > 0)
    598. 

  598.             break;
    599. 

  599.           if (!r)
    600. 

  600.             return SOAP_EOF;
    601. 

  601. 	  err = soap->errnum;
    602. 

  602. 	  if (!err)
    603. 

  603.             return soap->error;
    604. 

  604.           if (err != SOAP_EINTR && err != SOAP_EAGAIN && err != SOAP_EWOULDBLOCK)
    605. 

  605.             return SOAP_EOF;
    606. 

  606.         }
    607. 

  607.       }
    608. 

  608. #ifdef WITH_OPENSSL
    609. 

  609.       if (soap->ssl)
    610. 

  610.         nwritten = SSL_write(soap->ssl, s, (int)n);
    611. 

  611.       else if (soap->bio)
    612. 

  612.         nwritten = BIO_write(soap->bio, s, (int)n);
    613. 

  613.       else
    614. 

  614. #endif
    615. 

  615. #ifndef WITH_LEAN
    616. 

  616.       if ((soap->omode & SOAP_IO_UDP))
    617. 

  617.       { if (soap->peerlen)
    618. 

  618.           nwritten = sendto(soap->socket, (char*)s, (SOAP_WINSOCKINT)n, soap->socket_flags, (struct sockaddr*)&soap->peer, (SOAP_WINSOCKINT)soap->peerlen);
    619. 

  619.         else
    620. 

  620.           nwritten = send(soap->socket, s, (SOAP_WINSOCKINT)n, soap->socket_flags);
    621. 

  621.         /* retry and back-off algorithm */
    622. 

  622.         /* TODO: this is not very clear from specs so verify and limit conditions under which we should loop (e.g. ENOBUFS) */
    623. 

  623.         if (nwritten < 0)
    624. 

  624.         { int udp_repeat;
    625. 

  625.           int udp_delay;
    626. 

  626.           if ((soap->connect_flags & SO_BROADCAST))
    627. 

  627.             udp_repeat = 3; /* SOAP-over-UDP MULTICAST_UDP_REPEAT - 1 */
    628. 

  628.           else
    629. 

  629.             udp_repeat = 1; /* SOAP-over-UDP UNICAST_UDP_REPEAT - 1 */
    630. 

  630.           udp_delay = (soap_random % 201) + 50; /* UDP_MIN_DELAY .. UDP_MAX_DELAY */
    631. 

  631.           do
    632. 

  632.           { tcp_select(soap, soap->socket, SOAP_TCP_SELECT_ERR, -1000 * udp_delay);
    633. 

  633.             if (soap->peerlen)
    634. 

  634.               nwritten = sendto(soap->socket, (char*)s, (SOAP_WINSOCKINT)n, soap->socket_flags, (struct sockaddr*)&soap->peer, (SOAP_WINSOCKINT)soap->peerlen);
    635. 

  635.             else
    636. 

  636.               nwritten = send(soap->socket, s, (SOAP_WINSOCKINT)n, soap->socket_flags);
    637. 

  637.             udp_delay <<= 1;
    638. 

  638.             if (udp_delay > 500) /* UDP_UPPER_DELAY */
    639. 

  639.               udp_delay = 500;
    640. 

  640.           }
    641. 

  641.           while (nwritten < 0 && --udp_repeat > 0);
    642. 

  642.         }
    643. 

  643.       }
    644. 

  644.       else
    645. 

  645. #endif
    646. 

  646. #if !defined(PALM) && !defined(AS400)
    647. 

  647.         nwritten = send(soap->socket, s, (int)n, soap->socket_flags);
    648. 

  648. #else
    649. 

  649.         nwritten = send(soap->socket, (void*)s, n, soap->socket_flags);
    650. 

  650. #endif
    651. 

  651.       if (nwritten <= 0)
    652. 

  652.       {
    653. 

  653.         register int r = 0;
    654. 

  654.         err = soap_socket_errno(soap->socket);
    655. 

  655. #ifdef WITH_OPENSSL
    656. 

  656.         if (soap->ssl && (r = SSL_get_error(soap->ssl, nwritten)) != SSL_ERROR_NONE && r != SSL_ERROR_WANT_READ && r != SSL_ERROR_WANT_WRITE)
    657. 

  657.         { soap->errnum = err;
    658. 

  658.           return SOAP_EOF;
    659. 

  659.         }
    660. 

  660. #endif
    661. 

  661.         if (err == SOAP_EWOULDBLOCK || err == SOAP_EAGAIN)
    662. 

  662.         {
    663. 

  663. #ifdef WITH_OPENSSL
    664. 

  664.           if (soap->ssl && r == SSL_ERROR_WANT_READ)
    665. 

  665.             r = tcp_select(soap, soap->socket, SOAP_TCP_SELECT_RCV | SOAP_TCP_SELECT_ERR, soap->send_timeout ? soap->send_timeout : -10000);
    666. 

  666.           else
    667. 

  667.             r = tcp_select(soap, soap->socket, SOAP_TCP_SELECT_SND | SOAP_TCP_SELECT_ERR, soap->send_timeout ? soap->send_timeout : -10000);
    668. 

  668. #else
    669. 

  669.           r = tcp_select(soap, soap->socket, SOAP_TCP_SELECT_SND | SOAP_TCP_SELECT_ERR, soap->send_timeout ? soap->send_timeout : -10000);
    670. 

  670. #endif
    671. 

  671. 	  if (!r && soap->send_timeout)
    672. 

  672.             return SOAP_EOF;
    673. 

  673. 	  if (r < 0 && soap->errnum != SOAP_EINTR)
    674. 

  674.             return SOAP_EOF;
    675. 

  675.         }
    676. 

  676.         else if (err && err != SOAP_EINTR)
    677. 

  677.         { soap->errnum = err;
    678. 

  678.           return SOAP_EOF;
    679. 

  679.         }
    680. 

  680.         nwritten = 0; /* and call write() again */
    681. 

  681.       }
    682. 

  682.     }
    683. 

  683.     else
    684. 

  684.     {
    685. 

  685. #ifdef WITH_FASTCGI
    686. 

  686.       nwritten = fwrite((void*)s, 1, n, stdout);
    687. 

  687.       fflush(stdout);
    688. 

  688. #else
    689. 

  689. #ifdef UNDER_CE
    690. 

  690.       nwritten = fwrite(s, 1, n, soap->sendfd);
    691. 

  691. #else
    692. 

  692. #ifdef VXWORKS
    693. 

  693. #ifdef WMW_RPM_IO
    694. 

  694.       if (soap->rpmreqid)
    695. 

  695.         nwritten = (httpBlockPut(soap->rpmreqid, (char*)s, n) == 0) ? n : -1; 
    696. 

  696.       else
    697. 

  697. #endif
    698. 

  698.         nwritten = fwrite(s, sizeof(char), n, fdopen(soap->sendfd, "w"));
    699. 

  699. #else
    700. 

  700. #ifdef WIN32
    701. 

  701.       nwritten = _write(soap->sendfd, s, (unsigned int)n);
    702. 

  702. #else
    703. 

  703.       nwritten = write(soap->sendfd, s, (unsigned int)n);
    704. 

  704. #endif
    705. 

  705. #endif
    706. 

  706. #endif
    707. 

  707. #endif
    708. 

  708.       if (nwritten <= 0)
    709. 

  709.       { 
    710. 

  710. #ifndef WITH_FASTCGI
    711. 

  711.         err = soap_errno;
    712. 

  712. #else
    713. 

  713.         err = EOF;
    714. 

  714. #endif
    715. 

  715.         if (err && err != SOAP_EINTR && err != SOAP_EWOULDBLOCK && err != SOAP_EAGAIN)
    716. 

  716.         { soap->errnum = err;
    717. 

  717.           return SOAP_EOF;
    718. 

  718.         }
    719. 

  719.         nwritten = 0; /* and call write() again */
    720. 

  720.       }
    721. 

  721.     }
    722. 

  722.     n -= nwritten;
    723. 

  723.     s += nwritten;
    724. 

  724.   }
    725. 

  725.   return SOAP_OK;
    726. 

  726. }
    727. 

  727. #endif
    728. 

  728. #endif
    729. 

  729. 

  730. /******************************************************************************/
    731. 

  731. #ifndef PALM_1
    732. 

  732. SOAP_FMAC1
    733. 

  733. int
    734. 

  734. SOAP_FMAC2
    735. 

  735. soap_send_raw(struct soap *soap, const char *s, size_t n)
    736. 

  736. { if (!n)
    737. 

  737.     return SOAP_OK;
    738. 

  738.   if (soap->mode & SOAP_IO_LENGTH)
    739. 

  739.   { soap->count += n;
    740. 

  740. #ifndef WITH_LEANER
    741. 

  741.     if (soap->fpreparesend && (soap->mode & SOAP_IO) != SOAP_IO_STORE)
    742. 

  742.       return soap->error = soap->fpreparesend(soap, s, n);
    743. 

  743. #endif
    744. 

  744.     return SOAP_OK;
    745. 

  745.   }
    746. 

  746.   if (soap->mode & SOAP_IO)
    747. 

  747.   { register size_t i = SOAP_BUFLEN - soap->bufidx;
    748. 

  748.     while (n >= i)
    749. 

  749.     { memcpy(soap->buf + soap->bufidx, s, i);
    750. 

  750.       soap->bufidx = SOAP_BUFLEN;
    751. 

  751.       if (soap_flush(soap))
    752. 

  752.         return soap->error;
    753. 

  753.       s += i;
    754. 

  754.       n -= i;
    755. 

  755.       i = SOAP_BUFLEN;
    756. 

  756.     }
    757. 

  757.     memcpy(soap->buf + soap->bufidx, s, n);
    758. 

  758.     soap->bufidx += n;
    759. 

  759.     return SOAP_OK;
    760. 

  760.   }
    761. 

  761.   return soap_flush_raw(soap, s, n);
    762. 

  762. }
    763. 

  763. #endif
    764. 

  764. 

  765. /******************************************************************************/
    766. 

  766. #ifndef PALM_1
    767. 

  767. SOAP_FMAC1
    768. 

  768. int
    769. 

  769. SOAP_FMAC2
    770. 

  770. soap_flush(struct soap *soap)
    771. 

  771. { register size_t n = soap->bufidx;
    772. 

  772.   if (n)
    773. 

  773.   {
    774. 

  774. #ifndef WITH_LEANER
    775. 

  775.     if ((soap->mode & SOAP_IO) == SOAP_IO_STORE)
    776. 

  776.     { register int r;
    777. 

  777.       if (soap->fpreparesend && (r = soap->fpreparesend(soap, soap->buf, n)))
    778. 

  778.         return soap->error = r;
    779. 

  779.     }
    780. 

  780. #endif
    781. 

  781.     soap->bufidx = 0;
    782. 

  782. #ifdef WITH_ZLIB
    783. 

  783.     if (soap->mode & SOAP_ENC_ZLIB)
    784. 

  784.     { soap->d_stream->next_in = (Byte*)soap->buf;
    785. 

  785.       soap->d_stream->avail_in = (unsigned int)n;
    786. 

  786. #ifdef WITH_GZIP
    787. 

  787.       soap->z_crc = crc32(soap->z_crc, (Byte*)soap->buf, (unsigned int)n);
    788. 

  788. #endif
    789. 

  789.       do
    790. 

  790.       { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Deflating %u bytes\n", soap->d_stream->avail_in));
    791. 

  791.         if (deflate(soap->d_stream, Z_NO_FLUSH) != Z_OK)
    792. 

  792.         { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unable to deflate: %s\n", soap->d_stream->msg?soap->d_stream->msg:SOAP_STR_EOS));
    793. 

  793.           return soap->error = SOAP_ZLIB_ERROR;
    794. 

  794.         }
    795. 

  795.         if (!soap->d_stream->avail_out)
    796. 

  796.         { if (soap_flush_raw(soap, soap->z_buf, SOAP_BUFLEN))
    797. 

  797.             return soap->error;
    798. 

  798.           soap->d_stream->next_out = (Byte*)soap->z_buf;
    799. 

  799.           soap->d_stream->avail_out = SOAP_BUFLEN;
    800. 

  800.         }
    801. 

  801.       } while (soap->d_stream->avail_in);
    802. 

  802.     }
    803. 

  803.     else
    804. 

  804. #endif
    805. 

  805.       return soap_flush_raw(soap, soap->buf, n);
    806. 

  806.   }
    807. 

  807.   return SOAP_OK;
    808. 

  808. }
    809. 

  809. #endif
    810. 

  810. 

  811. /******************************************************************************/
    812. 

  812. #ifndef PALM_1
    813. 

  813. SOAP_FMAC1
    814. 

  814. int
    815. 

  815. SOAP_FMAC2
    816. 

  816. soap_flush_raw(struct soap *soap, const char *s, size_t n)
    817. 

  817. { if ((soap->mode & SOAP_IO) == SOAP_IO_STORE)
    818. 

  818.   { register char *t;
    819. 

  819.     if (!(t = (char*)soap_push_block(soap, NULL, n)))
    820. 

  820.       return soap->error = SOAP_EOM;
    821. 

  821.     memcpy(t, s, n);
    822. 

  822.     return SOAP_OK;
    823. 

  823.   }
    824. 

  824. #ifndef WITH_LEANER
    825. 

  825.   if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK)
    826. 

  826.   { char t[16];
    827. 

  827.     sprintf(t, "\r\n%lX\r\n" + (soap->chunksize ? 0 : 2), (unsigned long)n);
    828. 

  828.     DBGMSG(SENT, t, strlen(t));
    829. 

  829.     if ((soap->error = soap->fsend(soap, t, strlen(t))))
    830. 

  830.       return soap->error;
    831. 

  831.     soap->chunksize += n;
    832. 

  832.   }
    833. 

  833.   DBGMSG(SENT, s, n);
    834. 

  834. #endif
    835. 

  835.   return soap->error = soap->fsend(soap, s, n);
    836. 

  836. }
    837. 

  837. #endif
    838. 

  838. 

  839. /******************************************************************************/
    840. 

  840. #ifndef PALM_1
    841. 

  841. SOAP_FMAC1
    842. 

  842. int
    843. 

  843. SOAP_FMAC2
    844. 

  844. soap_send(struct soap *soap, const char *s)
    845. 

  845. { if (s)
    846. 

  846.     return soap_send_raw(soap, s, strlen(s));
    847. 

  847.   return SOAP_OK;
    848. 

  848. }
    849. 

  849. #endif
    850. 

  850. 

  851. /******************************************************************************/
    852. 

  852. #ifndef WITH_LEANER
    853. 

  853. #ifndef PALM_1
    854. 

  854. SOAP_FMAC1
    855. 

  855. int
    856. 

  856. SOAP_FMAC2
    857. 

  857. soap_send2(struct soap *soap, const char *s1, const char *s2)
    858. 

  858. { if (soap_send(soap, s1))
    859. 

  859.     return soap->error;
    860. 

  860.   return soap_send(soap, s2);
    861. 

  861. }
    862. 

  862. #endif
    863. 

  863. #endif
    864. 

  864. 

  865. /******************************************************************************/
    866. 

  866. #ifndef WITH_LEANER
    867. 

  867. #ifndef PALM_1
    868. 

  868. SOAP_FMAC1
    869. 

  869. int
    870. 

  870. SOAP_FMAC2
    871. 

  871. soap_send3(struct soap *soap, const char *s1, const char *s2, const char *s3)
    872. 

  872. { if (soap_send(soap, s1)
    873. 

  873.    || soap_send(soap, s2))
    874. 

  874.     return soap->error;
    875. 

  875.   return soap_send(soap, s3);
    876. 

  876. }
    877. 

  877. #endif
    878. 

  878. #endif
    879. 

  879. 

  880. /******************************************************************************/
    881. 

  881. #ifndef WITH_NOIO
    882. 

  882. #ifndef PALM_1
    883. 

  883. static size_t
    884. 

  884. frecv(struct soap *soap, char *s, size_t n)
    885. 

  885. { register int r;
    886. 

  886.   register int retries = 100; /* max 100 retries with non-blocking sockets */
    887. 

  887.   soap->errnum = 0;
    888. 

  888. #if defined(__cplusplus) && !defined(WITH_LEAN) && !defined(WITH_COMPAT)
    889. 

  889.   if (soap->is)
    890. 

  890.   { if (soap->is->good())
    891. 

  891.       return soap->is->read(s, (std::streamsize)n).gcount();
    892. 

  892.     return 0;
    893. 

  893.   }
    894. 

  894. #endif
    895. 

  895.   if (soap_valid_socket(soap->socket))
    896. 

  896.   { for (;;)
    897. 

  897.     { 
    898. 

  898. #ifdef WITH_OPENSSL
    899. 

  899.       register int err = 0;
    900. 

  900. #endif
    901. 

  901. #ifdef WITH_OPENSSL
    902. 

  902.       if (soap->recv_timeout && !soap->ssl) /* SSL: sockets are nonblocking */
    903. 

  903. #else
    904. 

  904.       if (soap->recv_timeout)
    905. 

  905. #endif
    906. 

  906.       { for (;;)
    907. 

  907.         { r = tcp_select(soap, soap->socket, SOAP_TCP_SELECT_RCV | SOAP_TCP_SELECT_ERR, soap->recv_timeout);
    908. 

  908.           if (r > 0)
    909. 

  909.             break;
    910. 

  910.           if (!r)
    911. 

  911.             return 0;
    912. 

  912. 	  r = soap->errnum;
    913. 

  913.           if (r != SOAP_EINTR && r != SOAP_EAGAIN && r != SOAP_EWOULDBLOCK)
    914. 

  914.             return 0;
    915. 

  915.         }
    916. 

  916.       }
    917. 

  917. #ifdef WITH_OPENSSL
    918. 

  918.       if (soap->ssl)
    919. 

  919.       { r = SSL_read(soap->ssl, s, (int)n);
    920. 

  920.         if (r > 0)
    921. 

  921.           return (size_t)r;
    922. 

  922.         err = SSL_get_error(soap->ssl, r);
    923. 

  923.         if (err != SSL_ERROR_NONE && err != SSL_ERROR_WANT_READ && err != SSL_ERROR_WANT_WRITE)
    924. 

  924.           return 0;
    925. 

  925.       }
    926. 

  926.       else if (soap->bio)
    927. 

  927.       { r = BIO_read(soap->bio, s, (int)n);
    928. 

  928.         if (r > 0)
    929. 

  929.           return (size_t)r;
    930. 

  930.         return 0;
    931. 

  931.       }
    932. 

  932.       else
    933. 

  933. #endif
    934. 

  934.       { 
    935. 

  935. #ifndef WITH_LEAN
    936. 

  936.         if ((soap->omode & SOAP_IO_UDP))
    937. 

  937.         { SOAP_SOCKLEN_T k = (SOAP_SOCKLEN_T)sizeof(soap->peer);
    938. 

  938.           memset((void*)&soap->peer, 0, sizeof(soap->peer));
    939. 

  939.           r = recvfrom(soap->socket, s, (SOAP_WINSOCKINT)n, soap->socket_flags, (struct sockaddr*)&soap->peer, &k);	/* portability note: see SOAP_SOCKLEN_T definition in stdsoap2.h */
    940. 

  940.           soap->peerlen = (size_t)k;
    941. 

  941. #ifndef WITH_IPV6
    942. 

  942.           soap->ip = ntohl(soap->peer.sin_addr.s_addr);
    943. 

  943. #endif
    944. 

  944.         }
    945. 

  945.         else
    946. 

  946. #endif
    947. 

  947.           r = recv(soap->socket, s, (int)n, soap->socket_flags);
    948. 

  948. #ifdef PALM
    949. 

  949.         /* CycleSyncDisplay(curStatusMsg); */
    950. 

  950. #endif
    951. 

  951.         if (r >= 0)
    952. 

  952.           return (size_t)r;
    953. 

  953.         r = soap_socket_errno(soap->socket);
    954. 

  954.         if (r != SOAP_EINTR && r != SOAP_EAGAIN && r != SOAP_EWOULDBLOCK)
    955. 

  955.         { soap->errnum = r;
    956. 

  956.           return 0;
    957. 

  957.         }
    958. 

  958.       }
    959. 

  959. #ifdef WITH_OPENSSL
    960. 

  960.       if (soap->ssl && err == SSL_ERROR_WANT_WRITE)
    961. 

  961.          r = tcp_select(soap, soap->socket, SOAP_TCP_SELECT_SND | SOAP_TCP_SELECT_ERR, soap->recv_timeout ? soap->recv_timeout : 5);
    962. 

  962.        else
    963. 

  963.          r = tcp_select(soap, soap->socket, SOAP_TCP_SELECT_RCV | SOAP_TCP_SELECT_ERR, soap->recv_timeout ? soap->recv_timeout : 5);
    964. 

  964. #else
    965. 

  965.        r = tcp_select(soap, soap->socket, SOAP_TCP_SELECT_RCV | SOAP_TCP_SELECT_ERR, soap->recv_timeout ? soap->recv_timeout : 5);
    966. 

  966. #endif
    967. 

  967.        if (!r && soap->recv_timeout)
    968. 

  968.          return 0;
    969. 

  969.        if (r < 0)
    970. 

  970.        { r = soap->errnum;
    971. 

  971.          if (r != SOAP_EINTR && r != SOAP_EAGAIN && r != SOAP_EWOULDBLOCK)
    972. 

  972.            return 0;
    973. 

  973.        }
    974. 

  974.        if (retries-- <= 0)
    975. 

  975.          return 0;
    976. 

  976. #ifdef PALM
    977. 

  977.       r = soap_socket_errno(soap->socket);
    978. 

  978.       if (r != SOAP_EINTR && retries-- <= 0)
    979. 

  979.       { soap->errnum = r;
    980. 

  980.         return 0;
    981. 

  981.       }
    982. 

  982. #endif
    983. 

  983.     }
    984. 

  984.   }
    985. 

  985. #ifdef WITH_FASTCGI
    986. 

  986.   return fread(s, 1, n, stdin);
    987. 

  987. #else
    988. 

  988. #ifdef UNDER_CE
    989. 

  989.   return fread(s, 1, n, soap->recvfd);
    990. 

  990. #else
    991. 

  991. #ifdef WMW_RPM_IO
    992. 

  992.   if (soap->rpmreqid)
    993. 

  993.     r = httpBlockRead(soap->rpmreqid, s, n);
    994. 

  994.   else
    995. 

  995. #endif
    996. 

  996. #ifdef WIN32
    997. 

  997.     r = _read(soap->recvfd, s, (unsigned int)n);
    998. 

  998. #else
    999. 

  999.     r = read(soap->recvfd, s, (unsigned int)n);
    1000. 

  1000. #endif
    1001. 

  1001.   if (r >= 0)
    1002. 

  1002.     return (size_t)r;
    1003. 

  1003.   soap->errnum = soap_errno;
    1004. 

  1004.   return 0;
    1005. 

  1005. #endif
    1006. 

  1006. #endif
    1007. 

  1007. }
    1008. 

  1008. #endif
    1009. 

  1009. #endif
    1010. 

  1010. 

  1011. /******************************************************************************/
    1012. 

  1012. #ifndef WITH_NOHTTP
    1013. 

  1013. #ifndef PALM_1
    1014. 

  1014. static soap_wchar
    1015. 

  1015. soap_getchunkchar(struct soap *soap)
    1016. 

  1016. { if (soap->bufidx < soap->buflen)
    1017. 

  1017.     return soap->buf[soap->bufidx++];
    1018. 

  1018.   soap->bufidx = 0;
    1019. 

  1019.   soap->buflen = soap->chunkbuflen = soap->frecv(soap, soap->buf, SOAP_BUFLEN);
    1020. 

  1020.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Read %u bytes from socket %d\n", (unsigned int)soap->buflen, soap->socket));
    1021. 

  1021.   DBGMSG(RECV, soap->buf, soap->buflen);
    1022. 

  1022.   if (soap->buflen)
    1023. 

  1023.     return soap->buf[soap->bufidx++];
    1024. 

  1024.   return EOF;
    1025. 

  1025. }
    1026. 

  1026. #endif
    1027. 

  1027. #endif
    1028. 

  1028. 

  1029. /******************************************************************************/
    1030. 

  1030. #ifndef PALM_1
    1031. 

  1031. static int
    1032. 

  1032. soap_isxdigit(int c)
    1033. 

  1033. { return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f');
    1034. 

  1034. }
    1035. 

  1035. #endif
    1036. 

  1036. 

  1037. /******************************************************************************/
    1038. 

  1038. #ifndef PALM_1
    1039. 

  1039. SOAP_FMAC1
    1040. 

  1040. int
    1041. 

  1041. SOAP_FMAC2
    1042. 

  1042. soap_recv_raw(struct soap *soap)
    1043. 

  1043. { register size_t ret;
    1044. 

  1044. #if !defined(WITH_LEANER) || defined(WITH_ZLIB)
    1045. 

  1045.   register int r;
    1046. 

  1046. #endif
    1047. 

  1047. #ifdef WITH_ZLIB
    1048. 

  1048.   if (soap->mode & SOAP_ENC_ZLIB)
    1049. 

  1049.   { if (soap->d_stream->next_out == Z_NULL)
    1050. 

  1050.       return EOF;
    1051. 

  1051.     if (soap->d_stream->avail_in || !soap->d_stream->avail_out)
    1052. 

  1052.     { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflating\n"));
    1053. 

  1053.       soap->d_stream->next_out = (Byte*)soap->buf;
    1054. 

  1054.       soap->d_stream->avail_out = SOAP_BUFLEN;
    1055. 

  1055.       r = inflate(soap->d_stream, Z_NO_FLUSH);
    1056. 

  1056.       if (r == Z_NEED_DICT && soap->z_dict)
    1057. 

  1057. 	r = inflateSetDictionary(soap->d_stream, (const Bytef*)soap->z_dict, soap->z_dict_len);
    1058. 

  1058.       if (r == Z_OK || r == Z_STREAM_END)
    1059. 

  1059.       { soap->bufidx = 0;
    1060. 

  1060.         ret = soap->buflen = SOAP_BUFLEN - soap->d_stream->avail_out;
    1061. 

  1061.         if (soap->zlib_in == SOAP_ZLIB_GZIP)
    1062. 

  1062.           soap->z_crc = crc32(soap->z_crc, (Byte*)soap->buf, (unsigned int)ret);
    1063. 

  1063.         if (r == Z_STREAM_END)
    1064. 

  1064.         { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflated %lu->%lu bytes\n", soap->d_stream->total_in, soap->d_stream->total_out));
    1065. 

  1065.           soap->z_ratio_in = (float)soap->d_stream->total_in / (float)soap->d_stream->total_out;
    1066. 

  1066.           soap->d_stream->next_out = Z_NULL;
    1067. 

  1067.         }
    1068. 

  1068.         if (ret)
    1069. 

  1069.         { soap->count += ret;
    1070. 

  1070.           DBGLOG(RECV, SOAP_MESSAGE(fdebug, "\n---- decompressed ----\n"));
    1071. 

  1071.           DBGMSG(RECV, soap->buf, ret);
    1072. 

  1072.           DBGLOG(RECV, SOAP_MESSAGE(fdebug, "\n----\n"));
    1073. 

  1073. #ifndef WITH_LEANER
    1074. 

  1074.           if (soap->fpreparerecv && (r = soap->fpreparerecv(soap, soap->buf, ret)))
    1075. 

  1075.             return soap->error = r;
    1076. 

  1076. #endif
    1077. 

  1077.           return SOAP_OK;
    1078. 

  1078.         }
    1079. 

  1079.       }
    1080. 

  1080.       else if (r != Z_BUF_ERROR)
    1081. 

  1081.       { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflate error: %s\n", soap->d_stream->msg?soap->d_stream->msg:SOAP_STR_EOS));
    1082. 

  1082.         soap->d_stream->next_out = Z_NULL;
    1083. 

  1083.         soap->error = SOAP_ZLIB_ERROR;
    1084. 

  1084.         return EOF;
    1085. 

  1085.       }
    1086. 

  1086.     }
    1087. 

  1087. zlib_again:
    1088. 

  1088.     if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK && !soap->chunksize)
    1089. 

  1089.     { memcpy(soap->buf, soap->z_buf, SOAP_BUFLEN);
    1090. 

  1090.       soap->buflen = soap->z_buflen;
    1091. 

  1091.     }
    1092. 

  1092.     DBGLOG(RECV, SOAP_MESSAGE(fdebug, "\n---- compressed ----\n"));
    1093. 

  1093.   }
    1094. 

  1094. #endif
    1095. 

  1095. #ifndef WITH_NOHTTP
    1096. 

  1096.   if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK) /* read HTTP chunked transfer */
    1097. 

  1097.   { for (;;)
    1098. 

  1098.     { register soap_wchar c;
    1099. 

  1099.       char *t, tmp[8];
    1100. 

  1100.       if (soap->chunksize)
    1101. 

  1101.       { soap->buflen = ret = soap->frecv(soap, soap->buf, soap->chunksize > SOAP_BUFLEN ? SOAP_BUFLEN : soap->chunksize);
    1102. 

  1102.         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Getting chunk: read %u bytes\n", (unsigned int)ret));
    1103. 

  1103.         DBGMSG(RECV, soap->buf, ret);
    1104. 

  1104.         soap->bufidx = 0;
    1105. 

  1105.         soap->chunksize -= ret;
    1106. 

  1106.         break;
    1107. 

  1107.       }
    1108. 

  1108.       t = tmp;
    1109. 

  1109.       if (!soap->chunkbuflen)
    1110. 

  1110.       { soap->chunkbuflen = ret = soap->frecv(soap, soap->buf, SOAP_BUFLEN);
    1111. 

  1111.         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Read %u bytes (chunked) from socket %d\n", (unsigned int)ret, soap->socket));
    1112. 

  1112.         DBGMSG(RECV, soap->buf, ret);
    1113. 

  1113.         soap->bufidx = 0;
    1114. 

  1114.         if (!ret)
    1115. 

  1115.           return soap->ahead = EOF;
    1116. 

  1116.       }
    1117. 

  1117.       else
    1118. 

  1118.         soap->bufidx = soap->buflen;
    1119. 

  1119.       soap->buflen = soap->chunkbuflen;
    1120. 

  1120.       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Getting chunk size (idx=%u len=%u)\n", (unsigned int)soap->bufidx, (unsigned int)soap->buflen));
    1121. 

  1121.       while (!soap_isxdigit((int)(c = soap_getchunkchar(soap))))
    1122. 

  1122.       { if ((int)c == EOF)
    1123. 

  1123.           return soap->ahead = EOF;
    1124. 

  1124.       }
    1125. 

  1125.       do
    1126. 

  1126.         *t++ = (char)c;
    1127. 

  1127.       while (soap_isxdigit((int)(c = soap_getchunkchar(soap))) && t - tmp < 7);
    1128. 

  1128.       while ((int)c != EOF && c != '\n')
    1129. 

  1129.         c = soap_getchunkchar(soap);
    1130. 

  1130.       if ((int)c == EOF)
    1131. 

  1131.         return soap->ahead = EOF;
    1132. 

  1132.       *t = '\0';
    1133. 

  1133.       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Chunk size = %s (hex)\n", tmp));
    1134. 

  1134.       soap->chunksize = soap_strtoul(tmp, &t, 16);
    1135. 

  1135.       if (!soap->chunksize)
    1136. 

  1136.       { soap->chunkbuflen = 0;
    1137. 

  1137.         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End of chunked message\n"));
    1138. 

  1138.         while ((int)c != EOF && c != '\n')
    1139. 

  1139.           c = soap_getchunkchar(soap);
    1140. 

  1140.         ret = 0;
    1141. 

  1141.         soap->ahead = EOF;
    1142. 

  1142. 	break;
    1143. 

  1143.       }
    1144. 

  1144.       soap->buflen = soap->bufidx + soap->chunksize;
    1145. 

  1145.       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Moving buf len to idx=%u len=%u (%s)\n", (unsigned int)soap->bufidx, (unsigned int)soap->buflen, tmp));
    1146. 

  1146.       if (soap->buflen > soap->chunkbuflen)
    1147. 

  1147.       { soap->buflen = soap->chunkbuflen;
    1148. 

  1148.         soap->chunksize -= soap->buflen - soap->bufidx;
    1149. 

  1149.         soap->chunkbuflen = 0;
    1150. 

  1150.         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Passed end of buffer for chunked HTTP (%u bytes left)\n", (unsigned int)(soap->buflen - soap->bufidx)));
    1151. 

  1151.       }
    1152. 

  1152.       else if (soap->chunkbuflen)
    1153. 

  1153.         soap->chunksize = 0;
    1154. 

  1154.       ret = soap->buflen - soap->bufidx;
    1155. 

  1155.       if (ret)
    1156. 

  1156.         break;
    1157. 

  1157.     }
    1158. 

  1158.   }
    1159. 

  1159.   else
    1160. 

  1160. #endif
    1161. 

  1161.   { soap->bufidx = 0;
    1162. 

  1162.     soap->buflen = ret = soap->frecv(soap, soap->buf, SOAP_BUFLEN);
    1163. 

  1163.     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Read %u bytes from socket %d\n", (unsigned int)ret, soap->socket));
    1164. 

  1164.     DBGMSG(RECV, soap->buf, ret);
    1165. 

  1165.   }
    1166. 

  1166. #ifdef WITH_ZLIB
    1167. 

  1167.   if (soap->mode & SOAP_ENC_ZLIB)
    1168. 

  1168.   { memcpy(soap->z_buf, soap->buf, SOAP_BUFLEN);
    1169. 

  1169.     soap->d_stream->next_in = (Byte*)(soap->z_buf + soap->bufidx);
    1170. 

  1170.     soap->d_stream->avail_in = (unsigned int)ret;
    1171. 

  1171.     soap->d_stream->next_out = (Byte*)soap->buf;
    1172. 

  1172.     soap->d_stream->avail_out = SOAP_BUFLEN;
    1173. 

  1173.     r = inflate(soap->d_stream, Z_NO_FLUSH);
    1174. 

  1174.     if (r == Z_NEED_DICT && soap->z_dict)
    1175. 

  1175.       r = inflateSetDictionary(soap->d_stream, (const Bytef*)soap->z_dict, soap->z_dict_len);
    1176. 

  1176.     if (r == Z_OK || r == Z_STREAM_END)
    1177. 

  1177.     { soap->bufidx = 0;
    1178. 

  1178.       soap->z_buflen = soap->buflen;
    1179. 

  1179.       soap->buflen = SOAP_BUFLEN - soap->d_stream->avail_out;
    1180. 

  1180.       if (soap->zlib_in == SOAP_ZLIB_GZIP)
    1181. 

  1181.         soap->z_crc = crc32(soap->z_crc, (Byte*)soap->buf, (unsigned int)soap->buflen);
    1182. 

  1182.       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflated %u bytes\n", (unsigned int)soap->buflen));
    1183. 

  1183.       if (ret && !soap->buflen && r != Z_STREAM_END)
    1184. 

  1184.         goto zlib_again;
    1185. 

  1185.       ret = soap->buflen;
    1186. 

  1186.       if (r == Z_STREAM_END)
    1187. 

  1187.       { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflated total %lu->%lu bytes\n", soap->d_stream->total_in, soap->d_stream->total_out));
    1188. 

  1188.         soap->z_ratio_in = (float)soap->d_stream->total_in / (float)soap->d_stream->total_out;
    1189. 

  1189.         soap->d_stream->next_out = Z_NULL;
    1190. 

  1190.       }
    1191. 

  1191.       DBGLOG(RECV, SOAP_MESSAGE(fdebug, "\n---- decompressed ----\n"));
    1192. 

  1192.       DBGMSG(RECV, soap->buf, ret);
    1193. 

  1193. #ifndef WITH_LEANER
    1194. 

  1194.       if (soap->fpreparerecv && (r = soap->fpreparerecv(soap, soap->buf, ret)))
    1195. 

  1195.         return soap->error = r;
    1196. 

  1196. #endif
    1197. 

  1197.     }
    1198. 

  1198.     else
    1199. 

  1199.     { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unable to inflate: (%d) %s\n", r, soap->d_stream->msg?soap->d_stream->msg:SOAP_STR_EOS));
    1200. 

  1200.       soap->d_stream->next_out = Z_NULL;
    1201. 

  1201.       soap->error = SOAP_ZLIB_ERROR;
    1202. 

  1202.       return EOF;
    1203. 

  1203.     }
    1204. 

  1204.   }
    1205. 

  1205. #endif
    1206. 

  1206. #ifndef WITH_LEANER
    1207. 

  1207.   if (soap->fpreparerecv
    1208. 

  1208. #ifdef WITH_ZLIB
    1209. 

  1209.    && soap->zlib_in == SOAP_ZLIB_NONE
    1210. 

  1210. #endif
    1211. 

  1211.    && (r = soap->fpreparerecv(soap, soap->buf + soap->bufidx, ret)))
    1212. 

  1212.     return soap->error = r;
    1213. 

  1213. #endif
    1214. 

  1214.   soap->count += ret;
    1215. 

  1215.   return !ret;
    1216. 

  1216. }
    1217. 

  1217. #endif
    1218. 

  1218. 

  1219. /******************************************************************************/
    1220. 

  1220. #ifndef PALM_1
    1221. 

  1221. SOAP_FMAC1
    1222. 

  1222. int
    1223. 

  1223. SOAP_FMAC2
    1224. 

  1224. soap_recv(struct soap *soap)
    1225. 

  1225. { 
    1226. 

  1226. #ifndef WITH_LEANER
    1227. 

  1227.   if (soap->mode & SOAP_ENC_DIME)
    1228. 

  1228.   { if (soap->dime.buflen)
    1229. 

  1229.     { char *s;
    1230. 

  1230.       int i;
    1231. 

  1231.       unsigned char tmp[12];
    1232. 

  1232.       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "DIME hdr for chunked DIME is in buffer\n"));
    1233. 

  1233.       soap->count += soap->dime.buflen - soap->buflen;
    1234. 

  1234.       soap->buflen = soap->dime.buflen;
    1235. 

  1235.       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Skip padding (%ld bytes)\n", -(long)soap->dime.size&3));
    1236. 

  1236.       for (i = -(long)soap->dime.size&3; i > 0; i--)
    1237. 

  1237.       { soap->bufidx++;
    1238. 

  1238.         if (soap->bufidx >= soap->buflen)
    1239. 

  1239.           if (soap_recv_raw(soap))
    1240. 

  1240.             return EOF;
    1241. 

  1241.       }
    1242. 

  1242.       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Get DIME hdr for next chunk\n"));
    1243. 

  1243.       s = (char*)tmp;
    1244. 

  1244.       for (i = 12; i > 0; i--)
    1245. 

  1245.       { *s++ = soap->buf[soap->bufidx++];
    1246. 

  1246.         if (soap->bufidx >= soap->buflen)
    1247. 

  1247.           if (soap_recv_raw(soap))
    1248. 

  1248.             return EOF;
    1249. 

  1249.       }
    1250. 

  1250.       soap->dime.flags = tmp[0] & 0x7;
    1251. 

  1251.       soap->dime.size = ((size_t)tmp[8] << 24) | ((size_t)tmp[9] << 16) | ((size_t)tmp[10] << 8) | ((size_t)tmp[11]);
    1252. 

  1252.       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Get DIME chunk (%u bytes)\n", (unsigned int)soap->dime.size));
    1253. 

  1253.       if (soap->dime.flags & SOAP_DIME_CF)
    1254. 

  1254.       { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "More chunking\n"));
    1255. 

  1255.         soap->dime.chunksize = soap->dime.size;
    1256. 

  1256.         if (soap->buflen - soap->bufidx >= soap->dime.size)
    1257. 

  1257.         { soap->dime.buflen = soap->buflen;
    1258. 

  1258.           soap->buflen = soap->bufidx + soap->dime.chunksize;
    1259. 

  1259.         }
    1260. 

  1260.         else
    1261. 

  1261.           soap->dime.chunksize -= soap->buflen - soap->bufidx;
    1262. 

  1262.       }
    1263. 

  1263.       else
    1264. 

  1264.       { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Last chunk\n"));
    1265. 

  1265.         soap->dime.buflen = 0;
    1266. 

  1266.         soap->dime.chunksize = 0;
    1267. 

  1267.       }
    1268. 

  1268.       soap->count = soap->buflen - soap->bufidx;
    1269. 

  1269.       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "%u bytes remaining\n", (unsigned int)soap->count));
    1270. 

  1270.       return SOAP_OK;
    1271. 

  1271.     }
    1272. 

  1272.     if (soap->dime.chunksize)
    1273. 

  1273.     { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Get next DIME hdr for chunked DIME (%u bytes chunk)\n", (unsigned int)soap->dime.chunksize));
    1274. 

  1274.       if (soap_recv_raw(soap))
    1275. 

  1275.         return EOF;
    1276. 

  1276.       if (soap->buflen - soap->bufidx >= soap->dime.chunksize)
    1277. 

  1277.       { soap->dime.buflen = soap->buflen;
    1278. 

  1278.         soap->count -= soap->buflen - soap->bufidx - soap->dime.chunksize;
    1279. 

  1279.         soap->buflen = soap->bufidx + soap->dime.chunksize;
    1280. 

  1280.       }
    1281. 

  1281.       else
    1282. 

  1282.         soap->dime.chunksize -= soap->buflen - soap->bufidx;
    1283. 

  1283.       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "%lu bytes remaining, count=%u\n", (unsigned long)(soap->buflen-soap->bufidx), (unsigned int)soap->count));
    1284. 

  1284.       return SOAP_OK;
    1285. 

  1285.     }
    1286. 

  1286.   }
    1287. 

  1287. #endif
    1288. 

  1288.   return soap_recv_raw(soap);
    1289. 

  1289. }
    1290. 

  1290. #endif
    1291. 

  1291. 

  1292. /******************************************************************************/
    1293. 

  1293. #ifndef PALM_1
    1294. 

  1294. SOAP_FMAC1
    1295. 

  1295. soap_wchar
    1296. 

  1296. SOAP_FMAC2
    1297. 

  1297. soap_getchar(struct soap *soap)
    1298. 

  1298. { register soap_wchar c;
    1299. 

  1299.   c = soap->ahead;
    1300. 

  1300.   if (c)
    1301. 

  1301.   { if (c != EOF)
    1302. 

  1302.       soap->ahead = 0;
    1303. 

  1303.     return c;
    1304. 

  1304.   }
    1305. 

  1305.   return soap_get1(soap);
    1306. 

  1306. }
    1307. 

  1307. #endif
    1308. 

  1308. 

  1309. /******************************************************************************/
    1310. 

  1310. #ifndef PALM_1
    1311. 

  1311. SOAP_FMAC1
    1312. 

  1312. const struct soap_code_map*
    1313. 

  1313. SOAP_FMAC2
    1314. 

  1314. soap_code(const struct soap_code_map *code_map, const char *str)
    1315. 

  1315. { if (code_map && str)
    1316. 

  1316.   { while (code_map->string)
    1317. 

  1317.     { if (!strcmp(str, code_map->string)) /* case sensitive */
    1318. 

  1318.         return code_map;
    1319. 

  1319.       code_map++;
    1320. 

  1320.     }
    1321. 

  1321.   }
    1322. 

  1322.   return NULL;
    1323. 

  1323. }
    1324. 

  1324. #endif
    1325. 

  1325. 

  1326. /******************************************************************************/
    1327. 

  1327. #ifndef PALM_1
    1328. 

  1328. SOAP_FMAC1
    1329. 

  1329. long
    1330. 

  1330. SOAP_FMAC2
    1331. 

  1331. soap_code_int(const struct soap_code_map *code_map, const char *str, long other)
    1332. 

  1332. { if (code_map)
    1333. 

  1333.   { while (code_map->string)
    1334. 

  1334.     { if (!soap_tag_cmp(str, code_map->string)) /* case insensitive */
    1335. 

  1335.         return code_map->code;
    1336. 

  1336.       code_map++;
    1337. 

  1337.     }
    1338. 

  1338.   }
    1339. 

  1339.   return other;
    1340. 

  1340. }
    1341. 

  1341. #endif
    1342. 

  1342. 

  1343. /******************************************************************************/
    1344. 

  1344. #ifndef PALM_1
    1345. 

  1345. SOAP_FMAC1
    1346. 

  1346. const char*
    1347. 

  1347. SOAP_FMAC2
    1348. 

  1348. soap_code_str(const struct soap_code_map *code_map, long code)
    1349. 

  1349. { if (!code_map)
    1350. 

  1350.     return NULL;
    1351. 

  1351.   while (code_map->code != code && code_map->string)
    1352. 

  1352.     code_map++;
    1353. 

  1353.   return code_map->string;
    1354. 

  1354. }
    1355. 

  1355. #endif
    1356. 

  1356. 

  1357. /******************************************************************************/
    1358. 

  1358. #ifndef PALM_1
    1359. 

  1359. SOAP_FMAC1
    1360. 

  1360. long
    1361. 

  1361. SOAP_FMAC2
    1362. 

  1362. soap_code_bits(const struct soap_code_map *code_map, const char *str)
    1363. 

  1363. { register long bits = 0;
    1364. 

  1364.   if (code_map)
    1365. 

  1365.   { while (str && *str)
    1366. 

  1366.     { const struct soap_code_map *p;
    1367. 

  1367.       for (p = code_map; p->string; p++)
    1368. 

  1368.       { register size_t n = strlen(p->string);
    1369. 

  1369.         if (!strncmp(p->string, str, n) && soap_blank(str[n]))
    1370. 

  1370.         { bits |= p->code;
    1371. 

  1371.           str += n;
    1372. 

  1372.           while (*str > 0 && *str <= 32)
    1373. 

  1373.             str++;
    1374. 

  1374.           break;
    1375. 

  1375.         }
    1376. 

  1376.       }
    1377. 

  1377.       if (!p->string)
    1378. 

  1378.         return 0;
    1379. 

  1379.     }
    1380. 

  1380.   }
    1381. 

  1381.   return bits;
    1382. 

  1382. }
    1383. 

  1383. #endif
    1384. 

  1384. 

  1385. /******************************************************************************/
    1386. 

  1386. #ifndef PALM_1
    1387. 

  1387. SOAP_FMAC1
    1388. 

  1388. const char*
    1389. 

  1389. SOAP_FMAC2
    1390. 

  1390. soap_code_list(struct soap *soap, const struct soap_code_map *code_map, long code)
    1391. 

  1391. { register char *t = soap->tmpbuf;
    1392. 

  1392.   if (code_map)
    1393. 

  1393.   { while (code_map->string)
    1394. 

  1394.     { if (code_map->code & code)
    1395. 

  1395.       { register const char *s = code_map->string;
    1396. 

  1396.         if (t != soap->tmpbuf)
    1397. 

  1397.           *t++ = ' ';
    1398. 

  1398.         while (*s && t < soap->tmpbuf + sizeof(soap->tmpbuf) - 1)
    1399. 

  1399.           *t++ = *s++;
    1400. 

  1400.         if (t == soap->tmpbuf + sizeof(soap->tmpbuf) - 1)
    1401. 

  1401.           break;
    1402. 

  1402.       }
    1403. 

  1403.       code_map++;
    1404. 

  1404.     }
    1405. 

  1405.   }
    1406. 

  1406.   *t = '\0';
    1407. 

  1407.   return soap->tmpbuf;
    1408. 

  1408. }
    1409. 

  1409. #endif
    1410. 

  1410. 

  1411. /******************************************************************************/
    1412. 

  1412. #ifndef PALM_1
    1413. 

  1413. static soap_wchar
    1414. 

  1414. soap_char(struct soap *soap)
    1415. 

  1415. { char tmp[8];
    1416. 

  1416.   register int i;
    1417. 

  1417.   register soap_wchar c;
    1418. 

  1418.   register char *s = tmp;
    1419. 

  1419.   for (i = 0; i < 7; i++)
    1420. 

  1420.   { c = soap_get1(soap);
    1421. 

  1421.     if (c == ';' || (int)c == EOF)
    1422. 

  1422.       break;
    1423. 

  1423.     *s++ = (char)c;
    1424. 

  1424.   }
    1425. 

  1425.   *s = '\0';
    1426. 

  1426.   if (*tmp == '#')
    1427. 

  1427.   { if (tmp[1] == 'x' || tmp[1] == 'X')
    1428. 

  1428.       return (soap_wchar)soap_strtol(tmp + 2, NULL, 16);
    1429. 

  1429.     return (soap_wchar)soap_strtol(tmp + 1, NULL, 10);
    1430. 

  1430.   }
    1431. 

  1431.   if (!strcmp(tmp, "lt"))
    1432. 

  1432.     return '<';
    1433. 

  1433.   if (!strcmp(tmp, "gt"))
    1434. 

  1434.     return '>';
    1435. 

  1435.   if (!strcmp(tmp, "amp"))
    1436. 

  1436.     return '&';
    1437. 

  1437.   if (!strcmp(tmp, "quot"))
    1438. 

  1438.     return '"';
    1439. 

  1439.   if (!strcmp(tmp, "apos"))
    1440. 

  1440.     return '\'';
    1441. 

  1441. #ifndef WITH_LEAN
    1442. 

  1442.   return (soap_wchar)soap_code_int(html_entity_codes, tmp, SOAP_UNKNOWN_CHAR);
    1443. 

  1443. #else
    1444. 

  1444.   return SOAP_UNKNOWN_CHAR; /* use this to represent unknown code */
    1445. 

  1445. #endif
    1446. 

  1446. }
    1447. 

  1447. #endif
    1448. 

  1448. 

  1449. /******************************************************************************/
    1450. 

  1450. #ifdef WITH_LEAN
    1451. 

  1451. #ifndef PALM_1
    1452. 

  1452. soap_wchar
    1453. 

  1453. soap_get0(struct soap *soap)
    1454. 

  1454. { if (soap->bufidx >= soap->buflen && soap_recv(soap))
    1455. 

  1455.     return EOF;
    1456. 

  1456.   return (unsigned char)soap->buf[soap->bufidx];
    1457. 

  1457. }
    1458. 

  1458. #endif
    1459. 

  1459. #endif
    1460. 

  1460. 

  1461. /******************************************************************************/
    1462. 

  1462. #ifdef WITH_LEAN
    1463. 

  1463. #ifndef PALM_1
    1464. 

  1464. soap_wchar
    1465. 

  1465. soap_get1(struct soap *soap)
    1466. 

  1466. { if (soap->bufidx >= soap->buflen && soap_recv(soap))
    1467. 

  1467.     return EOF;
    1468. 

  1468.   return (unsigned char)soap->buf[soap->bufidx++];
    1469. 

  1469. }
    1470. 

  1470. #endif
    1471. 

  1471. #endif
    1472. 

  1472. 

  1473. /******************************************************************************/
    1474. 

  1474. #ifndef PALM_1
    1475. 

  1475. SOAP_FMAC1
    1476. 

  1476. soap_wchar
    1477. 

  1477. SOAP_FMAC2
    1478. 

  1478. soap_get(struct soap *soap)
    1479. 

  1479. { register soap_wchar c;
    1480. 

  1480.   c = soap->ahead;
    1481. 

  1481.   if (c)
    1482. 

  1482.   { if ((int)c != EOF)
    1483. 

  1483.       soap->ahead = 0;
    1484. 

  1484.   }
    1485. 

  1485.   else
    1486. 

  1486.     c = soap_get1(soap);
    1487. 

  1487.   while ((int)c != EOF)
    1488. 

  1488.   { if (soap->cdata)
    1489. 

  1489.     { if (c == ']')
    1490. 

  1490.       { c = soap_get1(soap);
    1491. 

  1491.         if (c == ']')
    1492. 

  1492.         { c = soap_get0(soap);
    1493. 

  1493.           if (c == '>')
    1494. 

  1494.           { soap->cdata = 0;
    1495. 

  1495.             soap_get1(soap);
    1496. 

  1496.             c = soap_get1(soap);
    1497. 

  1497.           }
    1498. 

  1498.           else
    1499. 

  1499.           { soap_unget(soap, ']');
    1500. 

  1500.             return ']';
    1501. 

  1501.           }
    1502. 

  1502.         }
    1503. 

  1503.         else
    1504. 

  1504.         { soap_revget1(soap);
    1505. 

  1505.           return ']';
    1506. 

  1506.         }
    1507. 

  1507.       }
    1508. 

  1508.       else
    1509. 

  1509.         return c;
    1510. 

  1510.     }
    1511. 

  1511.     switch (c)
    1512. 

  1512.     { case '<':
    1513. 

  1513.         do c = soap_get1(soap);
    1514. 

  1514.         while (soap_blank(c));
    1515. 

  1515.         if (c == '!' || c == '?' || c == '%')
    1516. 

  1516.         { register int k = 1;
    1517. 

  1517.           if (c == '!')
    1518. 

  1518.           { c = soap_get1(soap);
    1519. 

  1519.             if (c == '[')
    1520. 

  1520.             { do c = soap_get1(soap);
    1521. 

  1521.               while ((int)c != EOF && c != '[');
    1522. 

  1522.               if ((int)c == EOF)
    1523. 

  1523.                 break;
    1524. 

  1524.               soap->cdata = 1;
    1525. 

  1525.               c = soap_get1(soap);
    1526. 

  1526.               continue;
    1527. 

  1527.             }
    1528. 

  1528.             if (c == '-' && (c = soap_get1(soap)) == '-')
    1529. 

  1529.             { do
    1530. 

  1530.               { c = soap_get1(soap);
    1531. 

  1531.                 if (c == '-' && (c = soap_get1(soap)) == '-')
    1532. 

  1532.                   break;
    1533. 

  1533.               } while ((int)c != EOF);
    1534. 

  1534.             }
    1535. 

  1535.           }
    1536. 

  1536.           else if (c == '?')
    1537. 

  1537.             c = soap_get_pi(soap);
    1538. 

  1538.           while ((int)c != EOF)
    1539. 

  1539.           { if (c == '<')
    1540. 

  1540.               k++;
    1541. 

  1541.             else if (c == '>')
    1542. 

  1542.             { if (--k <= 0)
    1543. 

  1543.                 break;
    1544. 

  1544.             }
    1545. 

  1545.             c = soap_get1(soap);
    1546. 

  1546.           }
    1547. 

  1547.           if ((int)c == EOF)
    1548. 

  1548.             break;
    1549. 

  1549.           c = soap_get1(soap);
    1550. 

  1550.           continue;
    1551. 

  1551.         }
    1552. 

  1552.         if (c == '/')
    1553. 

  1553.           return SOAP_TT;
    1554. 

  1554.         soap_revget1(soap);
    1555. 

  1555.         return SOAP_LT;
    1556. 

  1556.       case '>':
    1557. 

  1557.         return SOAP_GT;
    1558. 

  1558.       case '"':
    1559. 

  1559.         return SOAP_QT;
    1560. 

  1560.       case '\'':
    1561. 

  1561.         return SOAP_AP;
    1562. 

  1562.       case '&':
    1563. 

  1563.         return soap_char(soap) | 0x80000000;
    1564. 

  1564.     }
    1565. 

  1565.     break;
    1566. 

  1566.   }
    1567. 

  1567.   return c;
    1568. 

  1568. }
    1569. 

  1569. #endif
    1570. 

  1570. 

  1571. /******************************************************************************/
    1572. 

  1572. #ifndef PALM_1
    1573. 

  1573. static soap_wchar
    1574. 

  1574. soap_get_pi(struct soap *soap)
    1575. 

  1575. { char buf[64];
    1576. 

  1576.   register char *s = buf;
    1577. 

  1577.   register int i = sizeof(buf);
    1578. 

  1578.   register soap_wchar c = soap_getchar(soap);
    1579. 

  1579.   /* This is a quick way to parse XML PI and we could use a callback instead to
    1580. 

  1580.    * enable applications to intercept processing instructions */
    1581. 

  1581.   while ((int)c != EOF && c != '?')
    1582. 

  1582.   { if (--i > 0)
    1583. 

  1583.     { if (soap_blank(c))
    1584. 

  1584.         c = ' ';
    1585. 

  1585.       *s++ = (char)c;
    1586. 

  1586.     }
    1587. 

  1587.     c = soap_getchar(soap);
    1588. 

  1588.   }
    1589. 

  1589.   *s = '\0';
    1590. 

  1590.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "XML PI <?%s?>\n", buf));
    1591. 

  1591.   if (!strncmp(buf, "xml ", 4))
    1592. 

  1592.   { s = strstr(buf, " encoding=");
    1593. 

  1593.     if (s && s[10])
    1594. 

  1594.     { if (!soap_tag_cmp(s + 11, "iso-8859-1*")
    1595. 

  1595.        || !soap_tag_cmp(s + 11, "latin1*"))
    1596. 

  1596.       { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Switching to latin1 encoding\n"));
    1597. 

  1597.         soap->mode |= SOAP_ENC_LATIN;
    1598. 

  1598.       }
    1599. 

  1599.       else if (!soap_tag_cmp(s + 11, "utf-8*"))
    1600. 

  1600.       { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Switching to utf-8 encoding\n"));
    1601. 

  1601.         soap->mode &= ~SOAP_ENC_LATIN;
    1602. 

  1602.       }
    1603. 

  1603.     }
    1604. 

  1604.   }
    1605. 

  1605.   if ((int)c != EOF)
    1606. 

  1606.     c = soap_getchar(soap);
    1607. 

  1607.   return c;
    1608. 

  1608. }
    1609. 

  1609. #endif
    1610. 

  1610. 

  1611. /******************************************************************************/
    1612. 

  1612. #ifndef WITH_LEANER
    1613. 

  1613. #ifndef PALM_1
    1614. 

  1614. SOAP_FMAC1
    1615. 

  1615. int
    1616. 

  1616. SOAP_FMAC2
    1617. 

  1617. soap_move(struct soap *soap, long n)
    1618. 

  1618. { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Moving %ld bytes forward\n", (long)n));
    1619. 

  1619.   for (; n > 0; n--)
    1620. 

  1620.     if ((int)soap_getchar(soap) == EOF)
    1621. 

  1621.       return SOAP_EOF;
    1622. 

  1622.   return SOAP_OK;
    1623. 

  1623. }
    1624. 

  1624. #endif
    1625. 

  1625. #endif
    1626. 

  1626. 

  1627. /******************************************************************************/
    1628. 

  1628. #ifndef WITH_LEANER
    1629. 

  1629. #ifndef PALM_1
    1630. 

  1630. SOAP_FMAC1
    1631. 

  1631. size_t
    1632. 

  1632. SOAP_FMAC2
    1633. 

  1633. soap_tell(struct soap *soap)
    1634. 

  1634. { return soap->count - soap->buflen + soap->bufidx - (soap->ahead != 0);
    1635. 

  1635. }
    1636. 

  1636. #endif
    1637. 

  1637. #endif
    1638. 

  1638. 

  1639. /******************************************************************************/
    1640. 

  1640. #ifndef PALM_1
    1641. 

  1641. SOAP_FMAC1
    1642. 

  1642. int
    1643. 

  1643. SOAP_FMAC2
    1644. 

  1644. soap_pututf8(struct soap *soap, register unsigned long c)
    1645. 

  1645. { char tmp[16];
    1646. 

  1646.   if (c < 0x80 && c > 0)
    1647. 

  1647.   { *tmp = (char)c;
    1648. 

  1648.     return soap_send_raw(soap, tmp, 1);
    1649. 

  1649.   }
    1650. 

  1650. #ifndef WITH_LEAN
    1651. 

  1651.   if (c >= 0x80)
    1652. 

  1652.   { register char *t = tmp;
    1653. 

  1653.     if (c < 0x0800)
    1654. 

  1654.       *t++ = (char)(0xC0 | ((c >> 6) & 0x1F));
    1655. 

  1655.     else
    1656. 

  1656.     { if (c < 0x010000)
    1657. 

  1657.         *t++ = (char)(0xE0 | ((c >> 12) & 0x0F));
    1658. 

  1658.       else
    1659. 

  1659.       { if (c < 0x200000)
    1660. 

  1660.           *t++ = (char)(0xF0 | ((c >> 18) & 0x07));
    1661. 

  1661.         else
    1662. 

  1662.         { if (c < 0x04000000)
    1663. 

  1663.             *t++ = (char)(0xF8 | ((c >> 24) & 0x03));
    1664. 

  1664.           else
    1665. 

  1665.           { *t++ = (char)(0xFC | ((c >> 30) & 0x01));
    1666. 

  1666.             *t++ = (char)(0x80 | ((c >> 24) & 0x3F));
    1667. 

  1667.           }
    1668. 

  1668.           *t++ = (char)(0x80 | ((c >> 18) & 0x3F));
    1669. 

  1669.         }     
    1670. 

  1670.         *t++ = (char)(0x80 | ((c >> 12) & 0x3F));
    1671. 

  1671.       }
    1672. 

  1672.       *t++ = (char)(0x80 | ((c >> 6) & 0x3F));
    1673. 

  1673.     }
    1674. 

  1674.     *t++ = (char)(0x80 | (c & 0x3F));
    1675. 

  1675.     *t = '\0';
    1676. 

  1676.   }
    1677. 

  1677. #else
    1678. 

  1678.   sprintf(tmp, "&#%lu;", c);
    1679. 

  1679. #endif
    1680. 

  1680.   return soap_send(soap, tmp);
    1681. 

  1681. }
    1682. 

  1682. #endif
    1683. 

  1683. 

  1684. /******************************************************************************/
    1685. 

  1685. #ifndef PALM_1
    1686. 

  1686. SOAP_FMAC1
    1687. 

  1687. soap_wchar
    1688. 

  1688. SOAP_FMAC2
    1689. 

  1689. soap_getutf8(struct soap *soap)
    1690. 

  1690. { register soap_wchar c, c1, c2, c3, c4;
    1691. 

  1691.   c = soap->ahead;
    1692. 

  1692.   if (c > 0x7F)
    1693. 

  1693.   { soap->ahead = 0;
    1694. 

  1694.     return c;
    1695. 

  1695.   }
    1696. 

  1696.   c = soap_get(soap);
    1697. 

  1697.   if (c < 0x80 || (soap->mode & SOAP_ENC_LATIN))
    1698. 

  1698.     return c;
    1699. 

  1699.   c1 = soap_get1(soap);
    1700. 

  1700.   if (c1 < 0x80)
    1701. 

  1701.   { soap_revget1(soap); /* doesn't look like this is UTF8 */
    1702. 

  1702.     return c;
    1703. 

  1703.   }
    1704. 

  1704.   c1 &= 0x3F;
    1705. 

  1705.   if (c < 0xE0)
    1706. 

  1706.     return ((soap_wchar)(c & 0x1F) << 6) | c1;
    1707. 

  1707.   c2 = (soap_wchar)soap_get1(soap) & 0x3F;
    1708. 

  1708.   if (c < 0xF0)
    1709. 

  1709.     return ((soap_wchar)(c & 0x0F) << 12) | (c1 << 6) | c2;
    1710. 

  1710.   c3 = (soap_wchar)soap_get1(soap) & 0x3F;
    1711. 

  1711.   if (c < 0xF8)
    1712. 

  1712.     return ((soap_wchar)(c & 0x07) << 18) | (c1 << 12) | (c2 << 6) | c3;
    1713. 

  1713.   c4 = (soap_wchar)soap_get1(soap) & 0x3F;
    1714. 

  1714.   if (c < 0xFC)
    1715. 

  1715.     return ((soap_wchar)(c & 0x03) << 24) | (c1 << 18) | (c2 << 12) | (c3 << 6) | c4;
    1716. 

  1716.   return ((soap_wchar)(c & 0x01) << 30) | (c1 << 24) | (c2 << 18) | (c3 << 12) | (c4 << 6) | (soap_wchar)(soap_get1(soap) & 0x3F);
    1717. 

  1717. }
    1718. 

  1718. #endif
    1719. 

  1719. 

  1720. /******************************************************************************/
    1721. 

  1721. #ifndef PALM_1
    1722. 

  1722. SOAP_FMAC1
    1723. 

  1723. int
    1724. 

  1724. SOAP_FMAC2
    1725. 

  1725. soap_puthex(struct soap *soap, const unsigned char *s, int n)
    1726. 

  1726. { char d[2];
    1727. 

  1727.   register int i;
    1728. 

  1728. #ifdef WITH_DOM
    1729. 

  1729.   if ((soap->mode & SOAP_XML_DOM) && soap->dom)
    1730. 

  1730.   { if (!(soap->dom->data = soap_s2hex(soap, s, NULL, n)))
    1731. 

  1731.       return soap->error;
    1732. 

  1732.     return SOAP_OK;
    1733. 

  1733.   }
    1734. 

  1734. #endif
    1735. 

  1735.   for (i = 0; i < n; i++)
    1736. 

  1736.   { register int m = *s++;
    1737. 

  1737.     d[0] = (char)((m >> 4) + (m > 159 ? '7' : '0'));
    1738. 

  1738.     m &= 0x0F;
    1739. 

  1739.     d[1] = (char)(m + (m > 9 ? '7' : '0'));
    1740. 

  1740.     if (soap_send_raw(soap, d, 2))
    1741. 

  1741.       return soap->error;
    1742. 

  1742.   }
    1743. 

  1743.   return SOAP_OK;
    1744. 

  1744. }
    1745. 

  1745. #endif
    1746. 

  1746. 

  1747. /******************************************************************************/
    1748. 

  1748. #ifndef PALM_1
    1749. 

  1749. SOAP_FMAC1
    1750. 

  1750. unsigned char*
    1751. 

  1751. SOAP_FMAC2
    1752. 

  1752. soap_gethex(struct soap *soap, int *n)
    1753. 

  1753. {
    1754. 

  1754. #ifdef WITH_DOM
    1755. 

  1755.   if ((soap->mode & SOAP_XML_DOM) && soap->dom)
    1756. 

  1756.   { soap->dom->data = soap_string_in(soap, 0, -1, -1);
    1757. 

  1757.     return (unsigned char*)soap_hex2s(soap, soap->dom->data, NULL, 0, n);
    1758. 

  1758.   }
    1759. 

  1759. #endif
    1760. 

  1760. #ifdef WITH_FAST
    1761. 

  1761.   soap->labidx = 0;
    1762. 

  1762.   for (;;)
    1763. 

  1763.   { register char *s;
    1764. 

  1764.     register size_t i, k;
    1765. 

  1765.     if (soap_append_lab(soap, NULL, 0))
    1766. 

  1766.       return NULL;
    1767. 

  1767.     s = soap->labbuf + soap->labidx;
    1768. 

  1768.     k = soap->lablen - soap->labidx;
    1769. 

  1769.     soap->labidx = soap->lablen;
    1770. 

  1770.     for (i = 0; i < k; i++)
    1771. 

  1771.     { register char d1, d2;
    1772. 

  1772.       register soap_wchar c;
    1773. 

  1773.       c = soap_get(soap);
    1774. 

  1774.       if (soap_isxdigit(c))
    1775. 

  1775.       { d1 = (char)c;
    1776. 

  1776.         c = soap_get(soap); 
    1777. 

  1777.         if (soap_isxdigit(c))
    1778. 

  1778.           d2 = (char)c;
    1779. 

  1779.         else 
    1780. 

  1780.         { soap->error = SOAP_TYPE;
    1781. 

  1781.           return NULL;
    1782. 

  1782.         }
    1783. 

  1783.       }
    1784. 

  1784.       else
    1785. 

  1785.       { unsigned char *p;
    1786. 

  1786.         soap_unget(soap, c);
    1787. 

  1787.         if (n)
    1788. 

  1788.           *n = (int)(soap->lablen + i - k);
    1789. 

  1789.         p = (unsigned char*)soap_malloc(soap, soap->lablen + i - k);
    1790. 

  1790.         if (p)
    1791. 

  1791.           memcpy(p, soap->labbuf, soap->lablen + i - k);
    1792. 

  1792.         return p;
    1793. 

  1793.       }
    1794. 

  1794.       *s++ = ((d1 >= 'A' ? (d1 & 0x7) + 9 : d1 - '0') << 4) + (d2 >= 'A' ? (d2 & 0x7) + 9 : d2 - '0');
    1795. 

  1795.     }
    1796. 

  1796.   }
    1797. 

  1797. #else
    1798. 

  1798.   if (soap_new_block(soap) == NULL)
    1799. 

  1799.     return NULL;
    1800. 

  1800.   for (;;)
    1801. 

  1801.   { register int i;
    1802. 

  1802.     register char *s = (char*)soap_push_block(soap, NULL, SOAP_BLKLEN);
    1803. 

  1803.     if (!s)
    1804. 

  1804.     { soap_end_block(soap, NULL);
    1805. 

  1805.       return NULL;
    1806. 

  1806.     }
    1807. 

  1807.     for (i = 0; i < SOAP_BLKLEN; i++)
    1808. 

  1808.     { register char d1, d2;
    1809. 

  1809.       register soap_wchar c = soap_get(soap);
    1810. 

  1810.       if (soap_isxdigit(c))
    1811. 

  1811.       { d1 = (char)c;
    1812. 

  1812.         c = soap_get(soap); 
    1813. 

  1813.         if (soap_isxdigit(c))
    1814. 

  1814.           d2 = (char)c;
    1815. 

  1815.         else 
    1816. 

  1816.         { soap_end_block(soap, NULL);
    1817. 

  1817.           soap->error = SOAP_TYPE;
    1818. 

  1818.           return NULL;
    1819. 

  1819.         }
    1820. 

  1820.       }
    1821. 

  1821.       else
    1822. 

  1822.       { unsigned char *p;
    1823. 

  1823.         soap_unget(soap, c);
    1824. 

  1824.         if (n)
    1825. 

  1825.           *n = (int)soap_size_block(soap, NULL, i);
    1826. 

  1826.         p = (unsigned char*)soap_save_block(soap, NULL, 0);
    1827. 

  1827.         return p;
    1828. 

  1828.       }
    1829. 

  1829.       *s++ = ((d1 >= 'A' ? (d1 & 0x7) + 9 : d1 - '0') << 4) + (d2 >= 'A' ? (d2 & 0x7) + 9 : d2 - '0');
    1830. 

  1830.     }
    1831. 

  1831.   }
    1832. 

  1832. #endif
    1833. 

  1833. }
    1834. 

  1834. #endif
    1835. 

  1835. 

  1836. /******************************************************************************/
    1837. 

  1837. #ifndef PALM_1
    1838. 

  1838. SOAP_FMAC1
    1839. 

  1839. int
    1840. 

  1840. SOAP_FMAC2
    1841. 

  1841. soap_putbase64(struct soap *soap, const unsigned char *s, int n)
    1842. 

  1842. { register int i;
    1843. 

  1843.   register unsigned long m;
    1844. 

  1844.   char d[4];
    1845. 

  1845.   if (!s)
    1846. 

  1846.     return SOAP_OK;
    1847. 

  1847. #ifdef WITH_DOM
    1848. 

  1848.   if ((soap->mode & SOAP_XML_DOM) && soap->dom)
    1849. 

  1849.   { if (!(soap->dom->data = soap_s2base64(soap, s, NULL, n)))
    1850. 

  1850.       return soap->error;
    1851. 

  1851.     return SOAP_OK;
    1852. 

  1852.   }
    1853. 

  1853. #endif
    1854. 

  1854.   for (; n > 2; n -= 3, s += 3)
    1855. 

  1855.   { m = s[0];
    1856. 

  1856.     m = (m << 8) | s[1];
    1857. 

  1857.     m = (m << 8) | s[2];
    1858. 

  1858.     for (i = 4; i > 0; m >>= 6)
    1859. 

  1859.       d[--i] = soap_base64o[m & 0x3F];
    1860. 

  1860.     if (soap_send_raw(soap, d, 4))
    1861. 

  1861.       return soap->error;
    1862. 

  1862.   }
    1863. 

  1863.   if (n > 0)
    1864. 

  1864.   { m = 0;
    1865. 

  1865.     for (i = 0; i < n; i++)
    1866. 

  1866.       m = (m << 8) | *s++;
    1867. 

  1867.     for (; i < 3; i++)
    1868. 

  1868.       m <<= 8;
    1869. 

  1869.     for (i++; i > 0; m >>= 6)
    1870. 

  1870.       d[--i] = soap_base64o[m & 0x3F];
    1871. 

  1871.     for (i = 3; i > n; i--)
    1872. 

  1872.       d[i] = '=';
    1873. 

  1873.     if (soap_send_raw(soap, d, 4))
    1874. 

  1874.       return soap->error;
    1875. 

  1875.   }
    1876. 

  1876.   return SOAP_OK;
    1877. 

  1877. }
    1878. 

  1878. #endif
    1879. 

  1879. 

  1880. /******************************************************************************/
    1881. 

  1881. #ifndef PALM_1
    1882. 

  1882. SOAP_FMAC1
    1883. 

  1883. unsigned char*
    1884. 

  1884. SOAP_FMAC2
    1885. 

  1885. soap_getbase64(struct soap *soap, int *n, int malloc_flag)
    1886. 

  1886. { 
    1887. 

  1887. #ifdef WITH_DOM
    1888. 

  1888.   if ((soap->mode & SOAP_XML_DOM) && soap->dom)
    1889. 

  1889.   { soap->dom->data = soap_string_in(soap, 0, -1, -1);
    1890. 

  1890.     return (unsigned char*)soap_base642s(soap, soap->dom->data, NULL, 0, n);
    1891. 

  1891.   }
    1892. 

  1892. #endif
    1893. 

  1893. #ifdef WITH_FAST
    1894. 

  1894.   soap->labidx = 0;
    1895. 

  1895.   for (;;)
    1896. 

  1896.   { register size_t i, k;
    1897. 

  1897.     register char *s;
    1898. 

  1898.     if (soap_append_lab(soap, NULL, 2))
    1899. 

  1899.       return NULL;
    1900. 

  1900.     s = soap->labbuf + soap->labidx;
    1901. 

  1901.     k = soap->lablen - soap->labidx;
    1902. 

  1902.     soap->labidx = 3 * (soap->lablen / 3);
    1903. 

  1903.     if (!s)
    1904. 

  1904.       return NULL;
    1905. 

  1905.     if (k > 2)
    1906. 

  1906.     { for (i = 0; i < k - 2; i += 3)
    1907. 

  1907.       { register unsigned long m = 0;
    1908. 

  1908.         register int j = 0;
    1909. 

  1909.         do
    1910. 

  1910.         { register soap_wchar c = soap_get(soap);
    1911. 

  1911.           if (c == '=' || c < 0)
    1912. 

  1912.           { unsigned char *p;
    1913. 

  1913.             switch (j)
    1914. 

  1914.             { case 2:
    1915. 

  1915.                 *s++ = (char)((m >> 4) & 0xFF);
    1916. 

  1916.                 i++;
    1917. 

  1917.                 break;
    1918. 

  1918.               case 3:
    1919. 

  1919.                 *s++ = (char)((m >> 10) & 0xFF);
    1920. 

  1920.                 *s++ = (char)((m >> 2) & 0xFF);
    1921. 

  1921.                 i += 2;
    1922. 

  1922.             }
    1923. 

  1923.             if (n)
    1924. 

  1924.               *n = (int)(soap->lablen + i - k);
    1925. 

  1925.             p = (unsigned char*)soap_malloc(soap, soap->lablen + i - k);
    1926. 

  1926.             if (p)
    1927. 

  1927.               memcpy(p, soap->labbuf, soap->lablen + i - k);
    1928. 

  1928.             if (c >= 0)
    1929. 

  1929.             { while ((int)((c = soap_get(soap)) != EOF) && c != SOAP_LT && c != SOAP_TT)
    1930. 

  1930.                 ;
    1931. 

  1931.             }
    1932. 

  1932.             soap_unget(soap, c);
    1933. 

  1933.             return p;
    1934. 

  1934.           }
    1935. 

  1935.           c -= '+';
    1936. 

  1936.           if (c >= 0 && c <= 79)
    1937. 

  1937.           { register int b = soap_base64i[c];
    1938. 

  1938.             if (b >= 64)
    1939. 

  1939.             { soap->error = SOAP_TYPE;
    1940. 

  1940.               return NULL;  
    1941. 

  1941.             }
    1942. 

  1942.             m = (m << 6) + b;
    1943. 

  1943.             j++;
    1944. 

  1944.           }
    1945. 

  1945.           else if (!soap_blank(c + '+'))
    1946. 

  1946.           { soap->error = SOAP_TYPE;
    1947. 

  1947.             return NULL;  
    1948. 

  1948.           }
    1949. 

  1949.         } while (j < 4);
    1950. 

  1950.         *s++ = (char)((m >> 16) & 0xFF);
    1951. 

  1951.         *s++ = (char)((m >> 8) & 0xFF);
    1952. 

  1952.         *s++ = (char)(m & 0xFF);
    1953. 

  1953.       }
    1954. 

  1954.     }
    1955. 

  1955.   }
    1956. 

  1956. #else
    1957. 

  1957.   if (soap_new_block(soap) == NULL)
    1958. 

  1958.     return NULL;
    1959. 

  1959.   for (;;)
    1960. 

  1960.   { register int i;
    1961. 

  1961.     register char *s = (char*)soap_push_block(soap, NULL, 3 * SOAP_BLKLEN); /* must be multiple of 3 */
    1962. 

  1962.     if (!s)
    1963. 

  1963.     { soap_end_block(soap, NULL);
    1964. 

  1964.       return NULL;
    1965. 

  1965.     }
    1966. 

  1966.     for (i = 0; i < SOAP_BLKLEN; i++)
    1967. 

  1967.     { register unsigned long m = 0;
    1968. 

  1968.       register int j = 0;
    1969. 

  1969.       do
    1970. 

  1970.       { register soap_wchar c = soap_get(soap);
    1971. 

  1971.         if (c == '=' || c < 0)
    1972. 

  1972.         { unsigned char *p;
    1973. 

  1973.           i *= 3;
    1974. 

  1974.           switch (j)
    1975. 

  1975.           { case 2:
    1976. 

  1976.               *s++ = (char)((m >> 4) & 0xFF);
    1977. 

  1977.               i++;
    1978. 

  1978.               break;
    1979. 

  1979.             case 3:
    1980. 

  1980.               *s++ = (char)((m >> 10) & 0xFF);
    1981. 

  1981.               *s++ = (char)((m >> 2) & 0xFF);
    1982. 

  1982.               i += 2;
    1983. 

  1983.           }
    1984. 

  1984.           if (n)
    1985. 

  1985.             *n = (int)soap_size_block(soap, NULL, i);
    1986. 

  1986.           p = (unsigned char*)soap_save_block(soap, NULL, 0);
    1987. 

  1987.           if (c >= 0)
    1988. 

  1988.           { while ((int)((c = soap_get(soap)) != EOF) && c != SOAP_LT && c != SOAP_TT)
    1989. 

  1989.               ;
    1990. 

  1990.           }
    1991. 

  1991.           soap_unget(soap, c);
    1992. 

  1992.           return p;
    1993. 

  1993.         }
    1994. 

  1994.         c -= '+';
    1995. 

  1995.         if (c >= 0 && c <= 79)
    1996. 

  1996.         { int b = soap_base64i[c];
    1997. 

  1997.           if (b >= 64)
    1998. 

  1998.           { soap->error = SOAP_TYPE;
    1999. 

  1999.             return NULL;  
    2000. 

  2000.           }
    2001. 

  2001.           m = (m << 6) + b;
    2002. 

  2002.           j++;
    2003. 

  2003.         }
    2004. 

  2004.         else if (!soap_blank(c))
    2005. 

  2005.         { soap->error = SOAP_TYPE;
    2006. 

  2006.           return NULL;  
    2007. 

  2007.         }
    2008. 

  2008.       } while (j < 4);
    2009. 

  2009.       *s++ = (char)((m >> 16) & 0xFF);
    2010. 

  2010.       *s++ = (char)((m >> 8) & 0xFF);
    2011. 

  2011.       *s++ = (char)(m & 0xFF);
    2012. 

  2012.     }
    2013. 

  2013.   }
    2014. 

  2014. #endif
    2015. 

  2015. }
    2016. 

  2016. #endif
    2017. 

  2017. 

  2018. /******************************************************************************/
    2019. 

  2019. #ifndef WITH_LEANER
    2020. 

  2020. #ifndef PALM_1
    2021. 

  2021. SOAP_FMAC1
    2022. 

  2022. int
    2023. 

  2023. SOAP_FMAC2
    2024. 

  2024. soap_xop_forward(struct soap *soap, unsigned char **ptr, int *size, char **id, char **type, char **options)
    2025. 

  2025. { /* Check MTOM xop:Include element (within hex/base64Binary) */
    2026. 

  2026.   /* TODO: this code to be obsoleted with new import/xop.h conventions */
    2027. 

  2027.   int body = soap->body; /* should save type too? */
    2028. 

  2028.   if (!soap_peek_element(soap))
    2029. 

  2029.   { if (!soap_element_begin_in(soap, "xop:Include", 0, NULL) && *soap->href)
    2030. 

  2030.     { if (soap_dime_forward(soap, ptr, size, id, type, options))
    2031. 

  2031.         return soap->error;
    2032. 

  2032.     }
    2033. 

  2033.     if (soap->body && soap_element_end_in(soap, NULL))
    2034. 

  2034.       return soap->error;
    2035. 

  2035.   }
    2036. 

  2036.   soap->body = body;
    2037. 

  2037.   return SOAP_OK;
    2038. 

  2038. }
    2039. 

  2039. #endif
    2040. 

  2040. #endif
    2041. 

  2041. 

  2042. /******************************************************************************/
    2043. 

  2043. #ifndef WITH_LEANER
    2044. 

  2044. #ifndef PALM_1
    2045. 

  2045. SOAP_FMAC1
    2046. 

  2046. int
    2047. 

  2047. SOAP_FMAC2
    2048. 

  2048. soap_dime_forward(struct soap *soap, unsigned char **ptr, int *size, char **id, char **type, char **options)
    2049. 

  2049. { struct soap_xlist *xp;
    2050. 

  2050.   *ptr = NULL;
    2051. 

  2051.   *size = 0;
    2052. 

  2052.   *id = NULL;
    2053. 

  2053.   *type = NULL;
    2054. 

  2054.   *options = NULL;
    2055. 

  2055.   if (!*soap->href)
    2056. 

  2056.     return SOAP_OK;
    2057. 

  2057.   *id = soap_strdup(soap, soap->href);
    2058. 

  2058.   xp = (struct soap_xlist*)SOAP_MALLOC(soap, sizeof(struct soap_xlist));
    2059. 

  2059.   if (!xp)
    2060. 

  2060.     return soap->error = SOAP_EOM;
    2061. 

  2061.   xp->next = soap->xlist;
    2062. 

  2062.   xp->ptr = ptr;
    2063. 

  2063.   xp->size = size;
    2064. 

  2064.   xp->id = *id;
    2065. 

  2065.   xp->type = type;
    2066. 

  2066.   xp->options = options;
    2067. 

  2067.   soap->xlist = xp;
    2068. 

  2068.   return SOAP_OK;
    2069. 

  2069. }
    2070. 

  2070. #endif
    2071. 

  2071. #endif
    2072. 

  2072. 

  2073. /******************************************************************************/
    2074. 

  2074. #ifndef PALM_1
    2075. 

  2075. SOAP_FMAC1
    2076. 

  2076. char *
    2077. 

  2077. SOAP_FMAC2
    2078. 

  2078. soap_strdup(struct soap *soap, const char *s)
    2079. 

  2079. { char *t = NULL;
    2080. 

  2080.   if (s && (t = (char*)soap_malloc(soap, strlen(s) + 1)))
    2081. 

  2081.     strcpy(t, s);
    2082. 

  2082.   return t;
    2083. 

  2083. }
    2084. 

  2084. #endif
    2085. 

  2085. 

  2086. /******************************************************************************/
    2087. 

  2087. #ifndef PALM_1
    2088. 

  2088. SOAP_FMAC1
    2089. 

  2089. wchar_t *
    2090. 

  2090. SOAP_FMAC2
    2091. 

  2091. soap_wstrdup(struct soap *soap, const wchar_t *s)
    2092. 

  2092. { wchar_t *t = NULL;
    2093. 

  2093.   if (s)
    2094. 

  2094.   { size_t n = 0;
    2095. 

  2095.     while (s[n])
    2096. 

  2096.       n++;
    2097. 

  2097.     if ((t = (wchar_t*)soap_malloc(soap, sizeof(wchar_t)*(n+1))))
    2098. 

  2098.       memcpy(t, s, sizeof(wchar_t)*(n+1));
    2099. 

  2099.   }
    2100. 

  2100.   return t;
    2101. 

  2101. }
    2102. 

  2102. #endif
    2103. 

  2103. 

  2104. /******************************************************************************/
    2105. 

  2105. #ifndef PALM_1
    2106. 

  2106. SOAP_FMAC1
    2107. 

  2107. struct soap_blist*
    2108. 

  2108. SOAP_FMAC2
    2109. 

  2109. soap_new_block(struct soap *soap)
    2110. 

  2110. { struct soap_blist *p;
    2111. 

  2111.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "New block sequence (prev=%p)\n", soap->blist));
    2112. 

  2112.   if (!(p = (struct soap_blist*)SOAP_MALLOC(soap, sizeof(struct soap_blist))))
    2113. 

  2113.   { soap->error = SOAP_EOM;   
    2114. 

  2114.     return NULL;
    2115. 

  2115.   }
    2116. 

  2116.   p->next = soap->blist; 
    2117. 

  2117.   p->ptr = NULL;
    2118. 

  2118.   p->size = 0;
    2119. 

  2119.   soap->blist = p;
    2120. 

  2120.   return p;
    2121. 

  2121. }
    2122. 

  2122. #endif
    2123. 

  2123. 

  2124. /******************************************************************************/
    2125. 

  2125. #ifndef PALM_1
    2126. 

  2126. SOAP_FMAC1
    2127. 

  2127. void*
    2128. 

  2128. SOAP_FMAC2
    2129. 

  2129. soap_push_block(struct soap *soap, struct soap_blist *b, size_t n)
    2130. 

  2130. { char *p;
    2131. 

  2131.   if (!b)
    2132. 

  2132.     b = soap->blist;
    2133. 

  2133.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Push block of %u bytes (%u bytes total)\n", (unsigned int)n, (unsigned int)b->size + (unsigned int)n));
    2134. 

  2134.   if (!(p = (char*)SOAP_MALLOC(soap, n + sizeof(char*) + sizeof(size_t))))
    2135. 

  2135.   { soap->error = SOAP_EOM;
    2136. 

  2136.     return NULL;
    2137. 

  2137.   }
    2138. 

  2138.   *(char**)p = b->ptr;
    2139. 

  2139.   *(size_t*)(p + sizeof(char*)) = n;
    2140. 

  2140.   b->ptr = p;
    2141. 

  2141.   b->size += n;
    2142. 

  2142.   return p + sizeof(char*) + sizeof(size_t);
    2143. 

  2143. }
    2144. 

  2144. #endif
    2145. 

  2145. 

  2146. /******************************************************************************/
    2147. 

  2147. #ifndef PALM_1
    2148. 

  2148. SOAP_FMAC1
    2149. 

  2149. void
    2150. 

  2150. SOAP_FMAC2
    2151. 

  2151. soap_pop_block(struct soap *soap, struct soap_blist *b)
    2152. 

  2152. { char *p;
    2153. 

  2153.   if (!b)
    2154. 

  2154.     b = soap->blist;
    2155. 

  2155.   if (!b->ptr)
    2156. 

  2156.     return;
    2157. 

  2157.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Pop block\n"));
    2158. 

  2158.   p = b->ptr;
    2159. 

  2159.   b->size -= *(size_t*)(p + sizeof(char*));
    2160. 

  2160.   b->ptr = *(char**)p;
    2161. 

  2161.   SOAP_FREE(soap, p);
    2162. 

  2162. }
    2163. 

  2163. #endif
    2164. 

  2164. 

  2165. /******************************************************************************/
    2166. 

  2166. #ifndef WITH_NOIDREF
    2167. 

  2167. #ifndef PALM_1
    2168. 

  2168. static void
    2169. 

  2169. soap_update_ptrs(struct soap *soap, char *start, char *end, char *p1, char *p2)
    2170. 

  2170. { int i;
    2171. 

  2171.   register struct soap_ilist *ip = NULL;
    2172. 

  2172.   register struct soap_flist *fp = NULL;
    2173. 

  2173. #ifndef WITH_LEANER
    2174. 

  2174.   register struct soap_xlist *xp = NULL;
    2175. 

  2175. #endif
    2176. 

  2176.   register void *p, **q;
    2177. 

  2177.   for (i = 0; i < SOAP_IDHASH; i++)
    2178. 

  2178.   { for (ip = soap->iht[i]; ip; ip = ip->next)
    2179. 

  2179.     { if (ip->ptr && (char*)ip->ptr >= start && (char*)ip->ptr < end)
    2180. 

  2180.       { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Update id='%s' %p -> %p\n", ip->id, ip->ptr, (char*)ip->ptr + (p1-p2)));
    2181. 

  2181.         ip->ptr = (char*)ip->ptr + (p1-p2);
    2182. 

  2182.       }
    2183. 

  2183.       for (q = &ip->link; q; q = (void**)p)
    2184. 

  2184.       { p = *q;
    2185. 

  2185.         if (p && (char*)p >= start && (char*)p < end)
    2186. 

  2186.         { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Link update id='%s' %p\n", ip->id, p));
    2187. 

  2187.           *q = (char*)p + (p1-p2);
    2188. 

  2188.         }
    2189. 

  2189.       }
    2190. 

  2190.       for (q = &ip->copy; q; q = (void**)p)
    2191. 

  2191.       { p = *q;
    2192. 

  2192.         if (p && (char*)p >= start && (char*)p < end)
    2193. 

  2193.         { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy chain update id='%s' %p\n", ip->id, p));
    2194. 

  2194.           *q = (char*)p + (p1-p2);
    2195. 

  2195.         }
    2196. 

  2196.       }
    2197. 

  2197.       for (fp = ip->flist; fp; fp = fp->next)
    2198. 

  2198.       { if ((char*)fp->ptr >= start && (char*)fp->ptr < end)
    2199. 

  2199.         { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy list update id='%s' %p\n", ip->id, fp));
    2200. 

  2200.           fp->ptr = (char*)fp->ptr + (p1-p2);
    2201. 

  2201.         }
    2202. 

  2202.       }
    2203. 

  2203.     }
    2204. 

  2204.   }
    2205. 

  2205. #ifndef WITH_LEANER
    2206. 

  2206.   for (xp = soap->xlist; xp; xp = xp->next)
    2207. 

  2207.   { if (xp->ptr && (char*)xp->ptr >= start && (char*)xp->ptr < end)
    2208. 

  2208.     { 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)));
    2209. 

  2209.       xp->ptr = (unsigned char**)((char*)xp->ptr + (p1-p2));
    2210. 

  2210.       xp->size = (int*)((char*)xp->size + (p1-p2));
    2211. 

  2211.       xp->type = (char**)((char*)xp->type + (p1-p2));
    2212. 

  2212.       xp->options = (char**)((char*)xp->options + (p1-p2));
    2213. 

  2213.     }
    2214. 

  2214.   }
    2215. 

  2215. #endif
    2216. 

  2216. }
    2217. 

  2217. #endif
    2218. 

  2218. #endif
    2219. 

  2219. 

  2220. /******************************************************************************/
    2221. 

  2221. #ifndef WITH_NOIDREF
    2222. 

  2222. #ifndef PALM_1
    2223. 

  2223. static int
    2224. 

  2224. soap_has_copies(struct soap *soap, register const char *start, register const char *end)
    2225. 

  2225. { register int i;
    2226. 

  2226.   register struct soap_ilist *ip = NULL;
    2227. 

  2227.   register struct soap_flist *fp = NULL;
    2228. 

  2228.   register const char *p;
    2229. 

  2229.   for (i = 0; i < SOAP_IDHASH; i++)
    2230. 

  2230.   { for (ip = soap->iht[i]; ip; ip = ip->next)
    2231. 

  2231.     { for (p = (const char*)ip->copy; p; p = *(const char**)p)
    2232. 

  2232.         if (p >= start && p < end)
    2233. 

  2233.           return SOAP_ERR;
    2234. 

  2234.       for (fp = ip->flist; fp; fp = fp->next)
    2235. 

  2235.         if ((const char*)fp->ptr >= start && (const char*)fp->ptr < end)
    2236. 

  2236.           return SOAP_ERR;
    2237. 

  2237.     }
    2238. 

  2238.   }
    2239. 

  2239.   return SOAP_OK;
    2240. 

  2240. }
    2241. 

  2241. #endif
    2242. 

  2242. #endif
    2243. 

  2243. 

  2244. /******************************************************************************/
    2245. 

  2245. #ifndef WITH_NOIDREF
    2246. 

  2246. #ifndef PALM_1
    2247. 

  2247. SOAP_FMAC1
    2248. 

  2248. int
    2249. 

  2249. SOAP_FMAC2
    2250. 

  2250. soap_resolve(struct soap *soap)
    2251. 

  2251. { register int i;
    2252. 

  2252.   register struct soap_ilist *ip = NULL;
    2253. 

  2253.   register struct soap_flist *fp = NULL;
    2254. 

  2254.   short flag;
    2255. 

  2255.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Resolving forwarded data\n"));
    2256. 

  2256.   for (i = 0; i < SOAP_IDHASH; i++)
    2257. 

  2257.   { for (ip = soap->iht[i]; ip; ip = ip->next)
    2258. 

  2258.     { if (ip->ptr)
    2259. 

  2259.       { register void *p, **q, *r;
    2260. 

  2260.         q = (void**)ip->link;
    2261. 

  2261.         ip->link = NULL;
    2262. 

  2262.         r = ip->ptr;
    2263. 

  2263.         DBGLOG(TEST, if (q) SOAP_MESSAGE(fdebug, "Traversing link chain to resolve id='%s'\n", ip->id));
    2264. 

  2264.         while (q)
    2265. 

  2265.         { p = *q;
    2266. 

  2266.           *q = r;
    2267. 

  2267.           DBGLOG(TEST,SOAP_MESSAGE(fdebug, "... link %p -> %p\n", q, r));
    2268. 

  2268.           q = (void**)p;
    2269. 

  2269.         }
    2270. 

  2270.       }
    2271. 

  2271.       else if (*ip->id == '#')
    2272. 

  2272.       { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Missing data for id='%s'\n", ip->id));
    2273. 

  2273.         /* Oracle customization */
    2274. 

  2274.         strncpy(soap->id, ip->id + 1, sizeof(soap->id) - 1);
    2275. 

  2275.         soap->id[sizeof(soap->id) - 1] = '\0';
    2276. 

  2276.         return soap->error = SOAP_MISSING_ID;
    2277. 

  2277.       }
    2278. 

  2278.     }
    2279. 

  2279.   }
    2280. 

  2280.   do
    2281. 

  2281.   { flag = 0;
    2282. 

  2282.     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Resolution phase\n"));
    2283. 

  2283.     for (i = 0; i < SOAP_IDHASH; i++)
    2284. 

  2284.     { for (ip = soap->iht[i]; ip; ip = ip->next)
    2285. 

  2285.       { if (ip->ptr && !soap_has_copies(soap, (const char*)ip->ptr, (const char*)ip->ptr + ip->size))
    2286. 

  2286.         { if (ip->copy)
    2287. 

  2287.           { register void *p, **q = (void**)ip->copy;
    2288. 

  2288.             DBGLOG(TEST, if (q) SOAP_MESSAGE(fdebug, "Traversing copy chain to resolve id='%s'\n", ip->id));
    2289. 

  2289.             ip->copy = NULL;
    2290. 

  2290.             do
    2291. 

  2291.             { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "... copy %p -> %p (%u bytes)\n", ip->ptr, q, (unsigned int)ip->size));
    2292. 

  2292.               p = *q;
    2293. 

  2293.               memcpy(q, ip->ptr, ip->size);
    2294. 

  2294.               q = (void**)p;
    2295. 

  2295.             } while (q);
    2296. 

  2296.             flag = 1;
    2297. 

  2297.           }
    2298. 

  2298.           for (fp = ip->flist; fp; fp = ip->flist)
    2299. 

  2299.           { register unsigned int k = fp->level;
    2300. 

  2300.             register void *p = ip->ptr;
    2301. 

  2301.             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));
    2302. 

  2302.             while (ip->level < k)
    2303. 

  2303.             { register void **q = (void**)soap_malloc(soap, sizeof(void*));  
    2304. 

  2304.               if (!q)
    2305. 

  2305.                 return soap->error;
    2306. 

  2306.               *q = p;
    2307. 

  2307.               DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Descending one level, new location=%p holds=%p...\n", q, *q));
    2308. 

  2308.               p = (void*)q;
    2309. 

  2309.               k--;
    2310. 

  2310.             }
    2311. 

  2311.             if (fp->fcopy)
    2312. 

  2312.               fp->fcopy(soap, ip->type, fp->type, fp->ptr, fp->len, p, ip->size);
    2313. 

  2313.             else
    2314. 

  2314.               soap_fcopy(soap, ip->type, fp->type, fp->ptr, fp->len, p, ip->size);
    2315. 

  2315.             ip->flist = fp->next;
    2316. 

  2316.             SOAP_FREE(soap, fp);
    2317. 

  2317.             flag = 1;
    2318. 

  2318.           }
    2319. 

  2319.         }
    2320. 

  2320.       }
    2321. 

  2321.     }
    2322. 

  2322.   } while (flag);
    2323. 

  2323. #ifdef SOAP_DEBUG
    2324. 

  2324.   for (i = 0; i < SOAP_IDHASH; i++)
    2325. 

  2325.   { for (ip = soap->iht[i]; ip; ip = ip->next)
    2326. 

  2326.     { if (ip->copy || ip->flist)
    2327. 

  2327.       { 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));
    2328. 

  2328.       }
    2329. 

  2329.     }
    2330. 

  2330.   }
    2331. 

  2331. #endif
    2332. 

  2332.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Resolution done\n"));
    2333. 

  2333.   return SOAP_OK;
    2334. 

  2334. }
    2335. 

  2335. #endif
    2336. 

  2336. #endif
    2337. 

  2337. 

  2338. /******************************************************************************/
    2339. 

  2339. #ifndef PALM_1
    2340. 

  2340. SOAP_FMAC1
    2341. 

  2341. size_t
    2342. 

  2342. SOAP_FMAC2
    2343. 

  2343. soap_size_block(struct soap *soap, struct soap_blist *b, size_t n)
    2344. 

  2344. { if (!b)
    2345. 

  2345.     b = soap->blist;
    2346. 

  2346.   if (b->ptr)
    2347. 

  2347.   { b->size -= *(size_t*)(b->ptr + sizeof(char*)) - n;
    2348. 

  2348.     *(size_t*)(b->ptr + sizeof(char*)) = n;
    2349. 

  2349.   }
    2350. 

  2350.   return b->size;
    2351. 

  2351. }
    2352. 

  2352. #endif
    2353. 

  2353. 

  2354. /******************************************************************************/
    2355. 

  2355. #ifndef PALM_1
    2356. 

  2356. SOAP_FMAC1
    2357. 

  2357. char*
    2358. 

  2358. SOAP_FMAC2
    2359. 

  2359. soap_first_block(struct soap *soap, struct soap_blist *b)
    2360. 

  2360. { char *p, *q, *r;
    2361. 

  2361.   if (!b)
    2362. 

  2362.     b = soap->blist;
    2363. 

  2363.   p = b->ptr;
    2364. 

  2364.   if (!p)
    2365. 

  2365.     return NULL;
    2366. 

  2366.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "First block\n"));
    2367. 

  2367.   r = NULL;
    2368. 

  2368.   do
    2369. 

  2369.   { q = *(char**)p;
    2370. 

  2370.     *(char**)p = r;
    2371. 

  2371.     r = p;
    2372. 

  2372.     p = q;
    2373. 

  2373.   } while (p);
    2374. 

  2374.   b->ptr = r;
    2375. 

  2375.   return r + sizeof(char*) + sizeof(size_t);
    2376. 

  2376. }
    2377. 

  2377. #endif
    2378. 

  2378. 

  2379. /******************************************************************************/
    2380. 

  2380. #ifndef PALM_1
    2381. 

  2381. SOAP_FMAC1
    2382. 

  2382. char*
    2383. 

  2383. SOAP_FMAC2
    2384. 

  2384. soap_next_block(struct soap *soap, struct soap_blist *b)
    2385. 

  2385. { char *p;
    2386. 

  2386.   if (!b)
    2387. 

  2387.     b = soap->blist;
    2388. 

  2388.   p = b->ptr;
    2389. 

  2389.   if (p)
    2390. 

  2390.   { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Next block\n"));
    2391. 

  2391.     b->ptr = *(char**)p;
    2392. 

  2392.     SOAP_FREE(soap, p);
    2393. 

  2393.     if (b->ptr)
    2394. 

  2394.       return b->ptr + sizeof(char*) + sizeof(size_t);
    2395. 

  2395.   }
    2396. 

  2396.   return NULL;
    2397. 

  2397. }
    2398. 

  2398. #endif
    2399. 

  2399. 

  2400. /******************************************************************************/
    2401. 

  2401. #ifndef PALM_1
    2402. 

  2402. SOAP_FMAC1
    2403. 

  2403. size_t
    2404. 

  2404. SOAP_FMAC2
    2405. 

  2405. soap_block_size(struct soap *soap, struct soap_blist *b)
    2406. 

  2406. { if (!b)
    2407. 

  2407.     b = soap->blist;
    2408. 

  2408.   return *(size_t*)(b->ptr + sizeof(char*));
    2409. 

  2409. }
    2410. 

  2410. #endif
    2411. 

  2411. 

  2412. /******************************************************************************/
    2413. 

  2413. #ifndef PALM_1
    2414. 

  2414. SOAP_FMAC1
    2415. 

  2415. void
    2416. 

  2416. SOAP_FMAC2
    2417. 

  2417. soap_end_block(struct soap *soap, struct soap_blist *b)
    2418. 

  2418. { char *p, *q;
    2419. 

  2419.   if (!b)
    2420. 

  2420.     b = soap->blist;
    2421. 

  2421.   if (b)
    2422. 

  2422.   { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End of block sequence, free all remaining blocks\n"));
    2423. 

  2423.     for (p = b->ptr; p; p = q)
    2424. 

  2424.     { q = *(char**)p;
    2425. 

  2425.       SOAP_FREE(soap, p);
    2426. 

  2426.     }
    2427. 

  2427.     if (soap->blist == b)
    2428. 

  2428.       soap->blist = b->next;
    2429. 

  2429.     else
    2430. 

  2430.     { struct soap_blist *bp;
    2431. 

  2431.       for (bp = soap->blist; bp; bp = bp->next)
    2432. 

  2432.       { if (bp->next == b)
    2433. 

  2433.         { bp->next = b->next;
    2434. 

  2434. 	  break;
    2435. 

  2435.         }
    2436. 

  2436.       }
    2437. 

  2437.     }
    2438. 

  2438.     SOAP_FREE(soap, b);
    2439. 

  2439.   }
    2440. 

  2440.   DBGLOG(TEST, if (soap->blist) SOAP_MESSAGE(fdebug, "Restore previous block sequence\n"));
    2441. 

  2441. }
    2442. 

  2442. #endif
    2443. 

  2443. 

  2444. /******************************************************************************/
    2445. 

  2445. #ifndef PALM_1
    2446. 

  2446. SOAP_FMAC1
    2447. 

  2447. char*
    2448. 

  2448. SOAP_FMAC2
    2449. 

  2449. soap_save_block(struct soap *soap, struct soap_blist *b, char *p, int flag)
    2450. 

  2450. { register size_t n;
    2451. 

  2451.   register char *q, *s;
    2452. 

  2452.   if (!b)
    2453. 

  2453.     b = soap->blist;
    2454. 

  2454.   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));
    2455. 

  2455.   if (b->size)
    2456. 

  2456.   { if (!p)
    2457. 

  2457.       p = (char*)soap_malloc(soap, b->size);
    2458. 

  2458.     if (p)
    2459. 

  2459.     { for (s = p, q = soap_first_block(soap, b); q; q = soap_next_block(soap, b))
    2460. 

  2460.       { n = soap_block_size(soap, b);
    2461. 

  2461. #ifndef WITH_NOIDREF
    2462. 

  2462.         if (flag)
    2463. 

  2463.           soap_update_ptrs(soap, q, q + n, s, q);
    2464. 

  2464. #endif
    2465. 

  2465.         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy %u bytes from %p to %p\n", (unsigned int)n, q, s));
    2466. 

  2466.         memcpy(s, q, n);
    2467. 

  2467.         s += n;
    2468. 

  2468.       }
    2469. 

  2469.     }
    2470. 

  2470.     else
    2471. 

  2471.       soap->error = SOAP_EOM;
    2472. 

  2472.   }
    2473. 

  2473.   soap_end_block(soap, b);
    2474. 

  2474.   return p;
    2475. 

  2475. }
    2476. 

  2476. #endif
    2477. 

  2477. 

  2478. /******************************************************************************/
    2479. 

  2479. #ifndef PALM_2
    2480. 

  2480. SOAP_FMAC1
    2481. 

  2481. char *
    2482. 

  2482. SOAP_FMAC2
    2483. 

  2483. soap_putsize(struct soap *soap, const char *type, int size)
    2484. 

  2484. { return soap_putsizes(soap, type, &size, 1);
    2485. 

  2485. }
    2486. 

  2486. #endif
    2487. 

  2487. 

  2488. /******************************************************************************/
    2489. 

  2489. #ifndef PALM_2
    2490. 

  2490. SOAP_FMAC1
    2491. 

  2491. char *
    2492. 

  2492. SOAP_FMAC2
    2493. 

  2493. soap_putsizes(struct soap *soap, const char *type, const int *size, int dim)
    2494. 

  2494. { return soap_putsizesoffsets(soap, type, size, NULL, dim);
    2495. 

  2495. }
    2496. 

  2496. #endif
    2497. 

  2497. 

  2498. /******************************************************************************/
    2499. 

  2499. #ifndef PALM_2
    2500. 

  2500. SOAP_FMAC1
    2501. 

  2501. char *
    2502. 

  2502. SOAP_FMAC2
    2503. 

  2503. soap_putsizesoffsets(struct soap *soap, const char *type, const int *size, const int *offset, int dim)
    2504. 

  2504. { int i;
    2505. 

  2505.   if (!type)
    2506. 

  2506.     return NULL;
    2507. 

  2507.   if (soap->version == 2)
    2508. 

  2508.   { sprintf(soap->type, "%s[%d", type, size[0]);
    2509. 

  2509.     for (i = 1; i < dim; i++)
    2510. 

  2510.       sprintf(soap->type + strlen(soap->type), " %d", size[i]);
    2511. 

  2511.   }
    2512. 

  2512.   else
    2513. 

  2513.   { if (offset)
    2514. 

  2514.     { sprintf(soap->type, "%s[%d", type, size[0] + offset[0]);
    2515. 

  2515.       for (i = 1; i < dim; i++)
    2516. 

  2516.         sprintf(soap->type + strlen(soap->type), ",%d", size[i] + offset[i]);
    2517. 

  2517.     }
    2518. 

  2518.     else
    2519. 

  2519.     { sprintf(soap->type, "%s[%d", type, size[0]);
    2520. 

  2520.       for (i = 1; i < dim; i++)
    2521. 

  2521.         sprintf(soap->type + strlen(soap->type), ",%d", size[i]);
    2522. 

  2522.     }
    2523. 

  2523.     strcat(soap->type, "]");
    2524. 

  2524.   }
    2525. 

  2525.   return soap->type;
    2526. 

  2526. }
    2527. 

  2527. #endif
    2528. 

  2528. 

  2529. /******************************************************************************/
    2530. 

  2530. #ifndef PALM_2
    2531. 

  2531. SOAP_FMAC1
    2532. 

  2532. char *
    2533. 

  2533. SOAP_FMAC2
    2534. 

  2534. soap_putoffset(struct soap *soap, int offset)
    2535. 

  2535. { return soap_putoffsets(soap, &offset, 1);
    2536. 

  2536. }
    2537. 

  2537. #endif
    2538. 

  2538. 

  2539. /******************************************************************************/
    2540. 

  2540. #ifndef PALM_2
    2541. 

  2541. SOAP_FMAC1
    2542. 

  2542. char *
    2543. 

  2543. SOAP_FMAC2
    2544. 

  2544. soap_putoffsets(struct soap *soap, const int *offset, int dim)
    2545. 

  2545. { register int i;
    2546. 

  2546.   sprintf(soap->arrayOffset, "[%d", offset[0]);
    2547. 

  2547.   for (i = 1; i < dim; i++)
    2548. 

  2548.     sprintf(soap->arrayOffset + strlen(soap->arrayOffset), ",%d", offset[i]);
    2549. 

  2549.   strcat(soap->arrayOffset, "]");
    2550. 

  2550.   return soap->arrayOffset;
    2551. 

  2551. }
    2552. 

  2552. #endif
    2553. 

  2553. 

  2554. /******************************************************************************/
    2555. 

  2555. #ifndef PALM_2
    2556. 

  2556. SOAP_FMAC1
    2557. 

  2557. int
    2558. 

  2558. SOAP_FMAC2
    2559. 

  2559. soap_size(const int *size, int dim)
    2560. 

  2560. { register int i, n = size[0];
    2561. 

  2561.   for (i = 1; i < dim; i++)
    2562. 

  2562.     n *= size[i];
    2563. 

  2563.   return n;
    2564. 

  2564. }
    2565. 

  2565. #endif
    2566. 

  2566. 

  2567. /******************************************************************************/
    2568. 

  2568. #ifndef PALM_2
    2569. 

  2569. SOAP_FMAC1
    2570. 

  2570. int
    2571. 

  2571. SOAP_FMAC2
    2572. 

  2572. soap_getoffsets(const char *attr, const int *size, int *offset, int dim)
    2573. 

  2573. { register int i, j = 0;
    2574. 

  2574.   if (offset)
    2575. 

  2575.     for (i = 0; i < dim && attr && *attr; i++)
    2576. 

  2576.     { attr++;
    2577. 

  2577.       j *= size[i];
    2578. 

  2578.       j += offset[i] = (int)soap_strtol(attr, NULL, 10);
    2579. 

  2579.       attr = strchr(attr, ',');
    2580. 

  2580.     }
    2581. 

  2581.   else
    2582. 

  2582.     for (i = 0; i < dim && attr && *attr; i++)
    2583. 

  2583.     { attr++;
    2584. 

  2584.       j *= size[i];
    2585. 

  2585.       j += (int)soap_strtol(attr, NULL, 10);
    2586. 

  2586.       attr = strchr(attr, ',');
    2587. 

  2587.     }
    2588. 

  2588.   return j;
    2589. 

  2589. }
    2590. 

  2590. #endif
    2591. 

  2591. 

  2592. /******************************************************************************/
    2593. 

  2593. #ifndef PALM_2
    2594. 

  2594. SOAP_FMAC1
    2595. 

  2595. int
    2596. 

  2596. SOAP_FMAC2
    2597. 

  2597. soap_getsize(const char *attr1, const char *attr2, int *j)
    2598. 

  2598. { register int n, k;
    2599. 

  2599.   char *s;
    2600. 

  2600.   *j = 0;
    2601. 

  2601.   if (!*attr1)
    2602. 

  2602.     return -1;
    2603. 

  2603.   if (*attr1 == '[')
    2604. 

  2604.     attr1++;
    2605. 

  2605.   n = 1;
    2606. 

  2606.   for (;;)
    2607. 

  2607.   { k = (int)soap_strtol(attr1, &s, 10);
    2608. 

  2608.     n *= k;
    2609. 

  2609.     if (k < 0 || n > SOAP_MAXARRAYSIZE || s == attr1)
    2610. 

  2610.       return -1;
    2611. 

  2611.     attr1 = strchr(s, ',');
    2612. 

  2612.     if (!attr1)
    2613. 

  2613.       attr1 = strchr(s, ' ');
    2614. 

  2614.     if (attr2 && *attr2)
    2615. 

  2615.     { attr2++;
    2616. 

  2616.       *j *= k;
    2617. 

  2617.       k = (int)soap_strtol(attr2, &s, 10);
    2618. 

  2618.       *j += k;
    2619. 

  2619.       if (k < 0)
    2620. 

  2620.         return -1;
    2621. 

  2621.       attr2 = s;
    2622. 

  2622.     }
    2623. 

  2623.     if (!attr1)
    2624. 

  2624.       break;
    2625. 

  2625.     attr1++;
    2626. 

  2626.   }
    2627. 

  2627.   return n - *j;
    2628. 

  2628. }
    2629. 

  2629. #endif
    2630. 

  2630. 

  2631. /******************************************************************************/
    2632. 

  2632. #ifndef PALM_2
    2633. 

  2633. SOAP_FMAC1
    2634. 

  2634. int
    2635. 

  2635. SOAP_FMAC2
    2636. 

  2636. soap_getsizes(const char *attr, int *size, int dim)
    2637. 

  2637. { register int i, k, n;
    2638. 

  2638.   if (!*attr)
    2639. 

  2639.     return -1;
    2640. 

  2640.   i = (int)strlen(attr);
    2641. 

  2641.   n = 1;
    2642. 

  2642.   do
    2643. 

  2643.   { for (i = i-1; i >= 0; i--)
    2644. 

  2644.       if (attr[i] == '[' || attr[i] == ',' || attr[i] == ' ')
    2645. 

  2645.         break;
    2646. 

  2646.     k = (int)soap_strtol(attr + i + 1, NULL, 10);
    2647. 

  2647.     n *= size[--dim] = k;
    2648. 

  2648.     if (k < 0 || n > SOAP_MAXARRAYSIZE)
    2649. 

  2649.       return -1;
    2650. 

  2650.   } while (i >= 0 && attr[i] != '[');
    2651. 

  2651.   return n;
    2652. 

  2652. }
    2653. 

  2653. #endif
    2654. 

  2654. 

  2655. /******************************************************************************/
    2656. 

  2656. #ifndef PALM_2
    2657. 

  2657. SOAP_FMAC1
    2658. 

  2658. int
    2659. 

  2659. SOAP_FMAC2
    2660. 

  2660. soap_getposition(const char *attr, int *pos)
    2661. 

  2661. { register int i, n;
    2662. 

  2662.   if (!*attr)
    2663. 

  2663.     return -1;
    2664. 

  2664.   n = 0;
    2665. 

  2665.   i = 1;
    2666. 

  2666.   do
    2667. 

  2667.   { pos[n++] = (int)soap_strtol(attr + i, NULL, 10);
    2668. 

  2668.     while (attr[i] && attr[i] != ',' && attr[i] != ']')
    2669. 

  2669.       i++;
    2670. 

  2670.     if (attr[i] == ',')
    2671. 

  2671.       i++;
    2672. 

  2672.   } while (n < SOAP_MAXDIMS && attr[i] && attr[i] != ']');
    2673. 

  2673.   return n;
    2674. 

  2674. }
    2675. 

  2675. #endif
    2676. 

  2676. 

  2677. /******************************************************************************/
    2678. 

  2678. #ifndef PALM_2
    2679. 

  2679. SOAP_FMAC1
    2680. 

  2680. struct soap_nlist *
    2681. 

  2681. SOAP_FMAC2
    2682. 

  2682. soap_push_namespace(struct soap *soap, const char *id, const char *ns)
    2683. 

  2683. { register struct soap_nlist *np;
    2684. 

  2684.   register struct Namespace *p;
    2685. 

  2685.   register short i = -1;
    2686. 

  2686.   register size_t n, k;
    2687. 

  2687.   n = strlen(id);
    2688. 

  2688.   k = strlen(ns) + 1;
    2689. 

  2689.   p = soap->local_namespaces;
    2690. 

  2690.   if (p)
    2691. 

  2691.   { for (i = 0; p->id; p++, i++)
    2692. 

  2692.     { if (p->ns && !strcmp(ns, p->ns))
    2693. 

  2693.       { if (p->out)
    2694. 

  2694.         { SOAP_FREE(soap, p->out);
    2695. 

  2695.           p->out = NULL;
    2696. 

  2696.         }
    2697. 

  2697.         break;
    2698. 

  2698.       }
    2699. 

  2699.       if (p->out)
    2700. 

  2700.       { if (!strcmp(ns, p->out))
    2701. 

  2701.           break;
    2702. 

  2702.       }
    2703. 

  2703.       else if (p->in)
    2704. 

  2704.       { if (!soap_tag_cmp(ns, p->in))
    2705. 

  2705.         { if ((p->out = (char*)SOAP_MALLOC(soap, k)))
    2706. 

  2706.             strcpy(p->out, ns);
    2707. 

  2707.           break;
    2708. 

  2708.         }
    2709. 

  2709.       }
    2710. 

  2710.     }
    2711. 

  2711.     if (!p || !p->id)
    2712. 

  2712.       i = -1;
    2713. 

  2713.   }
    2714. 

  2714.   if (i >= 0)
    2715. 

  2715.     k = 0;
    2716. 

  2716.   np = (struct soap_nlist*)SOAP_MALLOC(soap, sizeof(struct soap_nlist) + n + k);
    2717. 

  2717.   if (!np)
    2718. 

  2718.   { soap->error = SOAP_EOM;
    2719. 

  2719.     return NULL;
    2720. 

  2720.   }
    2721. 

  2721.   np->next = soap->nlist;
    2722. 

  2722.   soap->nlist = np;
    2723. 

  2723.   np->level = soap->level;
    2724. 

  2724.   np->index = i;
    2725. 

  2725.   strcpy(np->id, id);
    2726. 

  2726.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Push namespace binding (level=%u) '%s' '%s'\n", soap->level, id, ns));
    2727. 

  2727.   if (i < 0)
    2728. 

  2728.   { np->ns = strcpy(np->id + n + 1, ns);
    2729. 

  2729.     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Push NOT OK: no match found for '%s' in namespace mapping table (added to stack anyway)\n", ns));
    2730. 

  2730.   }
    2731. 

  2731.   else
    2732. 

  2732.   { np->ns = NULL;
    2733. 

  2733.     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Push OK ('%s' matches '%s' in namespace table)\n", id, p->id));
    2734. 

  2734.   }
    2735. 

  2735.   return np;
    2736. 

  2736. }
    2737. 

  2737. #endif
    2738. 

  2738. 

  2739. /******************************************************************************/
    2740. 

  2740. #ifndef PALM_2
    2741. 

  2741. SOAP_FMAC1
    2742. 

  2742. void
    2743. 

  2743. SOAP_FMAC2
    2744. 

  2744. soap_pop_namespace(struct soap *soap)
    2745. 

  2745. { register struct soap_nlist *np, *nq;
    2746. 

  2746.   for (np = soap->nlist; np && np->level >= soap->level; np = nq)
    2747. 

  2747.   { nq = np->next;
    2748. 

  2748.     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Pop namespace binding (level=%u) '%s'\n", soap->level, np->id));
    2749. 

  2749.     SOAP_FREE(soap, np);
    2750. 

  2750.   }
    2751. 

  2751.   soap->nlist = np;
    2752. 

  2752. }
    2753. 

  2753. #endif
    2754. 

  2754. 

  2755. /******************************************************************************/
    2756. 

  2756. #ifndef PALM_2
    2757. 

  2757. SOAP_FMAC1
    2758. 

  2758. int
    2759. 

  2759. SOAP_FMAC2
    2760. 

  2760. soap_match_namespace(struct soap *soap, const char *id1, const char *id2, size_t n1, size_t n2) 
    2761. 

  2761. { register struct soap_nlist *np = soap->nlist;
    2762. 

  2762.   while (np && (strncmp(np->id, id1, n1) || np->id[n1]))
    2763. 

  2763.     np = np->next;
    2764. 

  2764.   if (np)
    2765. 

  2765.   { if (!(soap->mode & SOAP_XML_IGNORENS))
    2766. 

  2766.       if (np->index < 0
    2767. 

  2767.        || (soap->local_namespaces[np->index].id
    2768. 

  2768.         && (strncmp(soap->local_namespaces[np->index].id, id2, n2)
    2769. 

  2769.          || soap->local_namespaces[np->index].id[n2])))
    2770. 

  2770.         return SOAP_NAMESPACE;
    2771. 

  2771.     return SOAP_OK;
    2772. 

  2772.   }
    2773. 

  2773.   if (n1 == 0)
    2774. 

  2774.     return SOAP_NAMESPACE;
    2775. 

  2775.   if ((n1 == 3 && n1 == n2 && !strncmp(id1, "xml", 3) && !strncmp(id1, id2, 3))
    2776. 

  2776.    || (soap->mode & SOAP_XML_IGNORENS))
    2777. 

  2777.     return SOAP_OK;
    2778. 

  2778.   return soap->error = SOAP_SYNTAX_ERROR; 
    2779. 

  2779. }
    2780. 

  2780. #endif
    2781. 

  2781. 

  2782. /******************************************************************************/
    2783. 

  2783. #ifndef PALM_2
    2784. 

  2784. SOAP_FMAC1
    2785. 

  2785. const char*
    2786. 

  2786. SOAP_FMAC2
    2787. 

  2787. soap_current_namespace(struct soap *soap, const char *tag)
    2788. 

  2788. { register struct soap_nlist *np;
    2789. 

  2789.   register const char *s;
    2790. 

  2790.   if (!tag || !strncmp(tag, "xml", 3))
    2791. 

  2791.     return NULL;
    2792. 

  2792.   np = soap->nlist;
    2793. 

  2793.   if (!(s = strchr(tag, ':')))
    2794. 

  2794.   { while (np && *np->id) /* find default namespace, if present */
    2795. 

  2795.       np = np->next;
    2796. 

  2796.   }
    2797. 

  2797.   else
    2798. 

  2798.   { while (np && (strncmp(np->id, tag, s - tag) || np->id[s - tag]))
    2799. 

  2799.       np = np->next;
    2800. 

  2800.     if (!np)
    2801. 

  2801.       soap->error = SOAP_NAMESPACE;
    2802. 

  2802.   }
    2803. 

  2803.   if (np)
    2804. 

  2804.   { if (np->index >= 0)
    2805. 

  2805.       return soap->namespaces[np->index].ns;
    2806. 

  2806.     if (np->ns)
    2807. 

  2807.       return soap_strdup(soap, np->ns);
    2808. 

  2808.   }
    2809. 

  2809.   return NULL;
    2810. 

  2810. }
    2811. 

  2811. #endif
    2812. 

  2812. 

  2813. /******************************************************************************/
    2814. 

  2814. #ifndef PALM_2
    2815. 

  2815. SOAP_FMAC1
    2816. 

  2816. int
    2817. 

  2817. SOAP_FMAC2
    2818. 

  2818. soap_tag_cmp(const char *s, const char *t)
    2819. 

  2819. { for (;;)
    2820. 

  2820.   { register int c1 = *s;
    2821. 

  2821.     register int c2 = *t;
    2822. 

  2822.     if (!c1 || c1 == '"')
    2823. 

  2823.       break;
    2824. 

  2824.     if (c2 != '-')
    2825. 

  2825.     { if (c1 != c2)
    2826. 

  2826.       { if (c1 >= 'A' && c1 <= 'Z')
    2827. 

  2827.           c1 += 'a' - 'A';
    2828. 

  2828.         if (c2 >= 'A' && c2 <= 'Z')
    2829. 

  2829.           c2 += 'a' - 'A';
    2830. 

  2830.       }
    2831. 

  2831.       if (c1 != c2)
    2832. 

  2832.       { if (c2 != '*')
    2833. 

  2833.           return 1;
    2834. 

  2834.         c2 = *++t;
    2835. 

  2835.         if (!c2)
    2836. 

  2836.           return 0;
    2837. 

  2837.         if (c2 >= 'A' && c2 <= 'Z')
    2838. 

  2838.           c2 += 'a' - 'A';
    2839. 

  2839.         for (;;)
    2840. 

  2840.         { c1 = *s;
    2841. 

  2841.           if (!c1 || c1 == '"')
    2842. 

  2842.             break;
    2843. 

  2843.           if (c1 >= 'A' && c1 <= 'Z')
    2844. 

  2844.             c1 += 'a' - 'A';
    2845. 

  2845.           if (c1 == c2 && !soap_tag_cmp(s + 1, t + 1))
    2846. 

  2846.             return 0;
    2847. 

  2847.           s++;
    2848. 

  2848.         }
    2849. 

  2849.         break;
    2850. 

  2850.       }
    2851. 

  2851.     }
    2852. 

  2852.     s++;
    2853. 

  2853.     t++;
    2854. 

  2854.   }
    2855. 

  2855.   if (*t == '*' && !t[1])
    2856. 

  2856.     return 0;
    2857. 

  2857.   return *t;
    2858. 

  2858. }
    2859. 

  2859. #endif
    2860. 

  2860. 

  2861. /******************************************************************************/
    2862. 

  2862. #ifndef PALM_2
    2863. 

  2863. SOAP_FMAC1
    2864. 

  2864. int
    2865. 

  2865. SOAP_FMAC2
    2866. 

  2866. soap_match_tag(struct soap *soap, const char *tag1, const char *tag2)
    2867. 

  2867. { register const char *s, *t;
    2868. 

  2868.   register int err;
    2869. 

  2869.   if (!tag1 || !tag2 || !*tag2)
    2870. 

  2870.     return SOAP_OK;
    2871. 

  2871.   s = strchr(tag1, ':');
    2872. 

  2872.   t = strchr(tag2, ':');
    2873. 

  2873.   if (t)
    2874. 

  2874.   { if (s)
    2875. 

  2875.     { if (t[1] && SOAP_STRCMP(s + 1, t + 1))
    2876. 

  2876.         return SOAP_TAG_MISMATCH;
    2877. 

  2877.       if (t != tag2 && (err = soap_match_namespace(soap, tag1, tag2, s - tag1, t - tag2)))
    2878. 

  2878.       { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Tags '%s' and '%s' match but namespaces differ\n", tag1, tag2));
    2879. 

  2879.         if (err == SOAP_NAMESPACE)
    2880. 

  2880.           return SOAP_TAG_MISMATCH;
    2881. 

  2881.         return err;
    2882. 

  2882.       }
    2883. 

  2883.     } 
    2884. 

  2884.     else if (SOAP_STRCMP(tag1, t + 1))
    2885. 

  2885.     { return SOAP_TAG_MISMATCH;
    2886. 

  2886.     }
    2887. 

  2887.     else if (t != tag2 && (err = soap_match_namespace(soap, tag1, tag2, 0, t - tag2)))
    2888. 

  2888.     { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Tags '%s' and '%s' match but namespaces differ\n", tag1, tag2));
    2889. 

  2889.       if (err == SOAP_NAMESPACE)
    2890. 

  2890.         return SOAP_TAG_MISMATCH;
    2891. 

  2891.       return err;
    2892. 

  2892.     }
    2893. 

  2893.     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Tags and (default) namespaces match: '%s' '%s'\n", tag1, tag2));
    2894. 

  2894.     return SOAP_OK;
    2895. 

  2895.   }
    2896. 

  2896.   if (s)
    2897. 

  2897.   { if (SOAP_STRCMP(s + 1, tag2))
    2898. 

  2898.       return SOAP_TAG_MISMATCH;
    2899. 

  2899.   }
    2900. 

  2900.   else if (SOAP_STRCMP(tag1, tag2))
    2901. 

  2901.     return SOAP_TAG_MISMATCH;
    2902. 

  2902.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Tags match: '%s' '%s'\n", tag1, tag2));
    2903. 

  2903.   return SOAP_OK;
    2904. 

  2904. }
    2905. 

  2905. #endif
    2906. 

  2906. 

  2907. /******************************************************************************/
    2908. 

  2908. #ifndef PALM_2
    2909. 

  2909. SOAP_FMAC1
    2910. 

  2910. int
    2911. 

  2911. SOAP_FMAC2
    2912. 

  2912. soap_match_array(struct soap *soap, const char *type)
    2913. 

  2913. { if (*soap->arrayType)
    2914. 

  2914.     if (soap_match_tag(soap, soap->arrayType, type)
    2915. 

  2915.      && soap_match_tag(soap, soap->arrayType, "xsd:anyType")
    2916. 

  2916.      && soap_match_tag(soap, soap->arrayType, "xsd:ur-type")
    2917. 

  2917.     )
    2918. 

  2918.     { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Array type mismatch: '%s' '%s'\n", soap->arrayType, type));
    2919. 

  2919.       return SOAP_TAG_MISMATCH;
    2920. 

  2920.     }
    2921. 

  2921.   return SOAP_OK;
    2922. 

  2922. }
    2923. 

  2923. #endif
    2924. 

  2924. 

  2925. /******************************************************************************\
    2926. 

  2926.  *
    2927. 

  2927.  *	SSL/TLS
    2928. 

  2928.  *
    2929. 

  2929. \******************************************************************************/
    2930. 

  2930. 

  2931. /******************************************************************************/
    2932. 

  2932. #ifdef WITH_OPENSSL
    2933. 

  2933. #ifndef PALM_2
    2934. 

  2934. SOAP_FMAC1
    2935. 

  2935. int
    2936. 

  2936. SOAP_FMAC2
    2937. 

  2937. soap_rand()
    2938. 

  2938. { unsigned char buf[4];
    2939. 

  2939.   if (!soap_ssl_init_done)
    2940. 

  2940.     soap_ssl_init();
    2941. 

  2941.   RAND_pseudo_bytes(buf, 4);
    2942. 

  2942.   return *(int*)buf;
    2943. 

  2943. }
    2944. 

  2944. #endif
    2945. 

  2945. #endif
    2946. 

  2946. 

  2947. /******************************************************************************/
    2948. 

  2948. #ifdef WITH_OPENSSL
    2949. 

  2949. #ifndef PALM_2
    2950. 

  2950. SOAP_FMAC1
    2951. 

  2951. int
    2952. 

  2952. SOAP_FMAC2
    2953. 

  2953. 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)
    2954. 

  2954. { int err;
    2955. 

  2955.   soap->keyfile = keyfile;
    2956. 

  2956.   soap->password = password;
    2957. 

  2957.   soap->cafile = cafile;
    2958. 

  2958.   soap->capath = capath;
    2959. 

  2959.   soap->crlfile = NULL;
    2960. 

  2960.   soap->dhfile = dhfile;
    2961. 

  2961.   soap->randfile = randfile;
    2962. 

  2962.   soap->ssl_flags = flags | (dhfile == NULL ? SOAP_SSL_RSA : 0);
    2963. 

  2963.   if (!(err = soap->fsslauth(soap)))
    2964. 

  2964.   { if (sid)
    2965. 

  2965.       SSL_CTX_set_session_id_context(soap->ctx, (unsigned char*)sid, (unsigned int)strlen(sid));
    2966. 

  2966.     else
    2967. 

  2967.       SSL_CTX_set_session_cache_mode(soap->ctx, SSL_SESS_CACHE_OFF);
    2968. 

  2968.   }
    2969. 

  2969.   return err; 
    2970. 

  2970. }
    2971. 

  2971. #endif
    2972. 

  2972. #endif
    2973. 

  2973. 

  2974. /******************************************************************************/
    2975. 

  2975. #ifdef WITH_OPENSSL
    2976. 

  2976. #ifndef PALM_2
    2977. 

  2977. SOAP_FMAC1
    2978. 

  2978. int
    2979. 

  2979. SOAP_FMAC2
    2980. 

  2980. 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)
    2981. 

  2981. { soap->keyfile = keyfile;
    2982. 

  2982.   soap->password = password;
    2983. 

  2983.   soap->cafile = cafile;
    2984. 

  2984.   soap->capath = capath;
    2985. 

  2985.   soap->dhfile = NULL;
    2986. 

  2986.   soap->ssl_flags = flags;
    2987. 

  2987.   soap->randfile = randfile;
    2988. 

  2988.   soap->fsslverify = (flags & SOAP_SSL_ALLOW_EXPIRED_CERTIFICATE) == 0 ? ssl_verify_callback : ssl_verify_callback_allow_expired_certificate;
    2989. 

  2989.   return soap->fsslauth(soap);
    2990. 

  2990. }
    2991. 

  2991. #endif
    2992. 

  2992. #endif
    2993. 

  2993. 

  2994. /******************************************************************************/
    2995. 

  2995. #ifdef WITH_OPENSSL
    2996. 

  2996. #ifndef PALM_2
    2997. 

  2997. SOAP_FMAC1
    2998. 

  2998. void
    2999. 

  2999. SOAP_FMAC2
    3000. 

  3000. soap_ssl_init()
    3001. 

  3001. { /* Note: for MT systems, the main program MUST call soap_ssl_init() before any threads are started */
    3002. 

  3002.   if (!soap_ssl_init_done)
    3003. 

  3003.   { soap_ssl_init_done = 1;
    3004. 

  3004.     SSL_library_init();
    3005. 

  3005. #ifndef WITH_LEAN
    3006. 

  3006.     SSL_load_error_strings();
    3007. 

  3007. #endif
    3008. 

  3008.     if (!RAND_load_file("/dev/urandom", 1024))
    3009. 

  3009.     { char buf[1024];
    3010. 

  3010.       RAND_seed(buf, sizeof(buf));
    3011. 

  3011.       while (!RAND_status())
    3012. 

  3012.       { int r = rand();
    3013. 

  3013.         RAND_seed(&r, sizeof(int));
    3014. 

  3014.       }
    3015. 

  3015.     }
    3016. 

  3016.   }
    3017. 

  3017. }
    3018. 

  3018. #endif
    3019. 

  3019. #endif
    3020. 

  3020. 

  3021. /******************************************************************************/
    3022. 

  3022. #ifdef WITH_OPENSSL
    3023. 

  3023. #ifndef PALM_1
    3024. 

  3024. SOAP_FMAC1
    3025. 

  3025. const char *
    3026. 

  3026. SOAP_FMAC2
    3027. 

  3027. soap_ssl_error(struct soap *soap, int ret)
    3028. 

  3028. { int err = SSL_get_error(soap->ssl, ret);
    3029. 

  3029.   const char *msg = soap_code_str(h_ssl_error_codes, err);
    3030. 

  3030.   size_t msgbufsize = sizeof(soap->msgbuf);
    3031. 

  3031.   if (msg)
    3032. 

  3032.   { /* Oracle customization */
    3033. 

  3033.     strncpy(soap->msgbuf, msg, msgbufsize - 1);
    3034. 

  3034.     soap->msgbuf[msgbufsize - 1] = '\0';
    3035. 

  3035.   }
    3036. 

  3036.   else
    3037. 

  3037.     return ERR_error_string(err, soap->msgbuf);
    3038. 

  3038.   if (ERR_peek_error())
    3039. 

  3039.   { unsigned long r;
    3040. 

  3040.     /* Oracle customization */
    3041. 

  3041.     if (strlen(soap->msgbuf) < (msgbufsize-1))
    3042. 

  3042.         strcat(soap->msgbuf, "\n");
    3043. 

  3043.     else
    3044. 

  3044.         soap->msgbuf[msgbufsize - 2] = '\n';
    3045. 

  3045.     while ((r = ERR_get_error()))
    3046. 

  3046.       ERR_error_string_n(r, soap->msgbuf + strlen(soap->msgbuf), sizeof(soap->msgbuf) - strlen(soap->msgbuf));
    3047. 

  3047.   } 
    3048. 

  3048.   else
    3049. 

  3049.   { switch (ret)
    3050. 

  3050.     { case 0:
    3051. 

  3051.         {
    3052. 

  3052.           /* Oracle customization -- display SSL error code and string at the end */
    3053. 

  3053.           int myerrno = errno;
    3054. 

  3054.           unsigned long ec = ERR_get_error();
    3055. 

  3055.           sprintf(soap->msgbuf,
    3056. 

  3056.             "EOF was observed that violates the protocol. The client probably provided invalid authentication information. SSL error code is %s. ",
    3057. 

  3057.             msg);
    3058. 

  3058.           if (ec != 0)
    3059. 

  3059.           {
    3060. 

  3060.             /* display the next error string in the error queue */
    3061. 

  3061.             ERR_error_string_n(ec, soap->msgbuf + strlen(soap->msgbuf),
    3062. 

  3062.                 sizeof(soap->msgbuf) - strlen(soap->msgbuf));
    3063. 

  3063.             if (sizeof(soap->msgbuf) - strlen(soap->msgbuf) > 2)
    3064. 

  3064.             {
    3065. 

  3065.                 strcat(soap->msgbuf, ". ");
    3066. 

  3066.             }
    3067. 

  3067.           }
    3068. 

  3068.           if (myerrno != 0)
    3069. 

  3069.           {
    3070. 

  3070.             /* display system error too */
    3071. 

  3071.             char *mystrerror = strerror(myerrno);
    3072. 

  3072.             if (strlen(mystrerror)
    3073. 

  3073.                 < (sizeof(soap->msgbuf) - strlen(soap->msgbuf)))
    3074. 

  3074.             {
    3075. 

  3075.                 strncat(soap->msgbuf + strlen(soap->msgbuf), mystrerror,
    3076. 

  3076.                     strlen(mystrerror));
    3077. 

  3077.             }
    3078. 

  3078.             else
    3079. 

  3079.             {
    3080. 

  3080.                 strncat(soap->msgbuf + strlen(soap->msgbuf), mystrerror,
    3081. 

  3081.                     (sizeof(soap->msgbuf) - strlen(soap->msgbuf)));
    3082. 

  3082.             }
    3083. 

  3083.             soap->msgbuf[sizeof(soap->msgbuf) - 1] = '\0';
    3084. 

  3084.           }
    3085. 

  3085.         }
    3086. 

  3086.         break;
    3087. 

  3087.       case -1:
    3088. 

  3088.         sprintf(soap->msgbuf, "Error observed by underlying BIO: %s", strerror(errno));  
    3089. 

  3089.         break;
    3090. 

  3090.     }
    3091. 

  3091.   }
    3092. 

  3092.   return soap->msgbuf;
    3093. 

  3093. }
    3094. 

  3094. #endif
    3095. 

  3095. #endif
    3096. 

  3096. 

  3097. /******************************************************************************/
    3098. 

  3098. #ifdef WITH_OPENSSL
    3099. 

  3099. #ifndef PALM_1
    3100. 

  3100. static int
    3101. 

  3101. ssl_password(char *buf, int num, int rwflag, void *userdata)
    3102. 

  3102. { if (num < (int)strlen((char*)userdata) + 1)
    3103. 

  3103.     return 0;
    3104. 

  3104.   return (int)strlen(strcpy(buf, (char*)userdata));
    3105. 

  3105. }
    3106. 

  3106. #endif
    3107. 

  3107. #endif
    3108. 

  3108. 

  3109. /******************************************************************************/
    3110. 

  3110. #ifdef WITH_OPENSSL
    3111. 

  3111. #ifndef PALM_1
    3112. 

  3112. /*
    3113. 

  3113. static int
    3114. 

  3114. */
    3115. 

  3115. int
    3116. 

  3116. ssl_auth_init(struct soap *soap)
    3117. 

  3117. { long flags;
    3118. 

  3118.   int mode;
    3119. 

  3119.   if (!soap_ssl_init_done)
    3120. 

  3120.     soap_ssl_init();
    3121. 

  3121.   ERR_clear_error();
    3122. 

  3122.   if (!soap->ctx)
    3123. 

  3123.   { if (!(soap->ctx = SSL_CTX_new(SSLv23_method())))
    3124. 

  3124.       return soap_set_receiver_error(soap, "SSL error", "Can't setup context", SOAP_SSL_ERROR);
    3125. 

  3125.     /* The following alters the behavior of SSL read/write: */
    3126. 

  3126. #if 0
    3127. 

  3127.     SSL_CTX_set_mode(soap->ctx, SSL_MODE_ENABLE_PARTIAL_WRITE | SSL_MODE_AUTO_RETRY);
    3128. 

  3128. #endif
    3129. 

  3129.   }
    3130. 

  3130.   //
    3131. 

  3131.   // Oracle customization
    3132. 

  3132.   //
    3133. 

  3133.   // added SSL_CTX_set_cipher_list call to restrict the cipher suite to RSA-2048/AES
    3134. 

  3134.   // TLS_RSA_WITH_AES_256_CBC_SHA is defined in RFC 3268
    3135. 

  3135.   // also see http://www.openssl.org/docs/apps/ciphers.html
    3136. 

  3136.   //
    3137. 

  3137.     if (!SSL_CTX_set_cipher_list(soap->ctx, "AES256-SHA"))
    3138. 

  3138.         return soap_set_receiver_error(soap, "SSL error", "Cannot set cipher suite", SOAP_SSL_ERROR);
    3139. 

  3139.   if (soap->randfile)
    3140. 

  3140.   { if (!RAND_load_file(soap->randfile, -1))
    3141. 

  3141.       return soap_set_receiver_error(soap, "SSL error", "Can't load randomness", SOAP_SSL_ERROR);
    3142. 

  3142.   }
    3143. 

  3143.   if (soap->cafile || soap->capath)
    3144. 

  3144.   { if (!SSL_CTX_load_verify_locations(soap->ctx, soap->cafile, soap->capath))
    3145. 

  3145.       return soap_set_receiver_error(soap, "SSL error", "Can't read CA file and directory", SOAP_SSL_ERROR);
    3146. 

  3146.     if (soap->cafile && (soap->ssl_flags & SOAP_SSL_REQUIRE_CLIENT_AUTHENTICATION))
    3147. 

  3147.       SSL_CTX_set_client_CA_list(soap->ctx, SSL_load_client_CA_file(soap->cafile));
    3148. 

  3148.   }
    3149. 

  3149.   if (!(soap->ssl_flags & SOAP_SSL_NO_DEFAULT_CA_PATH))
    3150. 

  3150.   { if (!SSL_CTX_set_default_verify_paths(soap->ctx))
    3151. 

  3151.       return soap_set_receiver_error(soap, "SSL error", "Can't read default CA file and/or directory", SOAP_SSL_ERROR);
    3152. 

  3152.   }
    3153. 

  3153. /* This code assumes a typical scenario, see alternative code below */
    3154. 

  3154.   if (soap->keyfile)
    3155. 

  3155.   { if (!SSL_CTX_use_certificate_chain_file(soap->ctx, soap->keyfile))
    3156. 

  3156.       return soap_set_receiver_error(soap, "SSL error", "Can't read certificate key file", SOAP_SSL_ERROR);
    3157. 

  3157.     if (soap->password)
    3158. 

  3158.     { SSL_CTX_set_default_passwd_cb_userdata(soap->ctx, (void*)soap->password);
    3159. 

  3159.       SSL_CTX_set_default_passwd_cb(soap->ctx, ssl_password);
    3160. 

  3160.     }
    3161. 

  3161.     if (!SSL_CTX_use_PrivateKey_file(soap->ctx, soap->keyfile, SSL_FILETYPE_PEM))
    3162. 

  3162.       return soap_set_receiver_error(soap, "SSL error", "Can't read key file", SOAP_SSL_ERROR);
    3163. 

  3163.   }
    3164. 

  3164. /* Suggested alternative approach to check the key file for certs (cafile=NULL):*/
    3165. 

  3165. #if 0
    3166. 

  3166.   if (soap->password)
    3167. 

  3167.   { SSL_CTX_set_default_passwd_cb_userdata(soap->ctx, (void*)soap->password);
    3168. 

  3168.     SSL_CTX_set_default_passwd_cb(soap->ctx, ssl_password);
    3169. 

  3169.   }
    3170. 

  3170.   if (!soap->cafile || !SSL_CTX_use_certificate_chain_file(soap->ctx, soap->cafile))
    3171. 

  3171.   { if (soap->keyfile)
    3172. 

  3172.     { if (!SSL_CTX_use_certificate_chain_file(soap->ctx, soap->keyfile))
    3173. 

  3173.         return soap_set_receiver_error(soap, "SSL error", "Can't read certificate or key file", SOAP_SSL_ERROR);
    3174. 

  3174.       if (!SSL_CTX_use_PrivateKey_file(soap->ctx, soap->keyfile, SSL_FILETYPE_PEM))
    3175. 

  3175.         return soap_set_receiver_error(soap, "SSL error", "Can't read key file", SOAP_SSL_ERROR);
    3176. 

  3176.     }
    3177. 

  3177.   }
    3178. 

  3178. #endif
    3179. 

  3179.   if ((soap->ssl_flags & SOAP_SSL_RSA))
    3180. 

  3180.   {
    3181. 

  3181.     /*
    3182. 

  3182.      Oracle customization for OpenSSL 0.9.8 removal of deprecated function usage: RSA_generate_key
    3183. 

  3183.     */
    3184. 

  3184. #ifdef OPENSSL_NO_DEPRECATED
    3185. 

  3185.     RSA *rsa = RSA_new();
    3186. 

  3186.     if (!rsa)
    3187. 

  3187.     {
    3188. 

  3188.         return soap_set_receiver_error(soap, "SSL error", "Can't allocate RSA struct", SOAP_SSL_ERROR);
    3189. 

  3189.     }
    3190. 

  3190. 

  3191.     BIGNUM *e = BN_new();
    3192. 

  3192.     if (!e)
    3193. 

  3193.     {
    3194. 

  3194.         RSA_free(rsa);
    3195. 

  3195.         return soap_set_receiver_error(soap, "SSL error", "Can't allocate BIGNUM", SOAP_SSL_ERROR);
    3196. 

  3196.     }
    3197. 

  3197.     if (!BN_set_word(e, RSA_F4 ))
    3198. 

  3198.     {
    3199. 

  3199.         RSA_free(rsa);
    3200. 

  3200.         BN_free(e);
    3201. 

  3201.         return soap_set_receiver_error(soap, "SSL error", "Can't set BIGNUM value", SOAP_SSL_ERROR);
    3202. 

  3202.     }
    3203. 

  3203. 

  3204. #if OPENSSL_VERSION_NUMBER > 0x00908000L
    3205. 

  3205.     if (!RSA_generate_key_ex(rsa, 1024, e, NULL))
    3206. 

  3206. #else
    3207. 

  3207.     if (( rsa = RSA_generate_key(1024, RSA_F4, NULL, NULL)) == NULL )
    3208. 

  3208. #endif
    3209. 

  3209.     {
    3210. 

  3210.         RSA_free(rsa);
    3211. 

  3211.         BN_free(e);
    3212. 

  3212.         return soap_set_receiver_error(soap, "SSL error", "Can't set RSA key", SOAP_SSL_ERROR);
    3213. 

  3213.     }
    3214. 

  3214. 

  3215. #else
    3216. 

  3216.     RSA *rsa = RSA_generate_key(1024, RSA_F4, NULL, NULL);
    3217. 

  3217. #endif
    3218. 

  3218.     if (!SSL_CTX_set_tmp_rsa(soap->ctx, rsa))
    3219. 

  3219.     { if (rsa)
    3220. 

  3220.         RSA_free(rsa);
    3221. 

  3221. /*
    3222. 

  3222.  Oracle customization for OpenSSL 0.9.8 removal of deprecated function usage: RSA_generate_key
    3223. 

  3223. */
    3224. 

  3224. #ifdef OPENSSL_NO_DEPRECATED
    3225. 

  3225.       BN_free(e);
    3226. 

  3226. #endif
    3227. 

  3227.       return soap_set_receiver_error(soap, "SSL error", "Can't set RSA key", SOAP_SSL_ERROR);
    3228. 

  3228.     }
    3229. 

  3229.     RSA_free(rsa);
    3230. 

  3230. /*
    3231. 

  3231.  Oracle customization for OpenSSL 0.9.8 removal of deprecated function usage: RSA_generate_key
    3232. 

  3232. */
    3233. 

  3233. #ifdef OPENSSL_NO_DEPRECATED
    3234. 

  3234.       BN_free(e);
    3235. 

  3235. #endif
    3236. 

  3236.   }
    3237. 

  3237.   else if (soap->dhfile)
    3238. 

  3238.   {
    3239. 

  3239.     DH *dh = 0;
    3240. 

  3240. #ifdef OPENSSL_NO_DEPRECATED
    3241. 

  3241.     DH dhrec;
    3242. 

  3242. #endif
    3243. 

  3243.     char *s;
    3244. 

  3244.     int n = (int)soap_strtoul(soap->dhfile, &s, 10);
    3245. 

  3245.     /* if dhfile is numeric, treat it as a key length to generate DH params which can take a while */
    3246. 

  3246.     if (n >= 512 && s && *s == '\0') {
    3247. 

  3247. #if !defined(OPENSSL_NO_DEPRECATED) || OPENSSL_VERSION_NUMBER < 0x00908000L
    3248. 

  3248.       dh = DH_generate_parameters(n, 2/*or 5*/, NULL, NULL);
    3249. 

  3249. #else
    3250. 

  3250.       if (DH_generate_parameters_ex(&dhrec, n, 2/*or 5*/, NULL) == 0)
    3251. 

  3251. 	  dh = &dhrec;
    3252. 

  3252.       else
    3253. 

  3253. 	  return soap_set_receiver_error(soap, "SSL error", "Can't compute DH params", SOAP_SSL_ERROR);
    3254. 

  3254. #endif
    3255. 

  3255.     }
    3256. 

  3256.     else
    3257. 

  3257.     { BIO *bio;
    3258. 

  3258.       bio = BIO_new_file(soap->dhfile, "r");
    3259. 

  3259.       if (!bio)
    3260. 

  3260.         return soap_set_receiver_error(soap, "SSL error", "Can't read DH file", SOAP_SSL_ERROR);
    3261. 

  3261.       dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
    3262. 

  3262.       BIO_free(bio);
    3263. 

  3263.     }
    3264. 

  3264.     if (!dh || DH_check(dh, &n) != 1 || SSL_CTX_set_tmp_dh(soap->ctx, dh) < 0)
    3265. 

  3265.     {
    3266. 

  3266. #ifndef OPENSSL_NO_DEPRECATED
    3267. 

  3267.       if (dh)
    3268. 

  3268.         DH_free(dh);
    3269. 

  3269. #endif
    3270. 

  3270.       return soap_set_receiver_error(soap, "SSL error", "Can't set DH parameters", SOAP_SSL_ERROR);
    3271. 

  3271.     }
    3272. 

  3272. #ifndef OPENSSL_NO_DEPRECATED
    3273. 

  3273.     DH_free(dh);
    3274. 

  3274. #endif
    3275. 

  3275.   }
    3276. 

  3276.   
    3277. 

  3277.   //
    3278. 

  3278.   // Oracle customization
    3279. 

  3279.   //
    3280. 

  3280.   // Added SSL_OP_NO_SSLv3 to force use of TLS
    3281. 

  3281.   // Added SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG to prevent forced downgrade
    3282. 

  3282.   // of security level
    3283. 

  3283. 

  3284.   flags = ((SSL_OP_ALL & ~SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG) | SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);
    3285. 

  3285. 

  3286.   flags = (SSL_OP_ALL | SSL_OP_NO_SSLv2);
    3287. 

  3287.   if ((soap->ssl_flags & SOAP_SSLv3))
    3288. 

  3288.     flags |= SSL_OP_NO_TLSv1;
    3289. 

  3289.   if ((soap->ssl_flags & SOAP_TLSv1))
    3290. 

  3290.     flags |= SSL_OP_NO_SSLv3;
    3291. 

  3291. #ifdef SSL_OP_NO_TICKET
    3292. 

  3292.   /* TLS extension is enabled by default in OPENSSL v0.9.8k
    3293. 

  3293.      Disable it by adding SSL_OP_NO_TICKET */
    3294. 

  3294.   flags |= SSL_OP_NO_TICKET;
    3295. 

  3295. #endif
    3296. 

  3296.   SSL_CTX_set_options(soap->ctx, flags);
    3297. 

  3297.   if ((soap->ssl_flags & SOAP_SSL_REQUIRE_CLIENT_AUTHENTICATION))
    3298. 

  3298.     mode = (SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT);
    3299. 

  3299.   else if ((soap->ssl_flags & SOAP_SSL_REQUIRE_SERVER_AUTHENTICATION))
    3300. 

  3300.     mode = SSL_VERIFY_PEER;
    3301. 

  3301.   else
    3302. 

  3302.     mode = SSL_VERIFY_NONE;
    3303. 

  3303.   SSL_CTX_set_verify(soap->ctx, mode, soap->fsslverify);
    3304. 

  3304. #if (OPENSSL_VERSION_NUMBER < 0x00905100L)
    3305. 

  3305.   SSL_CTX_set_verify_depth(soap->ctx, 1); 
    3306. 

  3306. #else
    3307. 

  3307.   SSL_CTX_set_verify_depth(soap->ctx, 9); 
    3308. 

  3308. #endif  
    3309. 

  3309.   return SOAP_OK;
    3310. 

  3310. }
    3311. 

  3311. #endif
    3312. 

  3312. #endif
    3313. 

  3313. 

  3314. /******************************************************************************/
    3315. 

  3315. #ifdef WITH_OPENSSL
    3316. 

  3316. #ifndef PALM_1
    3317. 

  3317. static int
    3318. 

  3318. ssl_verify_callback(int ok, X509_STORE_CTX *store)
    3319. 

  3319. {
    3320. 

  3320. #ifdef SOAP_DEBUG
    3321. 

  3321.   if (!ok) 
    3322. 

  3322.   { char data[256];
    3323. 

  3323.     X509 *cert = X509_STORE_CTX_get_current_cert(store);
    3324. 

  3324.     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(X509_STORE_CTX_get_error(store)));
    3325. 

  3325.     X509_NAME_oneline(X509_get_issuer_name(cert), data, sizeof(data));
    3326. 

  3326.     fprintf(stderr, "certificate issuer %s\n", data);
    3327. 

  3327.     X509_NAME_oneline(X509_get_subject_name(cert), data, sizeof(data));
    3328. 

  3328.     fprintf(stderr, "certificate subject %s\n", data);
    3329. 

  3329.   }
    3330. 

  3330. #endif
    3331. 

  3331.   /* Note: return 1 to continue, but unsafe progress will be terminated by SSL */
    3332. 

  3332.   return ok;
    3333. 

  3333. }
    3334. 

  3334. #endif
    3335. 

  3335. #endif
    3336. 

  3336. 

  3337. /******************************************************************************/
    3338. 

  3338. #ifdef WITH_OPENSSL
    3339. 

  3339. #ifndef PALM_1
    3340. 

  3340. static int
    3341. 

  3341. ssl_verify_callback_allow_expired_certificate(int ok, X509_STORE_CTX *store)
    3342. 

  3342. { ok = ssl_verify_callback(ok, store);
    3343. 

  3343.   if (ok == 0 && X509_STORE_CTX_get_error(store) == X509_V_ERR_CERT_HAS_EXPIRED)
    3344. 

  3344.   {
    3345. 

  3345. #ifdef SOAP_DEBUG
    3346. 

  3346.     fprintf(stderr, "ignoring certificate expiration\n");
    3347. 

  3347. #endif
    3348. 

  3348.     X509_STORE_CTX_set_error(store, X509_V_OK);
    3349. 

  3349.     ok = 1;
    3350. 

  3350.   }
    3351. 

  3351.   /* Note: return 1 to continue, but unsafe progress will be terminated by SSL */
    3352. 

  3352.   return ok;
    3353. 

  3353. }
    3354. 

  3354. #endif
    3355. 

  3355. #endif
    3356. 

  3356. 

  3357. /******************************************************************************/
    3358. 

  3358. #ifdef WITH_OPENSSL
    3359. 

  3359. #ifndef WITH_NOIO
    3360. 

  3360. #ifndef PALM_1
    3361. 

  3361. SOAP_FMAC1
    3362. 

  3362. int
    3363. 

  3363. SOAP_FMAC2
    3364. 

  3364. soap_ssl_accept(struct soap *soap)
    3365. 

  3365. { BIO *bio;
    3366. 

  3366.   int retries, r, s;
    3367. 

  3367.   if (!soap_valid_socket(soap->socket))
    3368. 

  3368.     return soap_set_receiver_error(soap, "SSL error", "No socket in soap_ssl_accept()", SOAP_SSL_ERROR);
    3369. 

  3369.   if (!soap->ctx && (soap->error = soap->fsslauth(soap)))
    3370. 

  3370.     return SOAP_SSL_ERROR;
    3371. 

  3371.   if (!soap->ssl)
    3372. 

  3372.   { soap->ssl = SSL_new(soap->ctx);
    3373. 

  3373.     if (!soap->ssl)
    3374. 

  3374.       return soap_set_receiver_error(soap, "SSL error", "SSL_new() failed in soap_ssl_accept()", SOAP_SSL_ERROR);
    3375. 

  3375.   }
    3376. 

  3376.   else
    3377. 

  3377.     SSL_clear(soap->ssl);
    3378. 

  3378.   soap->imode |= SOAP_ENC_SSL;
    3379. 

  3379.   soap->omode |= SOAP_ENC_SSL;
    3380. 

  3380.   /* Set SSL sockets to non-blocking */
    3381. 

  3381.   SOAP_SOCKNONBLOCK(soap->socket)
    3382. 

  3382.   bio = BIO_new_socket((int)soap->socket, BIO_NOCLOSE);
    3383. 

  3383.   SSL_set_bio(soap->ssl, bio, bio);
    3384. 

  3384.   retries = 100; /* SSL_accept timeout: 10 sec retries, 100 times 0.1 sec */
    3385. 

  3385. #if defined(WITH_OPENSSL) && defined(KMS_SERVER)
    3386. 

  3386.   /* Oracle customization for Ultra 2 KMS Server */
    3387. 

  3387.   if (soap->ssl_accept_timeout > 0 )
    3388. 

  3388.   {
    3389. 

  3389.       retries = 10 * soap->ssl_accept_timeout;
    3390. 

  3390.   }
    3391. 

  3391. #endif
    3392. 

  3392. 

  3393. while ((r = SSL_accept(soap->ssl)) <= 0)
    3394. 

  3394.   { int err = SSL_get_error(soap->ssl, r);
    3395. 

  3395.     if (err == SSL_ERROR_WANT_ACCEPT || err == SSL_ERROR_WANT_READ || err == SSL_ERROR_WANT_WRITE)
    3396. 

  3396.     { if (err == SSL_ERROR_WANT_READ)
    3397. 

  3397.         s = tcp_select(soap, soap->socket, SOAP_TCP_SELECT_RCV | SOAP_TCP_SELECT_ERR, -100000);
    3398. 

  3398.       else
    3399. 

  3399.         s = tcp_select(soap, soap->socket, SOAP_TCP_SELECT_SND | SOAP_TCP_SELECT_ERR, -100000);
    3400. 

  3400.       if (s < 0 && soap->errnum != SOAP_EINTR)
    3401. 

  3401.         break;
    3402. 

  3402.     }
    3403. 

  3403.     else
    3404. 

  3404.     { soap->errnum = soap_socket_errno(soap->socket);
    3405. 

  3405.       break;
    3406. 

  3406.     }
    3407. 

  3407.     if (retries-- <= 0)
    3408. 

  3408.       break;
    3409. 

  3409.   }
    3410. 

  3410.   if (r <= 0)
    3411. 

  3411.   { soap_set_receiver_error(soap, soap_ssl_error(soap, r), "SSL_accept() failed in soap_ssl_accept()", SOAP_SSL_ERROR);
    3412. 

  3412.     soap_closesock(soap);
    3413. 

  3413.     return SOAP_SSL_ERROR;
    3414. 

  3414.   }
    3415. 

  3415.   if ((soap->ssl_flags & SOAP_SSL_REQUIRE_CLIENT_AUTHENTICATION))
    3416. 

  3416.   { X509 *peer;
    3417. 

  3417.     int err;
    3418. 

  3418.     if ((err = SSL_get_verify_result(soap->ssl)) != X509_V_OK)
    3419. 

  3419.     { soap_closesock(soap);
    3420. 

  3420.       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);
    3421. 

  3421.     }
    3422. 

  3422.     peer = SSL_get_peer_certificate(soap->ssl);
    3423. 

  3423.     if (!peer)
    3424. 

  3424.     { soap_closesock(soap);
    3425. 

  3425.       return soap_set_sender_error(soap, "SSL error", "No SSL certificate was presented by the peer in soap_ssl_accept()", SOAP_SSL_ERROR);
    3426. 

  3426.     }
    3427. 

  3427.     X509_free(peer);
    3428. 

  3428.   }
    3429. 

  3429.   return SOAP_OK;
    3430. 

  3430. }
    3431. 

  3431. #endif
    3432. 

  3432. #endif
    3433. 

  3433. #endif
    3434. 

  3434. 

  3435. /******************************************************************************\
    3436. 

  3436.  *
    3437. 

  3437.  *	TCP/UDP [SSL/TLS] IPv4 and IPv6
    3438. 

  3438.  *
    3439. 

  3439. \******************************************************************************/
    3440. 

  3440. 

  3441. /******************************************************************************/
    3442. 

  3442. #ifndef WITH_NOIO
    3443. 

  3443. #ifndef PALM_1
    3444. 

  3444. static int
    3445. 

  3445. tcp_init(struct soap *soap)
    3446. 

  3446. { soap->errmode = 1;
    3447. 

  3447. #ifdef WIN32
    3448. 

  3448.   if (tcp_done)
    3449. 

  3449.     return 0;
    3450. 

  3450.   else
    3451. 

  3451.   { WSADATA w;
    3452. 

  3452.     if (WSAStartup(MAKEWORD(1, 1), &w))
    3453. 

  3453.       return -1;
    3454. 

  3454.     tcp_done = 1;
    3455. 

  3455.   }
    3456. 

  3456. #endif
    3457. 

  3457.   return 0;
    3458. 

  3458. }
    3459. 

  3459. #endif
    3460. 

  3460. #endif
    3461. 

  3461. 

  3462. /******************************************************************************/
    3463. 

  3463. #ifndef WITH_NOIO
    3464. 

  3464. #ifndef PALM_1
    3465. 

  3465. static const char*
    3466. 

  3466. tcp_error(struct soap *soap)
    3467. 

  3467. { register const char *msg = NULL;
    3468. 

  3468.   switch (soap->errmode)
    3469. 

  3469.   { case 0:
    3470. 

  3470.       msg = soap_strerror(soap);
    3471. 

  3471.       break;
    3472. 

  3472.     case 1:
    3473. 

  3473.       msg = "WSAStartup failed";
    3474. 

  3474.       break;
    3475. 

  3475.     case 2:
    3476. 

  3476.     {
    3477. 

  3477. #ifndef WITH_LEAN
    3478. 

  3478.       msg = soap_code_str(h_error_codes, soap->errnum);
    3479. 

  3479.       if (!msg)
    3480. 

  3480. #endif
    3481. 

  3481.       { sprintf(soap->msgbuf, "TCP/UDP IP error %d", soap->errnum);
    3482. 

  3482.         msg = soap->msgbuf;
    3483. 

  3483.       }
    3484. 

  3484.     }
    3485. 

  3485.   }
    3486. 

  3486.   return msg;
    3487. 

  3487. }
    3488. 

  3488. #endif
    3489. 

  3489. #endif
    3490. 

  3490. 

  3491. /******************************************************************************/
    3492. 

  3492. #ifndef WITH_IPV6
    3493. 

  3493. #ifndef WITH_NOIO
    3494. 

  3494. #ifndef PALM_1
    3495. 

  3495. static int
    3496. 

  3496. tcp_gethost(struct soap *soap, const char *addr, struct in_addr *inaddr)
    3497. 

  3497. { soap_int32 iadd = -1;
    3498. 

  3498.   struct hostent hostent, *host = &hostent;
    3499. 

  3499. #ifdef VXWORKS
    3500. 

  3500.   int hostint;
    3501. 

  3501.   /* inet_addr(), and hostGetByName() expect "char *"; addr is a "const char *". */
    3502. 

  3502.   iadd = inet_addr((char*)addr);
    3503. 

  3503. #else
    3504. 

  3504. #if defined(_AIX43) || ((defined(TRU64) || defined(HP_UX)) && defined(HAVE_GETHOSTBYNAME_R))
    3505. 

  3505.   struct hostent_data ht_data;
    3506. 

  3506. #endif
    3507. 

  3507. #ifdef AS400
    3508. 

  3508.   iadd = inet_addr((void*)addr);
    3509. 

  3509. #else
    3510. 

  3510.   iadd = inet_addr(addr);
    3511. 

  3511. #endif
    3512. 

  3512. #endif
    3513. 

  3513.   if (iadd != -1)
    3514. 

  3514.   { memcpy(inaddr, &iadd, sizeof(iadd));
    3515. 

  3515.     return SOAP_OK;
    3516. 

  3516.   }
    3517. 

  3517. #if defined(__GLIBC__) || (defined(HAVE_GETHOSTBYNAME_R) && (defined(FREEBSD) || defined(__FreeBSD__)))
    3518. 

  3518.   if (gethostbyname_r(addr, &hostent, soap->buf, SOAP_BUFLEN, &host, &soap->errnum) < 0)
    3519. 

  3519.     host = NULL;
    3520. 

  3520. #elif defined(_AIX43) || ((defined(TRU64) || defined(HP_UX)) && defined(HAVE_GETHOSTBYNAME_R))
    3521. 

  3521.   memset((void*)&ht_data, 0, sizeof(ht_data));
    3522. 

  3522.   if (gethostbyname_r(addr, &hostent, &ht_data) < 0)
    3523. 

  3523.   { host = NULL;
    3524. 

  3524.     soap->errnum = h_errno;
    3525. 

  3525.   }
    3526. 

  3526. #elif defined(HAVE_GETHOSTBYNAME_R)
    3527. 

  3527.   host = gethostbyname_r(addr, &hostent, soap->buf, SOAP_BUFLEN, &soap->errnum);
    3528. 

  3528. #elif defined(VXWORKS)
    3529. 

  3529.   /* If the DNS resolver library resolvLib has been configured in the vxWorks
    3530. 

  3530.    * image, a query for the host IP address is sent to the DNS server, if the
    3531. 

  3531.    * name was not found in the local host table. */
    3532. 

  3532.   hostint = hostGetByName((char*)addr);
    3533. 

  3533.   if (hostint == ERROR)
    3534. 

  3534.   { host = NULL;
    3535. 

  3535.     soap->errnum = soap_errno; 
    3536. 

  3536.   }
    3537. 

  3537. #else
    3538. 

  3538. #ifdef AS400
    3539. 

  3539.   if (!(host = gethostbyname((void*)addr)))
    3540. 

  3540.     soap->errnum = h_errno;
    3541. 

  3541. #else
    3542. 

  3542.   if (!(host = gethostbyname(addr)))
    3543. 

  3543.     soap->errnum = h_errno;
    3544. 

  3544. #endif
    3545. 

  3545. #endif
    3546. 

  3546.   if (!host)
    3547. 

  3547.   { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Host name not found\n"));
    3548. 

  3548.     return SOAP_ERR;
    3549. 

  3549.   }
    3550. 

  3550. #ifdef VXWORKS
    3551. 

  3551.   inaddr->s_addr = hostint;
    3552. 

  3552. #else
    3553. 

  3553.   memcpy(inaddr, host->h_addr, host->h_length);
    3554. 

  3554. #endif
    3555. 

  3555.   return SOAP_OK;
    3556. 

  3556. }
    3557. 

  3557. #endif
    3558. 

  3558. #endif
    3559. 

  3559. #endif
    3560. 

  3560. 

  3561. /******************************************************************************/
    3562. 

  3562. #ifndef WITH_NOIO
    3563. 

  3563. #ifndef PALM_1
    3564. 

  3564. static SOAP_SOCKET
    3565. 

  3565. tcp_connect(struct soap *soap, const char *endpoint, const char *host, int port)
    3566. 

  3566. {
    3567. 

  3567. #ifdef WITH_IPV6
    3568. 

  3568.   struct addrinfo hints, *res, *ressave;
    3569. 

  3569. #endif
    3570. 

  3570.   SOAP_SOCKET fd;
    3571. 

  3571.   int err = 0;
    3572. 

  3572. #ifndef WITH_LEAN
    3573. 

  3573.   int len = SOAP_BUFLEN;
    3574. 

  3574.   int set = 1;
    3575. 

  3575. #endif
    3576. 

  3576. #if !defined(WITH_LEAN) || defined(WITH_OPENSSL)
    3577. 

  3577.   int retries;
    3578. 

  3578. #endif
    3579. 

  3579.   if (soap_valid_socket(soap->socket))
    3580. 

  3580.     soap->fclosesocket(soap, soap->socket);
    3581. 

  3581.   soap->socket = SOAP_INVALID_SOCKET;
    3582. 

  3582.   if (tcp_init(soap))
    3583. 

  3583.   { soap->errnum = 0;
    3584. 

  3584.     soap_set_sender_error(soap, tcp_error(soap), "TCP init failed in tcp_connect()", SOAP_TCP_ERROR);
    3585. 

  3585.     return SOAP_INVALID_SOCKET;
    3586. 

  3586.   }
    3587. 

  3587.   soap->errmode = 0;
    3588. 

  3588. #ifdef WITH_IPV6
    3589. 

  3589.   memset((void*)&hints, 0, sizeof(hints));
    3590. 

  3590.   hints.ai_family = PF_UNSPEC;
    3591. 

  3591. #ifndef WITH_LEAN
    3592. 

  3592.   if ((soap->omode & SOAP_IO_UDP))
    3593. 

  3593.     hints.ai_socktype = SOCK_DGRAM;
    3594. 

  3594.   else
    3595. 

  3595. #endif
    3596. 

  3596.     hints.ai_socktype = SOCK_STREAM;
    3597. 

  3597.   soap->errmode = 2;
    3598. 

  3598.   res = NULL;
    3599. 

  3599.   if (soap->proxy_host)
    3600. 

  3600.     err = getaddrinfo(soap->proxy_host, soap_int2s(soap, soap->proxy_port), &hints, &res);
    3601. 

  3601.   else
    3602. 

  3602.     err = getaddrinfo(host, soap_int2s(soap, port), &hints, &res);
    3603. 

  3603.   /* Oracle customization: check err before using res */
    3604. 

  3604.   if (err || (res==NULL))
    3605. 

  3605.   { soap_set_sender_error(soap, SOAP_GAI_STRERROR(err), "getaddrinfo failed in tcp_connect()", SOAP_TCP_ERROR);
    3606. 

  3606.     if (res)
    3607. 

  3607.     {
    3608. 

  3608.       freeaddrinfo(res);
    3609. 

  3609.     }
    3610. 

  3610.     return SOAP_INVALID_SOCKET;
    3611. 

  3611.   }
    3612. 

  3612.   ressave = res;
    3613. 

  3613. again:
    3614. 

  3614.   fd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
    3615. 

  3615.   soap->errmode = 0;
    3616. 

  3616. #else
    3617. 

  3617. #ifndef WITH_LEAN
    3618. 

  3618. again:
    3619. 

  3619. #endif
    3620. 

  3620. #ifndef WITH_LEAN
    3621. 

  3621.   if ((soap->omode & SOAP_IO_UDP))
    3622. 

  3622.     fd = socket(AF_INET, SOCK_DGRAM, 0);
    3623. 

  3623.   else
    3624. 

  3624. #endif
    3625. 

  3625.     fd = socket(AF_INET, SOCK_STREAM, 0);
    3626. 

  3626. #endif
    3627. 

  3627.   if (!soap_valid_socket(fd))
    3628. 

  3628.   {
    3629. 

  3629. #ifdef WITH_IPV6
    3630. 

  3630.     if (res->ai_next)
    3631. 

  3631.     { res = res->ai_next;
    3632. 

  3632.       goto again;
    3633. 

  3633.     }
    3634. 

  3634. #endif
    3635. 

  3635.     soap->errnum = soap_socket_errno(fd);
    3636. 

  3636.     soap_set_sender_error(soap, tcp_error(soap), "socket failed in tcp_connect()", SOAP_TCP_ERROR);
    3637. 

  3637. #ifdef WITH_IPV6
    3638. 

  3638.     freeaddrinfo(ressave);
    3639. 

  3639. #endif
    3640. 

  3640.     return SOAP_INVALID_SOCKET;
    3641. 

  3641.   }
    3642. 

  3642. #ifdef SOCKET_CLOSE_ON_EXEC
    3643. 

  3643. #ifdef WIN32
    3644. 

  3644. #ifndef UNDER_CE
    3645. 

  3645.   SetHandleInformation((HANDLE)fd, HANDLE_FLAG_INHERIT, 0);
    3646. 

  3646. #endif
    3647. 

  3647. #else
    3648. 

  3648.   fcntl(fd, F_SETFD, 1);
    3649. 

  3649. #endif
    3650. 

  3650. #endif
    3651. 

  3651. #ifndef WITH_LEAN
    3652. 

  3652.   if (soap->connect_flags == SO_LINGER)
    3653. 

  3653.   { struct linger linger;
    3654. 

  3654.     memset((void*)&linger, 0, sizeof(linger));
    3655. 

  3655.     linger.l_onoff = 1;
    3656. 

  3656.     linger.l_linger = soap->linger_time;
    3657. 

  3657.     if (setsockopt(fd, SOL_SOCKET, SO_LINGER, (char*)&linger, sizeof(struct linger)))
    3658. 

  3658.     { soap->errnum = soap_socket_errno(fd);
    3659. 

  3659.       soap_set_sender_error(soap, tcp_error(soap), "setsockopt SO_LINGER failed in tcp_connect()", SOAP_TCP_ERROR);
    3660. 

  3660.       soap->fclosesocket(soap, fd);
    3661. 

  3661. #ifdef WITH_IPV6
    3662. 

  3662.       freeaddrinfo(ressave);
    3663. 

  3663. #endif
    3664. 

  3664.       return SOAP_INVALID_SOCKET;
    3665. 

  3665.     }
    3666. 

  3666.   }
    3667. 

  3667.   else if (soap->connect_flags && setsockopt(fd, SOL_SOCKET, soap->connect_flags, (char*)&set, sizeof(int)))
    3668. 

  3668.   { soap->errnum = soap_socket_errno(fd);
    3669. 

  3669.     soap_set_sender_error(soap, tcp_error(soap), "setsockopt failed in tcp_connect()", SOAP_TCP_ERROR);
    3670. 

  3670.     soap->fclosesocket(soap, fd);
    3671. 

  3671. #ifdef WITH_IPV6
    3672. 

  3672.     freeaddrinfo(ressave);
    3673. 

  3673. #endif
    3674. 

  3674.     return SOAP_INVALID_SOCKET;
    3675. 

  3675.   }
    3676. 

  3676.   if ((soap->keep_alive || soap->tcp_keep_alive) && setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (char*)&set, sizeof(int)))
    3677. 

  3677.   { soap->errnum = soap_socket_errno(fd);
    3678. 

  3678.     soap_set_sender_error(soap, tcp_error(soap), "setsockopt SO_KEEPALIVE failed in tcp_connect()", SOAP_TCP_ERROR);
    3679. 

  3679.     soap->fclosesocket(soap, fd);
    3680. 

  3680. #ifdef WITH_IPV6
    3681. 

  3681.     freeaddrinfo(ressave);
    3682. 

  3682. #endif
    3683. 

  3683.     return SOAP_INVALID_SOCKET;
    3684. 

  3684.   }
    3685. 

  3685.   if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (char*)&len, sizeof(int)))
    3686. 

  3686.   { soap->errnum = soap_socket_errno(fd);
    3687. 

  3687.     soap_set_sender_error(soap, tcp_error(soap), "setsockopt SO_SNDBUF failed in tcp_connect()", SOAP_TCP_ERROR);
    3688. 

  3688.     soap->fclosesocket(soap, fd);
    3689. 

  3689. #ifdef WITH_IPV6
    3690. 

  3690.     freeaddrinfo(ressave);
    3691. 

  3691. #endif
    3692. 

  3692.     return SOAP_INVALID_SOCKET;
    3693. 

  3693.   }
    3694. 

  3694.   if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, (char*)&len, sizeof(int)))
    3695. 

  3695.   { soap->errnum = soap_socket_errno(fd);
    3696. 

  3696.     soap_set_sender_error(soap, tcp_error(soap), "setsockopt SO_RCVBUF failed in tcp_connect()", SOAP_TCP_ERROR);
    3697. 

  3697.     soap->fclosesocket(soap, fd);
    3698. 

  3698. #ifdef WITH_IPV6
    3699. 

  3699.     freeaddrinfo(ressave);
    3700. 

  3700. #endif
    3701. 

  3701.     return SOAP_INVALID_SOCKET;
    3702. 

  3702.   }
    3703. 

  3703. #ifdef TCP_KEEPIDLE
    3704. 

  3704.   if (soap->tcp_keep_idle && setsockopt((SOAP_SOCKET)fd, IPPROTO_TCP, TCP_KEEPIDLE, (char*)&(soap->tcp_keep_idle), sizeof(int)))
    3705. 

  3705.   { soap->errnum = soap_socket_errno(fd);
    3706. 

  3706.     soap_set_sender_error(soap, tcp_error(soap), "setsockopt TCP_KEEPIDLE failed in tcp_connect()", SOAP_TCP_ERROR);
    3707. 

  3707.     soap->fclosesocket(soap, (SOAP_SOCKET)fd);
    3708. 

  3708. #ifdef WITH_IPV6
    3709. 

  3709.     freeaddrinfo(ressave);
    3710. 

  3710. #endif
    3711. 

  3711.     return SOAP_INVALID_SOCKET;
    3712. 

  3712.   }
    3713. 

  3713. #endif
    3714. 

  3714. #ifdef TCP_KEEPINTVL
    3715. 

  3715.   if (soap->tcp_keep_intvl && setsockopt((SOAP_SOCKET)fd, IPPROTO_TCP, TCP_KEEPINTVL, (char*)&(soap->tcp_keep_intvl), sizeof(int)))
    3716. 

  3716.   { soap->errnum = soap_socket_errno(fd);
    3717. 

  3717.     soap_set_sender_error(soap, tcp_error(soap), "setsockopt TCP_KEEPINTVL failed in tcp_connect()", SOAP_TCP_ERROR);
    3718. 

  3718.     soap->fclosesocket(soap, (SOAP_SOCKET)fd);
    3719. 

  3719. #ifdef WITH_IPV6
    3720. 

  3720.     freeaddrinfo(ressave);
    3721. 

  3721. #endif
    3722. 

  3722.     return SOAP_INVALID_SOCKET;
    3723. 

  3723.   }
    3724. 

  3724. #endif
    3725. 

  3725. #ifdef TCP_KEEPCNT
    3726. 

  3726.   if (soap->tcp_keep_cnt && setsockopt((SOAP_SOCKET)fd, IPPROTO_TCP, TCP_KEEPCNT, (char*)&(soap->tcp_keep_cnt), sizeof(int)))
    3727. 

  3727.   { soap->errnum = soap_socket_errno(fd);
    3728. 

  3728.     soap_set_sender_error(soap, tcp_error(soap), "setsockopt TCP_KEEPCNT failed in tcp_connect()", SOAP_TCP_ERROR);
    3729. 

  3729.     soap->fclosesocket(soap, (SOAP_SOCKET)fd);
    3730. 

  3730. #ifdef WITH_IPV6
    3731. 

  3731.     freeaddrinfo(ressave);
    3732. 

  3732. #endif
    3733. 

  3733.     return SOAP_INVALID_SOCKET;
    3734. 

  3734.   }
    3735. 

  3735. #endif
    3736. 

  3736. #ifdef TCP_NODELAY
    3737. 

  3737.   if (!(soap->omode & SOAP_IO_UDP) && setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char*)&set, sizeof(int)))
    3738. 

  3738.   { soap->errnum = soap_socket_errno(fd);
    3739. 

  3739.     soap_set_sender_error(soap, tcp_error(soap), "setsockopt TCP_NODELAY failed in tcp_connect()", SOAP_TCP_ERROR);
    3740. 

  3740.     soap->fclosesocket(soap, fd);
    3741. 

  3741. #ifdef WITH_IPV6
    3742. 

  3742.     freeaddrinfo(ressave);
    3743. 

  3743. #endif
    3744. 

  3744.     return SOAP_INVALID_SOCKET;
    3745. 

  3745.   }
    3746. 

  3746. #endif
    3747. 

  3747. #ifdef WITH_IPV6
    3748. 

  3748.   if ((soap->omode & SOAP_IO_UDP) && soap->ipv6_multicast_if)
    3749. 

  3749.   { struct sockaddr_in6 *in6addr = (struct sockaddr_in6*)res->ai_addr;
    3750. 

  3750.     in6addr->sin6_scope_id = soap->ipv6_multicast_if;
    3751. 

  3751.   }
    3752. 

  3752. #endif
    3753. 

  3753. #ifdef IP_MULTICAST_TTL
    3754. 

  3754.   if ((soap->omode & SOAP_IO_UDP) && soap->ipv4_multicast_if && !soap->ipv6_multicast_if)
    3755. 

  3755.   { if (soap->ipv4_multicast_ttl > 0)
    3756. 

  3756.     { char ttl = (char)(soap->ipv4_multicast_ttl);
    3757. 

  3757.       if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_TTL, (char*)&ttl, sizeof(ttl)))
    3758. 

  3758.       { soap->errnum = soap_socket_errno(fd);
    3759. 

  3759.         soap_set_sender_error(soap, tcp_error(soap), "setsockopt IP_MULTICAST_TTL failed in tcp_connect()", SOAP_TCP_ERROR);
    3760. 

  3760.         soap->fclosesocket(soap, fd);
    3761. 

  3761.         return SOAP_INVALID_SOCKET;
    3762. 

  3762.       }
    3763. 

  3763.     }
    3764. 

  3764. #ifndef WINDOWS
    3765. 

  3765.     if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF, (char*)soap->ipv4_multicast_if, sizeof(struct in_addr))) 
    3766. 

  3766.     { soap->errnum = soap_socket_errno(fd);
    3767. 

  3767.       soap_set_sender_error(soap, tcp_error(soap), "setsockopt IP_MULTICAST_IF failed in tcp_connect()", SOAP_TCP_ERROR);
    3768. 

  3768.       soap->fclosesocket(soap, fd);
    3769. 

  3769.       return SOAP_INVALID_SOCKET;
    3770. 

  3770.     }
    3771. 

  3771. #else
    3772. 

  3772. #ifndef IP_MULTICAST_IF
    3773. 

  3773. #define IP_MULTICAST_IF 2
    3774. 

  3774. #endif
    3775. 

  3775.     if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF, (char*)soap->ipv4_multicast_if, sizeof(struct in_addr))) 
    3776. 

  3776.     { soap->errnum = soap_socket_errno(fd);
    3777. 

  3777.       soap_set_sender_error(soap, tcp_error(soap), "setsockopt IP_MULTICAST_IF failed in tcp_connect()", SOAP_TCP_ERROR);
    3778. 

  3778.       soap->fclosesocket(soap, fd);
    3779. 

  3779.       return SOAP_INVALID_SOCKET;
    3780. 

  3780.     }
    3781. 

  3781. #endif
    3782. 

  3782.   }
    3783. 

  3783. #endif
    3784. 

  3784. #endif
    3785. 

  3785.   DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Opening socket %d to host='%s' port=%d\n", fd, host, port));
    3786. 

  3786. #ifndef WITH_IPV6
    3787. 

  3787.   soap->peerlen = sizeof(soap->peer);
    3788. 

  3788.   memset((void*)&soap->peer, 0, sizeof(soap->peer));
    3789. 

  3789.   soap->peer.sin_family = AF_INET;
    3790. 

  3790.   soap->errmode = 2;
    3791. 

  3791.   if (soap->proxy_host)
    3792. 

  3792.   { if (soap->fresolve(soap, soap->proxy_host, &soap->peer.sin_addr))
    3793. 

  3793.     { soap_set_sender_error(soap, tcp_error(soap), "get proxy host by name failed in tcp_connect()", SOAP_TCP_ERROR);
    3794. 

  3794.       soap->fclosesocket(soap, fd);
    3795. 

  3795.       return SOAP_INVALID_SOCKET;
    3796. 

  3796.     }
    3797. 

  3797.     soap->peer.sin_port = htons((short)soap->proxy_port);
    3798. 

  3798.   }
    3799. 

  3799.   else
    3800. 

  3800.   { if (soap->fresolve(soap, host, &soap->peer.sin_addr))
    3801. 

  3801.     { soap_set_sender_error(soap, tcp_error(soap), "get host by name failed in tcp_connect()", SOAP_TCP_ERROR);
    3802. 

  3802.       soap->fclosesocket(soap, fd);
    3803. 

  3803.       return SOAP_INVALID_SOCKET;
    3804. 

  3804.     }
    3805. 

  3805.     soap->peer.sin_port = htons((short)port);
    3806. 

  3806.   }
    3807. 

  3807.   soap->errmode = 0;
    3808. 

  3808. #ifndef WITH_LEAN
    3809. 

  3809.   if ((soap->omode & SOAP_IO_UDP))
    3810. 

  3810.     return fd;
    3811. 

  3811. #endif
    3812. 

  3812. #else
    3813. 

  3813.   if ((soap->omode & SOAP_IO_UDP))
    3814. 

  3814.   { memcpy(&soap->peer, res->ai_addr, res->ai_addrlen);
    3815. 

  3815.     soap->peerlen = res->ai_addrlen;
    3816. 

  3816.     freeaddrinfo(ressave);
    3817. 

  3817.     return fd;
    3818. 

  3818.   }
    3819. 

  3819. #endif
    3820. 

  3820. #ifndef WITH_LEAN
    3821. 

  3821.   if (soap->connect_timeout)
    3822. 

  3822.     SOAP_SOCKNONBLOCK(fd)
    3823. 

  3823.   else
    3824. 

  3824.     SOAP_SOCKBLOCK(fd)
    3825. 

  3825.   retries = 10;
    3826. 

  3826. #endif
    3827. 

  3827.   for (;;)
    3828. 

  3828.   { 
    3829. 

  3829. #ifdef WITH_IPV6
    3830. 

  3830.     if (connect(fd, res->ai_addr, (int)res->ai_addrlen))
    3831. 

  3831. #else
    3832. 

  3832.     if (connect(fd, (struct sockaddr*)&soap->peer, sizeof(soap->peer)))
    3833. 

  3833. #endif
    3834. 

  3834.     { err = soap_socket_errno(fd);
    3835. 

  3835. #ifndef WITH_LEAN
    3836. 

  3836.       if (err == SOAP_EADDRINUSE)
    3837. 

  3837.       { soap->fclosesocket(soap, fd);
    3838. 

  3838.         if (retries-- > 0)
    3839. 

  3839.           goto again;
    3840. 

  3840.       }
    3841. 

  3841.       else if (soap->connect_timeout && (err == SOAP_EINPROGRESS || err == SOAP_EAGAIN || err == SOAP_EWOULDBLOCK))
    3842. 

  3842.       {
    3843. 

  3843.         SOAP_SOCKLEN_T k;
    3844. 

  3844.         for (;;)
    3845. 

  3845.         { register int r;
    3846. 

  3846.           r = tcp_select(soap, fd, SOAP_TCP_SELECT_SND, soap->connect_timeout);
    3847. 

  3847.           if (r > 0)
    3848. 

  3848.             break;
    3849. 

  3849.           if (!r)
    3850. 

  3850.           { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Connect timeout\n"));
    3851. 

  3851.             soap_set_sender_error(soap, "Timeout", "connect failed in tcp_connect()", SOAP_TCP_ERROR);
    3852. 

  3852.             soap->fclosesocket(soap, fd);
    3853. 

  3853.             soap->socket = SOAP_INVALID_SOCKET;      /* Oracle customization */
    3854. 

  3854. #ifdef WITH_IPV6
    3855. 

  3855.             freeaddrinfo(ressave);
    3856. 

  3856. #endif
    3857. 

  3857.             return SOAP_INVALID_SOCKET;
    3858. 

  3858.           }
    3859. 

  3859.     	  r = soap->errnum;
    3860. 

  3860.           if (r != SOAP_EINTR)
    3861. 

  3861.           { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not connect to host\n"));
    3862. 

  3862.             soap_set_sender_error(soap, tcp_error(soap), "connect failed in tcp_connect()", SOAP_TCP_ERROR);
    3863. 

  3863.             soap->fclosesocket(soap, fd);
    3864. 

  3864.             soap->socket = SOAP_INVALID_SOCKET;      /* Oracle customization */
    3865. 

  3865. #ifdef WITH_IPV6
    3866. 

  3866.             freeaddrinfo(ressave);
    3867. 

  3867. #endif
    3868. 

  3868.             return SOAP_INVALID_SOCKET;
    3869. 

  3869.           }
    3870. 

  3870.         }
    3871. 

  3871.         k = (SOAP_SOCKLEN_T)sizeof(soap->errnum);
    3872. 

  3872.         if (!getsockopt(fd, SOL_SOCKET, SO_ERROR, (char*)&soap->errnum, &k) && !soap->errnum)	/* portability note: see SOAP_SOCKLEN_T definition in stdsoap2.h */
    3873. 

  3873.           break;
    3874. 

  3874.         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not connect to host\n"));
    3875. 

  3875.         if (!soap->errnum)
    3876. 

  3876.           soap->errnum = soap_socket_errno(fd);
    3877. 

  3877.         soap_set_sender_error(soap, tcp_error(soap), "connect failed in tcp_connect()", SOAP_TCP_ERROR);
    3878. 

  3878.         soap->fclosesocket(soap, fd);
    3879. 

  3879. #ifdef WITH_IPV6
    3880. 

  3880.         freeaddrinfo(ressave);
    3881. 

  3881. #endif
    3882. 

  3882.         return SOAP_INVALID_SOCKET;
    3883. 

  3883.       }
    3884. 

  3884. #endif
    3885. 

  3885. #ifdef WITH_IPV6
    3886. 

  3886.       if (res->ai_next)
    3887. 

  3887.       { res = res->ai_next;
    3888. 

  3888.         soap->fclosesocket(soap, fd);
    3889. 

  3889.         goto again;
    3890. 

  3890.       }
    3891. 

  3891. #endif
    3892. 

  3892.       if (err && err != SOAP_EINTR)
    3893. 

  3893.       { soap->errnum = err;
    3894. 

  3894.         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not connect to host\n"));
    3895. 

  3895.         soap_set_sender_error(soap, tcp_error(soap), "connect failed in tcp_connect()", SOAP_TCP_ERROR);
    3896. 

  3896.         soap->fclosesocket(soap, fd);
    3897. 

  3897. #ifdef WITH_IPV6
    3898. 

  3898.         freeaddrinfo(ressave);
    3899. 

  3899. #endif
    3900. 

  3900.         return SOAP_INVALID_SOCKET;
    3901. 

  3901.       }
    3902. 

  3902.     }  
    3903. 

  3903.     else
    3904. 

  3904.       break;
    3905. 

  3905.   }
    3906. 

  3906. #ifdef WITH_IPV6
    3907. 

  3907.   soap->peerlen = 0; /* IPv6: already connected so use send() */
    3908. 

  3908.   freeaddrinfo(ressave);
    3909. 

  3909. #endif
    3910. 

  3910.   if (soap->recv_timeout || soap->send_timeout)
    3911. 

  3911.     SOAP_SOCKNONBLOCK(fd)
    3912. 

  3912.   else
    3913. 

  3913.     SOAP_SOCKBLOCK(fd)
    3914. 

  3914.   soap->socket = fd;
    3915. 

  3915.   soap->imode &= ~SOAP_ENC_SSL;
    3916. 

  3916.   soap->omode &= ~SOAP_ENC_SSL;
    3917. 

  3917.   if (!soap_tag_cmp(endpoint, "https:*"))
    3918. 

  3918.   {
    3919. 

  3919. #ifdef WITH_OPENSSL
    3920. 

  3920.     BIO *bio;
    3921. 

  3921.     int r;
    3922. 

  3922.     if (soap->proxy_host)
    3923. 

  3923.     { soap_mode m = soap->mode; /* preserve settings */
    3924. 

  3924.       soap_mode om = soap->omode; /* make sure we only parse HTTP */
    3925. 

  3925.       size_t n = soap->count; /* save the content length */
    3926. 

  3926.       const char *userid, *passwd;
    3927. 

  3927.       soap->omode &= ~SOAP_ENC; /* mask IO and ENC */
    3928. 

  3928.       soap->omode |= SOAP_IO_BUFFER;
    3929. 

  3929.       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Connecting to %s proxy server\n", soap->proxy_http_version));
    3930. 

  3930.       sprintf(soap->tmpbuf, "CONNECT %s:%d HTTP/%s", host, port, soap->proxy_http_version);
    3931. 

  3931.       if (soap_begin_send(soap)
    3932. 

  3932.        || (soap->error = soap->fposthdr(soap, soap->tmpbuf, NULL)))
    3933. 

  3933.       { soap->fclosesocket(soap, fd);
    3934. 

  3934.         soap->socket = SOAP_INVALID_SOCKET;      /* Oracle customization */
    3935. 

  3935.         return SOAP_INVALID_SOCKET;
    3936. 

  3936.       }
    3937. 

  3937. #ifndef WITH_LEAN
    3938. 

  3938.       if (soap->proxy_userid && soap->proxy_passwd && strlen(soap->proxy_userid) + strlen(soap->proxy_passwd) < 761)
    3939. 

  3939.       { sprintf(soap->tmpbuf + 262, "%s:%s", soap->proxy_userid, soap->proxy_passwd);
    3940. 

  3940.         strcpy(soap->tmpbuf, "Basic ");
    3941. 

  3941.         soap_s2base64(soap, (const unsigned char*)(soap->tmpbuf + 262), soap->tmpbuf + 6, (int)strlen(soap->tmpbuf + 262));
    3942. 

  3942.         if ((soap->error = soap->fposthdr(soap, "Proxy-Authorization", soap->tmpbuf)))
    3943. 

  3943.         { soap->fclosesocket(soap, fd);
    3944. 

  3944.           soap->socket = SOAP_INVALID_SOCKET;      /* Oracle customization */
    3945. 

  3945.           //
    3946. 

  3946.           // Oracle customization
    3947. 

  3947.           // TODO: returning soap->error may also be a bug
    3948. 

  3948.           //
    3949. 

  3949.           return soap->error;
    3950. 

  3950.         }
    3951. 

  3951.       }
    3952. 

  3952. #endif
    3953. 

  3953.       if ((soap->error = soap->fposthdr(soap, NULL, NULL))
    3954. 

  3954.        || soap_flush(soap))
    3955. 

  3955.       { soap->fclosesocket(soap, fd);
    3956. 

  3956.         soap->socket = SOAP_INVALID_SOCKET;      /* Oracle customization */
    3957. 

  3957.         return SOAP_INVALID_SOCKET;
    3958. 

  3958.       }
    3959. 

  3959.       soap->omode = om;
    3960. 

  3960.       om = soap->imode;
    3961. 

  3961.       soap->imode &= ~SOAP_ENC; /* mask IO and ENC */
    3962. 

  3962.       userid = soap->userid; /* preserve */
    3963. 

  3963.       passwd = soap->passwd; /* preserve */
    3964. 

  3964.       if ((soap->error = soap->fparse(soap)))
    3965. 

  3965.       { soap->fclosesocket(soap, fd);
    3966. 

  3966.         soap->socket = SOAP_INVALID_SOCKET;      /* Oracle customization */
    3967. 

  3967.         return SOAP_INVALID_SOCKET;
    3968. 

  3968.       }
    3969. 

  3969.       soap->userid = userid; /* restore */
    3970. 

  3970.       soap->passwd = passwd; /* restore */
    3971. 

  3971.       soap->imode = om; /* restore */
    3972. 

  3972.       soap->count = n; /* restore */
    3973. 

  3973.       if (soap_begin_send(soap))
    3974. 

  3974.       { soap->fclosesocket(soap, fd);
    3975. 

  3975.         return SOAP_INVALID_SOCKET;
    3976. 

  3976.       }
    3977. 

  3977.       if (endpoint)
    3978. 

  3978.         strncpy(soap->endpoint, endpoint, sizeof(soap->endpoint)-1); /* restore */
    3979. 

  3979.       soap->mode = m;
    3980. 

  3980.     }
    3981. 

  3981.     if (!soap->ctx && (soap->error = soap->fsslauth(soap)))
    3982. 

  3982.     { soap_set_sender_error(soap, "SSL error", "SSL authentication failed in tcp_connect(): check password, key file, and ca file.", SOAP_SSL_ERROR);
    3983. 

  3983.       soap->fclosesocket(soap, fd);
    3984. 

  3984.       soap->socket = SOAP_INVALID_SOCKET;      /* Oracle customization */
    3985. 

  3985.       return SOAP_INVALID_SOCKET;
    3986. 

  3986.     }
    3987. 

  3987.     if (!soap->ssl)
    3988. 

  3988.     { soap->ssl = SSL_new(soap->ctx);
    3989. 

  3989.       if (!soap->ssl)
    3990. 

  3990.       { soap->fclosesocket(soap, fd);
    3991. 

  3991.         soap->socket = SOAP_INVALID_SOCKET;      /* Oracle customization */
    3992. 

  3992.         soap->error = SOAP_SSL_ERROR;
    3993. 

  3993.         return SOAP_INVALID_SOCKET;
    3994. 

  3994.       }
    3995. 

  3995.     }
    3996. 

  3996.     else
    3997. 

  3997.       SSL_clear(soap->ssl);
    3998. 

  3998.     if (soap->session)
    3999. 

  3999.     { if (!strcmp(soap->session_host, host) && soap->session_port == port)
    4000. 

  4000.         SSL_set_session(soap->ssl, soap->session);
    4001. 

  4001.       SSL_SESSION_free(soap->session);
    4002. 

  4002.       soap->session = NULL;
    4003. 

  4003.     }
    4004. 

  4004.     soap->imode |= SOAP_ENC_SSL;
    4005. 

  4005.     soap->omode |= SOAP_ENC_SSL;
    4006. 

  4006.     bio = BIO_new_socket((int)fd, BIO_NOCLOSE);
    4007. 

  4007.     SSL_set_bio(soap->ssl, bio, bio);
    4008. 

  4008.     retries = 0;
    4009. 

  4009. #ifndef WITH_LEAN
    4010. 

  4010.     /* Connect timeout: set SSL sockets to non-blocking */
    4011. 

  4011.     if (soap->connect_timeout)
    4012. 

  4012.     { SOAP_SOCKNONBLOCK(fd)
    4013. 

  4013.       retries = 10*soap->connect_timeout;
    4014. 

  4014.     }
    4015. 

  4015.     else
    4016. 

  4016.       SOAP_SOCKBLOCK(fd)
    4017. 

  4017. #endif
    4018. 

  4018.     //
    4019. 

  4019.     // Oracle customization
    4020. 

  4020.     //
    4021. 

  4021.     // Clear error queue of any errors remaining from a previous operation
    4022. 

  4022.     ERR_clear_error();
    4023. 

  4023.     
    4024. 

  4024.     if (retries <= 0)
    4025. 

  4025.       retries = 100; /* SSL connect timeout: 10 sec retries, 100 x 0.1 sec */
    4026. 

  4026.     /* Try connecting until success or timeout (when nonblocking) */
    4027. 

  4027.     do
    4028. 

  4028.     { if ((r = SSL_connect(soap->ssl)) <= 0)
    4029. 

  4029.       { int err = SSL_get_error(soap->ssl, r);
    4030. 

  4030.         if (err == SSL_ERROR_WANT_CONNECT || err == SSL_ERROR_WANT_READ || err == SSL_ERROR_WANT_WRITE)
    4031. 

  4031.         { register int s;
    4032. 

  4032. 	  if (err == SSL_ERROR_WANT_READ)
    4033. 

  4033.             s = tcp_select(soap, soap->socket, SOAP_TCP_SELECT_RCV | SOAP_TCP_SELECT_ERR, -100000);
    4034. 

  4034.           else
    4035. 

  4035.             s = tcp_select(soap, soap->socket, SOAP_TCP_SELECT_SND | SOAP_TCP_SELECT_ERR, -100000);
    4036. 

  4036.           if (s < 0 && soap->errnum != SOAP_EINTR)
    4037. 

  4037.           { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "SSL_connect/select error in tcp_connect\n"));
    4038. 

  4038.             soap_set_sender_error(soap, soap_ssl_error(soap, r), "SSL_connect failed in tcp_connect()", SOAP_TCP_ERROR);
    4039. 

  4039.             soap->fclosesocket(soap, fd);
    4040. 

  4040.             soap->socket = SOAP_INVALID_SOCKET;      /* Oracle customization */
    4041. 

  4041.             return SOAP_INVALID_SOCKET;
    4042. 

  4042.           }
    4043. 

  4043. 	  if (s == 0 && retries-- <= 0)
    4044. 

  4044.           { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "SSL connect timeout\n"));
    4045. 

  4045.             soap_set_sender_error(soap, "Timeout", "SSL connect failed in tcp_connect()", SOAP_TCP_ERROR);
    4046. 

  4046.             soap->fclosesocket(soap, fd);
    4047. 

  4047.             soap->socket = SOAP_INVALID_SOCKET;      /* Oracle customization */
    4048. 

  4048.             return SOAP_INVALID_SOCKET;
    4049. 

  4049.           }
    4050. 

  4050.         }
    4051. 

  4051. 	else
    4052. 

  4052.         { soap_set_sender_error(soap, soap_ssl_error(soap, r), "SSL_connect error in tcp_connect()", SOAP_SSL_ERROR);
    4053. 

  4053.           soap->fclosesocket(soap, fd);
    4054. 

  4054.           soap->socket = SOAP_INVALID_SOCKET;      /* Oracle customization */
    4055. 

  4055.           return SOAP_INVALID_SOCKET;
    4056. 

  4056.         }
    4057. 

  4057.       }
    4058. 

  4058.     } while (!SSL_is_init_finished(soap->ssl));
    4059. 

  4059.     /* Set SSL sockets to nonblocking */
    4060. 

  4060.     SOAP_SOCKNONBLOCK(fd)
    4061. 

  4061.     /* Check server credentials when required */
    4062. 

  4062.     if ((soap->ssl_flags & SOAP_SSL_REQUIRE_SERVER_AUTHENTICATION))
    4063. 

  4063.     { int err;
    4064. 

  4064.       if ((err = SSL_get_verify_result(soap->ssl)) != X509_V_OK)
    4065. 

  4065.       { soap_set_sender_error(soap, X509_verify_cert_error_string(err), "SSL certificate presented by peer cannot be verified in tcp_connect()", SOAP_SSL_ERROR);
    4066. 

  4066.         soap->fclosesocket(soap, fd);
    4067. 

  4067.         soap->socket = SOAP_INVALID_SOCKET;      /* Oracle customization */
    4068. 

  4068.         return SOAP_INVALID_SOCKET;
    4069. 

  4069.       }
    4070. 

  4070.       if (!(soap->ssl_flags & SOAP_SSL_SKIP_HOST_CHECK))
    4071. 

  4071.       { /* Oracle customization: X509_NAME *subj; */
    4072. 

  4072.         int ext_count;
    4073. 

  4073.         int ok = 0;
    4074. 

  4074.         X509 *peer;
    4075. 

  4075.         peer = SSL_get_peer_certificate(soap->ssl);
    4076. 

  4076.         if (!peer)
    4077. 

  4077.         { soap_set_sender_error(soap, "SSL error", "No SSL certificate was presented by the peer in tcp_connect()", SOAP_SSL_ERROR);
    4078. 

  4078.           soap->fclosesocket(soap, fd);
    4079. 

  4079.           soap->socket = SOAP_INVALID_SOCKET;      /* Oracle customization */
    4080. 

  4080.           return SOAP_INVALID_SOCKET;
    4081. 

  4081.         }
    4082. 

  4082.         ext_count = X509_get_ext_count(peer);
    4083. 

  4083.         if (ext_count > 0)
    4084. 

  4084.         { int i;
    4085. 

  4085.           for (i = 0; i < ext_count; i++)
    4086. 

  4086.           { X509_EXTENSION *ext = X509_get_ext(peer, i);
    4087. 

  4087.             const char *ext_str = OBJ_nid2sn(OBJ_obj2nid(X509_EXTENSION_get_object(ext)));
    4088. 

  4088.             if (ext_str && !strcmp(ext_str, "subjectAltName"))
    4089. 

  4089.             { X509V3_EXT_METHOD *meth = (X509V3_EXT_METHOD*)X509V3_EXT_get(ext);
    4090. 

  4090.               void *ext_data;
    4091. 

  4091. #if (OPENSSL_VERSION_NUMBER >= 0x0090800fL)
    4092. 

  4092.               const unsigned char *data;
    4093. 

  4093. #else
    4094. 

  4094.               unsigned char *data;
    4095. 

  4095. #endif
    4096. 

  4096.               STACK_OF(CONF_VALUE) *val;
    4097. 

  4097.               int j;
    4098. 

  4098.               if (!meth)
    4099. 

  4099.                 break;
    4100. 

  4100.               data = ext->value->data;
    4101. 

  4101. #if (OPENSSL_VERSION_NUMBER > 0x00907000L)
    4102. 

  4102.               if (meth->it) 
    4103. 

  4103.                 ext_data = ASN1_item_d2i(NULL, &data, ext->value->length, ASN1_ITEM_ptr(meth->it));
    4104. 

  4104.               else
    4105. 

  4105.               { /* OpenSSL not perfectly portable at this point (?):
    4106. 

  4106.                    Some compilers appear to prefer
    4107. 

  4107.                      meth->d2i(NULL, (const unsigned char**)&data, ...
    4108. 

  4108.                    and others prefer
    4109. 

  4109.                      meth->d2i(NULL, &data, ext->value->length);
    4110. 

  4110.                 */
    4111. 

  4111.                 ext_data = meth->d2i(NULL, &data, ext->value->length);
    4112. 

  4112.               }
    4113. 

  4113. #else
    4114. 

  4114.               ext_data = meth->d2i(NULL, &data, ext->value->length);
    4115. 

  4115. #endif
    4116. 

  4116.               if (ext_data)
    4117. 

  4117.               { val = meth->i2v(meth, ext_data, NULL);
    4118. 

  4118. 		if (val)
    4119. 

  4119.                 { for (j = 0; j < sk_CONF_VALUE_num(val); j++)
    4120. 

  4120.                   { CONF_VALUE *nval = sk_CONF_VALUE_value(val, j);
    4121. 

  4121.                     if (nval && !strcmp(nval->name, "DNS") && !strcmp(nval->value, host))
    4122. 

  4122.                     { ok = 1;
    4123. 

  4123.                       break;
    4124. 

  4124.                     }
    4125. 

  4125.                   }
    4126. 

  4126.                   sk_CONF_VALUE_pop_free(val, X509V3_conf_free);
    4127. 

  4127.                 }
    4128. 

  4128. #if (OPENSSL_VERSION_NUMBER > 0x00907000L)
    4129. 

  4129.                 if (meth->it)
    4130. 

  4130.                   ASN1_item_free((ASN1_VALUE*)ext_data, ASN1_ITEM_ptr(meth->it));
    4131. 

  4131.                 else
    4132. 

  4132.                   meth->ext_free(ext_data);
    4133. 

  4133. #else
    4134. 

  4134.                 meth->ext_free(ext_data);
    4135. 

  4135. #endif
    4136. 

  4136. 	      }
    4137. 

  4137.             }
    4138. 

  4138.             if (ok)
    4139. 

  4139.               break;
    4140. 

  4140.           }
    4141. 

  4141.         }
    4142. 

  4142.         //
    4143. 

  4143.         // Oracle customization
    4144. 

  4144.         //
    4145. 

  4145.         // the certificate subject name is an entity name, not a DNS name
    4146. 

  4146.         //
    4147. 

  4147.         /*
    4148. 

  4148.         if (!ok && (subj = X509_get_subject_name(peer)))
    4149. 

  4149.         { int i = -1;
    4150. 

  4150.           do
    4151. 

  4151.           { ASN1_STRING *name;
    4152. 

  4152.             i = X509_NAME_get_index_by_NID(subj, NID_commonName, i);
    4153. 

  4153.             if (i == -1)
    4154. 

  4154.               break;
    4155. 

  4155.             name = X509_NAME_ENTRY_get_data(X509_NAME_get_entry(subj, i));
    4156. 

  4156.             if (name)
    4157. 

  4157.             { if (!soap_tag_cmp(host, (const char*)M_ASN1_STRING_data(name)))
    4158. 

  4158.                 ok = 1;
    4159. 

  4159.               else
    4160. 

  4160.               { unsigned char *tmp = NULL;
    4161. 

  4161.                 ASN1_STRING_to_UTF8(&tmp, name);
    4162. 

  4162.                 if (tmp)
    4163. 

  4163.                 { if (!soap_tag_cmp(host, (const char*)tmp))
    4164. 

  4164.                     ok = 1;
    4165. 

  4165.                   OPENSSL_free(tmp);
    4166. 

  4166.                 }
    4167. 

  4167.               }
    4168. 

  4168.             }
    4169. 

  4169.           } while (!ok);
    4170. 

  4170.         }
    4171. 

  4171.         */
    4172. 

  4172.         X509_free(peer);
    4173. 

  4173.         /*
    4174. 

  4174.         if (!ok)
    4175. 

  4175.         { soap_set_sender_error(soap, "SSL error", "SSL certificate host name mismatch in tcp_connect()", SOAP_SSL_ERROR);
    4176. 

  4176.           soap->fclosesocket(soap, fd);
    4177. 

  4177.           return SOAP_INVALID_SOCKET;
    4178. 

  4178.         }
    4179. 

  4179.         */
    4180. 

  4180.       }
    4181. 

  4181.     }
    4182. 

  4182. #ifdef SOAP_DEBUG
    4183. 

  4183.     //
    4184. 

  4184.     // Oracle customization for debug
    4185. 

  4185.     //
    4186. 

  4186.     if ( SSL_session_reused( soap->ssl ) == 1)
    4187. 

  4187.     {
    4188. 

  4188.       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "SSL session reused\n"));
    4189. 

  4189.     }
    4190. 

  4190.     else
    4191. 

  4191.     {
    4192. 

  4192.       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "SSL session negotiated\n"));
    4193. 

  4193.     }
    4194. 

  4194. #endif
    4195. 

  4195. #else
    4196. 

  4196.     soap->fclosesocket(soap, fd);
    4197. 

  4197.     soap->socket = SOAP_INVALID_SOCKET;      /* Oracle customization */
    4198. 

  4198.     soap->error = SOAP_SSL_ERROR;
    4199. 

  4199.     return SOAP_INVALID_SOCKET;
    4200. 

  4200. #endif
    4201. 

  4201.   }
    4202. 

  4202.   return fd;
    4203. 

  4203. }
    4204. 

  4204. #endif
    4205. 

  4205. #endif
    4206. 

  4206. 

  4207. /******************************************************************************/
    4208. 

  4208. #ifndef WITH_NOIO
    4209. 

  4209. #ifndef PALM_1
    4210. 

  4210. static int
    4211. 

  4211. tcp_select(struct soap *soap, SOAP_SOCKET s, int flags, int timeout)
    4212. 

  4212. { register int r;
    4213. 

  4213.   struct timeval tv;
    4214. 

  4214.   fd_set fd[3], *rfd, *sfd, *efd;
    4215. 

  4215.   soap->errnum = 0;
    4216. 

  4216. #ifndef WIN32
    4217. 

  4217.   /* if fd max set size exceeded, use poll() when available */
    4218. 

  4218. #if defined(__QNX__) || defined(QNX) /* select() is not MT safe on some QNX */
    4219. 

  4219.   if (1)
    4220. 

  4220. #else
    4221. 

  4221.   if ((int)s >= (int)FD_SETSIZE)
    4222. 

  4222. #endif
    4223. 

  4223. #ifdef HAVE_POLL
    4224. 

  4224.   { struct pollfd pollfd;
    4225. 

  4225.     int retries = 0;
    4226. 

  4226.     pollfd.fd = (int)s;
    4227. 

  4227.     pollfd.events = 0;
    4228. 

  4228.     if (flags & SOAP_TCP_SELECT_RCV)
    4229. 

  4229.       pollfd.events |= POLLIN;
    4230. 

  4230.     if (flags & SOAP_TCP_SELECT_SND)
    4231. 

  4231.       pollfd.events |= POLLOUT;
    4232. 

  4232.     if (flags & SOAP_TCP_SELECT_ERR)
    4233. 

  4233.       pollfd.events |= POLLERR;
    4234. 

  4234.     if (timeout < 0)
    4235. 

  4235.       timeout /= -1000; /* -usec -> ms */
    4236. 

  4236.     else if (timeout <= 1000000) /* avoid overflow */
    4237. 

  4237.       timeout *= 1000; /* sec -> ms */
    4238. 

  4238.     else
    4239. 

  4239.     { retries = timeout / 1000000;
    4240. 

  4240.       timeout = 1000000000;
    4241. 

  4241.     }
    4242. 

  4242.     do r = poll(&pollfd, 1, timeout);
    4243. 

  4243.     while (r == 0 && retries--);
    4244. 

  4244.     if (r > 0)
    4245. 

  4245.     { r = 0;
    4246. 

  4246.       if ((flags & SOAP_TCP_SELECT_RCV) && (pollfd.revents & POLLIN))
    4247. 

  4247.         r |= SOAP_TCP_SELECT_RCV;
    4248. 

  4248.       if ((flags & SOAP_TCP_SELECT_SND) && (pollfd.revents & POLLOUT))
    4249. 

  4249.         r |= SOAP_TCP_SELECT_SND;
    4250. 

  4250.       if ((flags & SOAP_TCP_SELECT_ERR) && (pollfd.revents & POLLERR))
    4251. 

  4251.         r |= SOAP_TCP_SELECT_ERR;
    4252. 

  4252.     }
    4253. 

  4253.     else if (r < 0)
    4254. 

  4254.       soap->errnum = soap_socket_errno(s);
    4255. 

  4255.     return r;
    4256. 

  4256.   }
    4257. 

  4257. #else
    4258. 

  4258.   { soap->error = SOAP_FD_EXCEEDED;
    4259. 

  4259.     return -1;
    4260. 

  4260.   }
    4261. 

  4261. #endif
    4262. 

  4262. #endif
    4263. 

  4263.   rfd = sfd = efd = NULL;
    4264. 

  4264.   if (flags & SOAP_TCP_SELECT_RCV)
    4265. 

  4265.   { rfd = &fd[0];
    4266. 

  4266.     FD_ZERO(rfd);
    4267. 

  4267.     FD_SET(s, rfd);
    4268. 

  4268.   }
    4269. 

  4269.   if (flags & SOAP_TCP_SELECT_SND)
    4270. 

  4270.   { sfd = &fd[1];
    4271. 

  4271.     FD_ZERO(sfd);
    4272. 

  4272.     FD_SET(s, sfd);
    4273. 

  4273.   }
    4274. 

  4274.   if (flags & SOAP_TCP_SELECT_ERR)
    4275. 

  4275.   { efd = &fd[2];
    4276. 

  4276.     FD_ZERO(efd);
    4277. 

  4277.     FD_SET(s, efd);
    4278. 

  4278.   }
    4279. 

  4279.   if (timeout >= 0)
    4280. 

  4280.   { tv.tv_sec = timeout;
    4281. 

  4281.     tv.tv_usec = 0;
    4282. 

  4282.   }
    4283. 

  4283.   else
    4284. 

  4284.   { tv.tv_sec = -timeout / 1000000;
    4285. 

  4285.     tv.tv_usec = -timeout % 1000000;
    4286. 

  4286.   }
    4287. 

  4287.   r = select((int)s + 1, rfd, sfd, efd, &tv);
    4288. 

  4288.   if (r > 0)
    4289. 

  4289.   { r = 0;
    4290. 

  4290.     if ((flags & SOAP_TCP_SELECT_RCV) && FD_ISSET(s, rfd))
    4291. 

  4291.       r |= SOAP_TCP_SELECT_RCV;
    4292. 

  4292.     if ((flags & SOAP_TCP_SELECT_SND) && FD_ISSET(s, sfd))
    4293. 

  4293.       r |= SOAP_TCP_SELECT_SND;
    4294. 

  4294.     if ((flags & SOAP_TCP_SELECT_ERR) && FD_ISSET(s, efd))
    4295. 

  4295.       r |= SOAP_TCP_SELECT_ERR;
    4296. 

  4296.   }
    4297. 

  4297.   else if (r < 0)
    4298. 

  4298.     soap->errnum = soap_socket_errno(s);
    4299. 

  4299.   return r;
    4300. 

  4300. }
    4301. 

  4301. #endif
    4302. 

  4302. #endif
    4303. 

  4303. 

  4304. /******************************************************************************/
    4305. 

  4305. #ifndef WITH_NOIO
    4306. 

  4306. #ifndef PALM_1
    4307. 

  4307. static SOAP_SOCKET
    4308. 

  4308. tcp_accept(struct soap *soap, SOAP_SOCKET s, struct sockaddr *a, int *n)
    4309. 

  4309. { SOAP_SOCKET fd;
    4310. 

  4310.   fd = accept(s, a, (SOAP_SOCKLEN_T*)n); /* portability note: see SOAP_SOCKLEN_T definition in stdsoap2.h */
    4311. 

  4311. #ifdef SOCKET_CLOSE_ON_EXEC
    4312. 

  4312. #ifdef WIN32
    4313. 

  4313. #ifndef UNDER_CE
    4314. 

  4314.   SetHandleInformation((HANDLE)fd, HANDLE_FLAG_INHERIT, 0);
    4315. 

  4315. #endif
    4316. 

  4316. #else
    4317. 

  4317.   fcntl(fd, F_SETFD, FD_CLOEXEC);
    4318. 

  4318. #endif
    4319. 

  4319. #endif
    4320. 

  4320.   return fd;
    4321. 

  4321. }
    4322. 

  4322. #endif
    4323. 

  4323. #endif
    4324. 

  4324. 

  4325. /******************************************************************************/
    4326. 

  4326. #ifndef WITH_NOIO
    4327. 

  4327. #ifndef PALM_1
    4328. 

  4328. static int
    4329. 

  4329. tcp_disconnect(struct soap *soap)
    4330. 

  4330. {
    4331. 

  4331. #ifdef WITH_OPENSSL
    4332. 

  4332.   if (soap->ssl)
    4333. 

  4333.   { int r, s = 0;
    4334. 

  4334.     if (soap->session)
    4335. 

  4335.     { SSL_SESSION_free(soap->session);
    4336. 

  4336.       soap->session = NULL;
    4337. 

  4337.     }
    4338. 

  4338.     if (*soap->host)
    4339. 

  4339.     { soap->session = SSL_get1_session(soap->ssl);
    4340. 

  4340.       if (soap->session)
    4341. 

  4341.       { strcpy(soap->session_host, soap->host);
    4342. 

  4342.         soap->session_port = soap->port;
    4343. 

  4343.       }
    4344. 

  4344.     }
    4345. 

  4345.     r = SSL_shutdown(soap->ssl);
    4346. 

  4346.     /* SSL shutdown does not work when reads are pending */
    4347. 

  4347.     while (SSL_want_read(soap->ssl))
    4348. 

  4348.     { SSL_read(soap->ssl, NULL, 0);
    4349. 

  4349.       if (soap_socket_errno(soap->socket) != SOAP_EAGAIN)
    4350. 

  4350.       { r = SSL_shutdown(soap->ssl);
    4351. 

  4351. 	break;
    4352. 

  4352.       }
    4353. 

  4353.     }
    4354. 

  4354.     if (r == 0)
    4355. 

  4355.     { if (soap_valid_socket(soap->socket))
    4356. 

  4356.       { if (!soap->fshutdownsocket(soap, soap->socket, 1))
    4357. 

  4357.         {
    4358. 

  4358. #ifndef WITH_LEAN
    4359. 

  4359. 	  /*
    4360. 

  4360.           wait up to 10 seconds for close_notify to be sent by peer (if peer not
    4361. 

  4361.           present, this avoids calling SSL_shutdown() which has a lengthy return
    4362. 

  4362.           timeout)
    4363. 

  4363.           */
    4364. 

  4364.           r = tcp_select(soap, soap->socket, SOAP_TCP_SELECT_RCV | SOAP_TCP_SELECT_ERR, 10);
    4365. 

  4365.           if (r <= 0 && soap->errnum != SOAP_EINTR)
    4366. 

  4366.           { soap->errnum = 0;
    4367. 

  4367.             DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Connection lost...\n"));
    4368. 

  4368.             soap->fclosesocket(soap, soap->socket);
    4369. 

  4369.             soap->socket = SOAP_INVALID_SOCKET;
    4370. 

  4370.             ERR_remove_state(0);
    4371. 

  4371.             return SOAP_OK;
    4372. 

  4372.           }
    4373. 

  4373. #else
    4374. 

  4374.           r = SSL_shutdown(soap->ssl);
    4375. 

  4375. #endif
    4376. 

  4376.         }
    4377. 

  4377.       }
    4378. 

  4378.     }
    4379. 

  4379.     if (r != 1)
    4380. 

  4380.     { s = ERR_get_error();
    4381. 

  4381.       if (s)
    4382. 

  4382.       { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Shutdown failed: %d\n", SSL_get_error(soap->ssl, r)));
    4383. 

  4383.         if (soap_valid_socket(soap->socket) && !(soap->omode & SOAP_IO_UDP))
    4384. 

  4384.         { soap->fclosesocket(soap, soap->socket);
    4385. 

  4385.           soap->socket = SOAP_INVALID_SOCKET;
    4386. 

  4386.         }
    4387. 

  4387.       }
    4388. 

  4388.     }
    4389. 

  4389.     SSL_free(soap->ssl);
    4390. 

  4390.     soap->ssl = NULL;
    4391. 

  4391.     if (s)
    4392. 

  4392.       return SOAP_SSL_ERROR;
    4393. 

  4393.     ERR_remove_state(0);
    4394. 

  4394.   }
    4395. 

  4395. #endif
    4396. 

  4396.   if (soap_valid_socket(soap->socket) && !(soap->omode & SOAP_IO_UDP))
    4397. 

  4397.   { soap->fshutdownsocket(soap, soap->socket, 2);
    4398. 

  4398.     soap->fclosesocket(soap, soap->socket);
    4399. 

  4399.     soap->socket = SOAP_INVALID_SOCKET;
    4400. 

  4400.   }
    4401. 

  4401.   return SOAP_OK;
    4402. 

  4402. }
    4403. 

  4403. #endif
    4404. 

  4404. #endif
    4405. 

  4405. 

  4406. /******************************************************************************/
    4407. 

  4407. #ifndef WITH_NOIO
    4408. 

  4408. #ifndef PALM_1
    4409. 

  4409. static int
    4410. 

  4410. tcp_closesocket(struct soap *soap, SOAP_SOCKET fd)
    4411. 

  4411. { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Close socket %d\n", (int)fd));
    4412. 

  4412.   return soap_closesocket(fd);
    4413. 

  4413. }
    4414. 

  4414. #endif
    4415. 

  4415. #endif
    4416. 

  4416. 

  4417. /******************************************************************************/
    4418. 

  4418. #ifndef WITH_NOIO
    4419. 

  4419. #ifndef PALM_1
    4420. 

  4420. static int
    4421. 

  4421. tcp_shutdownsocket(struct soap *soap, SOAP_SOCKET fd, int how)
    4422. 

  4422. { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Shutdown socket %d how=%d\n", (int)fd, how));
    4423. 

  4423.   return shutdown(fd, how);
    4424. 

  4424. }
    4425. 

  4425. #endif
    4426. 

  4426. #endif
    4427. 

  4427. 

  4428. /******************************************************************************/
    4429. 

  4429. #ifndef WITH_NOIO
    4430. 

  4430. #ifndef PALM_1
    4431. 

  4431. SOAP_FMAC1
    4432. 

  4432. SOAP_SOCKET
    4433. 

  4433. SOAP_FMAC2
    4434. 

  4434. soap_bind(struct soap *soap, const char *host, int port, int backlog)
    4435. 

  4435. {
    4436. 

  4436. #ifdef WITH_IPV6
    4437. 

  4437.   struct addrinfo *addrinfo = NULL;
    4438. 

  4438.   struct addrinfo hints;
    4439. 

  4439.   struct addrinfo res;
    4440. 

  4440.   int err;
    4441. 

  4441. #ifdef IPV6_V6ONLY
    4442. 

  4442.   int unset = 0;
    4443. 

  4443. #ifdef SOL_IP
    4444. 

  4444.   int level = SOL_IP;
    4445. 

  4445. #else
    4446. 

  4446.   int level = IPPROTO_IPV6;
    4447. 

  4447. #endif
    4448. 

  4448. #endif
    4449. 

  4449. #endif
    4450. 

  4450. #ifndef WITH_LEAN
    4451. 

  4451.   int len = SOAP_BUFLEN;
    4452. 

  4452.   int set = 1;
    4453. 

  4453. #endif
    4454. 

  4454.   if (soap_valid_socket(soap->master))
    4455. 

  4455.   { soap->fclosesocket(soap, soap->master);
    4456. 

  4456.     soap->master = SOAP_INVALID_SOCKET;
    4457. 

  4457.   }
    4458. 

  4458.   soap->socket = SOAP_INVALID_SOCKET;
    4459. 

  4459.   soap->errmode = 1;
    4460. 

  4460.   if (tcp_init(soap))
    4461. 

  4461.   { soap_set_receiver_error(soap, tcp_error(soap), "TCP init failed in soap_bind()", SOAP_TCP_ERROR);
    4462. 

  4462.     return SOAP_INVALID_SOCKET;
    4463. 

  4463.   }
    4464. 

  4464. #ifdef WITH_IPV6
    4465. 

  4465.   memset((void*)&hints, 0, sizeof(hints));
    4466. 

  4466.   hints.ai_family = PF_UNSPEC;
    4467. 

  4467. #ifndef WITH_LEAN
    4468. 

  4468.   if ((soap->omode & SOAP_IO_UDP))
    4469. 

  4469.     hints.ai_socktype = SOCK_DGRAM;
    4470. 

  4470.   else
    4471. 

  4471. #endif
    4472. 

  4472.     hints.ai_socktype = SOCK_STREAM;
    4473. 

  4473.   hints.ai_flags = AI_PASSIVE;
    4474. 

  4474.   soap->errmode = 2;
    4475. 

  4475.   /* Oracle customization: check err before using addrinfo */
    4476. 

  4476.   err = getaddrinfo(host, soap_int2s(soap, port), &hints, &addrinfo);
    4477. 

  4477.   if (err || !addrinfo)
    4478. 

  4478.   { soap_set_receiver_error(soap, SOAP_GAI_STRERROR(err), "getaddrinfo failed in soap_bind()", SOAP_TCP_ERROR);
    4479. 

  4479.     if (addrinfo)
    4480. 

  4480.     {
    4481. 

  4481.       freeaddrinfo(addrinfo);
    4482. 

  4482.     }
    4483. 

  4483.     return SOAP_INVALID_SOCKET;
    4484. 

  4484.   }
    4485. 

  4485.   res = *addrinfo;
    4486. 

  4486.   memcpy(&soap->peer, addrinfo->ai_addr, addrinfo->ai_addrlen);
    4487. 

  4487.   soap->peerlen = addrinfo->ai_addrlen;
    4488. 

  4488.   res.ai_addr = (struct sockaddr*)&soap->peer;
    4489. 

  4489.   res.ai_addrlen = soap->peerlen;
    4490. 

  4490.   freeaddrinfo(addrinfo);
    4491. 

  4491.   soap->master = (int)socket(res.ai_family, res.ai_socktype, res.ai_protocol);
    4492. 

  4492. #else
    4493. 

  4493. #ifndef WITH_LEAN
    4494. 

  4494.   if ((soap->omode & SOAP_IO_UDP))
    4495. 

  4495.     soap->master = (int)socket(AF_INET, SOCK_DGRAM, 0);
    4496. 

  4496.   else
    4497. 

  4497. #endif
    4498. 

  4498.     soap->master = (int)socket(AF_INET, SOCK_STREAM, 0);
    4499. 

  4499. #endif
    4500. 

  4500.   soap->errmode = 0;
    4501. 

  4501.   if (!soap_valid_socket(soap->master))
    4502. 

  4502.   { soap->errnum = soap_socket_errno(soap->master);
    4503. 

  4503.     soap_set_receiver_error(soap, tcp_error(soap), "socket failed in soap_bind()", SOAP_TCP_ERROR);
    4504. 

  4504.     return SOAP_INVALID_SOCKET;
    4505. 

  4505.   }
    4506. 

  4506. #ifndef WITH_LEAN
    4507. 

  4507.   if ((soap->omode & SOAP_IO_UDP))
    4508. 

  4508.     soap->socket = soap->master;
    4509. 

  4509. #endif
    4510. 

  4510. #ifdef SOCKET_CLOSE_ON_EXEC
    4511. 

  4511. #ifdef WIN32
    4512. 

  4512. #ifndef UNDER_CE
    4513. 

  4513.   SetHandleInformation((HANDLE)soap->master, HANDLE_FLAG_INHERIT, 0);
    4514. 

  4514. #endif
    4515. 

  4515. #else
    4516. 

  4516.   fcntl(soap->master, F_SETFD, 1);
    4517. 

  4517. #endif
    4518. 

  4518. #endif
    4519. 

  4519. #ifndef WITH_LEAN
    4520. 

  4520.   if (soap->bind_flags && setsockopt(soap->master, SOL_SOCKET, soap->bind_flags, (char*)&set, sizeof(int)))
    4521. 

  4521.   { soap->errnum = soap_socket_errno(soap->master);
    4522. 

  4522.     soap_set_receiver_error(soap, tcp_error(soap), "setsockopt failed in soap_bind()", SOAP_TCP_ERROR);
    4523. 

  4523.     return SOAP_INVALID_SOCKET;
    4524. 

  4524.   }
    4525. 

  4525.   if (((soap->imode | soap->omode) & SOAP_IO_KEEPALIVE) && setsockopt(soap->master, SOL_SOCKET, SO_KEEPALIVE, (char*)&set, sizeof(int)))
    4526. 

  4526.   { soap->errnum = soap_socket_errno(soap->master);
    4527. 

  4527.     soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_KEEPALIVE failed in soap_bind()", SOAP_TCP_ERROR);
    4528. 

  4528.     return SOAP_INVALID_SOCKET;
    4529. 

  4529.   }
    4530. 

  4530.   if (setsockopt(soap->master, SOL_SOCKET, SO_SNDBUF, (char*)&len, sizeof(int)))
    4531. 

  4531.   { soap->errnum = soap_socket_errno(soap->master);
    4532. 

  4532.     soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_SNDBUF failed in soap_bind()", SOAP_TCP_ERROR);
    4533. 

  4533.     return SOAP_INVALID_SOCKET;
    4534. 

  4534.   }
    4535. 

  4535.   if (setsockopt(soap->master, SOL_SOCKET, SO_RCVBUF, (char*)&len, sizeof(int)))
    4536. 

  4536.   { soap->errnum = soap_socket_errno(soap->master);
    4537. 

  4537.     soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_RCVBUF failed in soap_bind()", SOAP_TCP_ERROR);
    4538. 

  4538.     return SOAP_INVALID_SOCKET;
    4539. 

  4539.   }
    4540. 

  4540. #ifdef TCP_NODELAY
    4541. 

  4541.   if (!(soap->omode & SOAP_IO_UDP) && setsockopt(soap->master, IPPROTO_TCP, TCP_NODELAY, (char*)&set, sizeof(int)))
    4542. 

  4542.   { soap->errnum = soap_socket_errno(soap->master);
    4543. 

  4543.     soap_set_receiver_error(soap, tcp_error(soap), "setsockopt TCP_NODELAY failed in soap_bind()", SOAP_TCP_ERROR);
    4544. 

  4544.     return SOAP_INVALID_SOCKET;
    4545. 

  4545.   }
    4546. 

  4546. #endif
    4547. 

  4547. #endif
    4548. 

  4548. #ifdef WITH_IPV6
    4549. 

  4549. #ifdef IPV6_V6ONLY
    4550. 

  4550.   if (setsockopt(soap->master, level, IPV6_V6ONLY, (char*)&unset, sizeof(int)))
    4551. 

  4551.   { soap->errnum = soap_socket_errno(soap->master);
    4552. 

  4552.     soap_set_receiver_error(soap, tcp_error(soap), "setsockopt IPV6_V6ONLY failed in soap_bind()", SOAP_TCP_ERROR);
    4553. 

  4553.     return SOAP_INVALID_SOCKET;
    4554. 

  4554.   }
    4555. 

  4555. #endif
    4556. 

  4556.   soap->errmode = 0;
    4557. 

  4557.   if (bind(soap->master, res.ai_addr, (int)res.ai_addrlen))
    4558. 

  4558.   { soap->errnum = soap_socket_errno(soap->master);
    4559. 

  4559.     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not bind to host\n"));
    4560. 

  4560.     soap_closesock(soap);
    4561. 

  4561.     soap_set_receiver_error(soap, tcp_error(soap), "bind failed in soap_bind()", SOAP_TCP_ERROR);
    4562. 

  4562.     return SOAP_INVALID_SOCKET;
    4563. 

  4563.   }  
    4564. 

  4564. #else
    4565. 

  4565.   soap->peerlen = sizeof(soap->peer);
    4566. 

  4566.   memset((void*)&soap->peer, 0, sizeof(soap->peer));
    4567. 

  4567.   soap->peer.sin_family = AF_INET;
    4568. 

  4568.   soap->errmode = 2;
    4569. 

  4569.   if (host)
    4570. 

  4570.   { if (soap->fresolve(soap, host, &soap->peer.sin_addr))
    4571. 

  4571.     { soap_set_receiver_error(soap, tcp_error(soap), "get host by name failed in soap_bind()", SOAP_TCP_ERROR);
    4572. 

  4572.       return SOAP_INVALID_SOCKET;
    4573. 

  4573.     }
    4574. 

  4574.   }
    4575. 

  4575.   else
    4576. 

  4576.     soap->peer.sin_addr.s_addr = htonl(INADDR_ANY);
    4577. 

  4577.   soap->peer.sin_port = htons((short)port);
    4578. 

  4578.   soap->errmode = 0;
    4579. 

  4579.   if (bind(soap->master, (struct sockaddr*)&soap->peer, (int)soap->peerlen))
    4580. 

  4580.   { soap->errnum = soap_socket_errno(soap->master);
    4581. 

  4581.     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not bind to host\n"));
    4582. 

  4582.     soap_closesock(soap);
    4583. 

  4583.     soap_set_receiver_error(soap, tcp_error(soap), "bind failed in soap_bind()", SOAP_TCP_ERROR);
    4584. 

  4584.     return SOAP_INVALID_SOCKET;
    4585. 

  4585.   }
    4586. 

  4586. #endif
    4587. 

  4587.   if (!(soap->omode & SOAP_IO_UDP) && listen(soap->master, backlog))
    4588. 

  4588.   { soap->errnum = soap_socket_errno(soap->master);
    4589. 

  4589.     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not bind to host\n"));
    4590. 

  4590.     soap_closesock(soap);
    4591. 

  4591.     soap_set_receiver_error(soap, tcp_error(soap), "listen failed in soap_bind()", SOAP_TCP_ERROR);
    4592. 

  4592.     return SOAP_INVALID_SOCKET;
    4593. 

  4593.   }  
    4594. 

  4594.   return soap->master;
    4595. 

  4595. }
    4596. 

  4596. #endif
    4597. 

  4597. #endif
    4598. 

  4598. 

  4599. /******************************************************************************/
    4600. 

  4600. #ifndef WITH_NOIO
    4601. 

  4601. #ifndef PALM_1
    4602. 

  4602. SOAP_FMAC1
    4603. 

  4603. int
    4604. 

  4604. SOAP_FMAC2
    4605. 

  4605. soap_poll(struct soap *soap)
    4606. 

  4606. { 
    4607. 

  4607. #ifndef WITH_LEAN
    4608. 

  4608.   register int r;
    4609. 

  4609.   if (soap_valid_socket(soap->socket))
    4610. 

  4610.   { r = tcp_select(soap, soap->socket, SOAP_TCP_SELECT_ALL, 0);
    4611. 

  4611.     if (r > 0 && (r & SOAP_TCP_SELECT_ERR))
    4612. 

  4612.       r = -1;
    4613. 

  4613.   }
    4614. 

  4614.   else if (soap_valid_socket(soap->master))
    4615. 

  4615.     r = tcp_select(soap, soap->master, SOAP_TCP_SELECT_SND, 0);
    4616. 

  4616.   else
    4617. 

  4617.     return SOAP_OK;
    4618. 

  4618.   if (r > 0)
    4619. 

  4619.   {
    4620. 

  4620. #ifdef WITH_OPENSSL
    4621. 

  4621.     if (soap->imode & SOAP_ENC_SSL)
    4622. 

  4622.     {
    4623. 

  4623.       if (soap_valid_socket(soap->socket)
    4624. 

  4624.        && (r & SOAP_TCP_SELECT_SND)
    4625. 

  4625.        && (!(r & SOAP_TCP_SELECT_RCV)
    4626. 

  4626.         || SSL_peek(soap->ssl, soap->tmpbuf, 1) > 0))
    4627. 

  4627.         return SOAP_OK;
    4628. 

  4628.     }
    4629. 

  4629.     else
    4630. 

  4630. #endif
    4631. 

  4631.       if (soap_valid_socket(soap->socket)
    4632. 

  4632.        && (r & SOAP_TCP_SELECT_SND)
    4633. 

  4633.        && (!(r & SOAP_TCP_SELECT_RCV)
    4634. 

  4634.         || recv(soap->socket, soap->tmpbuf, 1, MSG_PEEK) > 0))
    4635. 

  4635.         return SOAP_OK;
    4636. 

  4636.   }
    4637. 

  4637.   else if (r < 0)
    4638. 

  4638.   { if ((soap_valid_socket(soap->master) || soap_valid_socket(soap->socket)) && soap_socket_errno(soap->master) != SOAP_EINTR)
    4639. 

  4639.     { soap_set_receiver_error(soap, tcp_error(soap), "select failed in soap_poll()", SOAP_TCP_ERROR);
    4640. 

  4640.       return soap->error = SOAP_TCP_ERROR;
    4641. 

  4641.     }
    4642. 

  4642.   }
    4643. 

  4643.   DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Polling: other end down on socket=%d select=%d\n", soap->socket, r));
    4644. 

  4644.   return SOAP_EOF;
    4645. 

  4645. #else
    4646. 

  4646.   return SOAP_OK;
    4647. 

  4647. #endif
    4648. 

  4648. }
    4649. 

  4649. #endif
    4650. 

  4650. #endif
    4651. 

  4651. 

  4652. /******************************************************************************/
    4653. 

  4653. #ifndef WITH_NOIO
    4654. 

  4654. #ifndef PALM_1
    4655. 

  4655. SOAP_FMAC1
    4656. 

  4656. SOAP_SOCKET
    4657. 

  4657. SOAP_FMAC2
    4658. 

  4658. soap_accept(struct soap *soap)
    4659. 

  4659. { int n = (int)sizeof(soap->peer);
    4660. 

  4660. #ifndef WITH_LEAN
    4661. 

  4661.   int len = SOAP_BUFLEN;
    4662. 

  4662.   int set = 1;
    4663. 

  4663. #endif
    4664. 

  4664.   soap->error = SOAP_OK;
    4665. 

  4665. #ifndef WITH_LEAN
    4666. 

  4666.   if ((soap->omode & SOAP_IO_UDP))
    4667. 

  4667.     return soap->socket = soap->master;
    4668. 

  4668. #endif
    4669. 

  4669.   memset((void*)&soap->peer, 0, sizeof(soap->peer));
    4670. 

  4670.   soap->socket = SOAP_INVALID_SOCKET;
    4671. 

  4671.   soap->errmode = 0;
    4672. 

  4672.   soap->keep_alive = 0;
    4673. 

  4673.   if (soap_valid_socket(soap->master))
    4674. 

  4674.   { register int err;
    4675. 

  4675.     for (;;)
    4676. 

  4676.     { if (soap->accept_timeout || soap->send_timeout || soap->recv_timeout)
    4677. 

  4677.       { for (;;)
    4678. 

  4678.         { register int r;
    4679. 

  4679.           r = tcp_select(soap, soap->master, SOAP_TCP_SELECT_ALL, soap->accept_timeout ? soap->accept_timeout : 60);
    4680. 

  4680.           if (r > 0)
    4681. 

  4681.             break;
    4682. 

  4682.           if (!r && soap->accept_timeout)
    4683. 

  4683.           { soap_set_receiver_error(soap, "Timeout", "accept failed in soap_accept()", SOAP_TCP_ERROR);
    4684. 

  4684.             return SOAP_INVALID_SOCKET;
    4685. 

  4685.           }
    4686. 

  4686. 	  if (r < 0)
    4687. 

  4687.           { r = soap->errnum;
    4688. 

  4688.             if (r != SOAP_EINTR)
    4689. 

  4689.             { soap_closesock(soap);
    4690. 

  4690.               soap_set_sender_error(soap, tcp_error(soap), "accept failed in soap_accept()", SOAP_TCP_ERROR);
    4691. 

  4691.               return SOAP_INVALID_SOCKET;
    4692. 

  4692.             }
    4693. 

  4693. 	  }
    4694. 

  4694.         }
    4695. 

  4695.       }
    4696. 

  4696.       if (soap->accept_timeout || soap->send_timeout || soap->recv_timeout)
    4697. 

  4697.         SOAP_SOCKNONBLOCK(soap->master)
    4698. 

  4698.       else
    4699. 

  4699.         SOAP_SOCKBLOCK(soap->master)
    4700. 

  4700.       soap->socket = soap->faccept(soap, soap->master, (struct sockaddr*)&soap->peer, &n);
    4701. 

  4701.       soap->peerlen = (size_t)n;
    4702. 

  4702.       if (soap_valid_socket(soap->socket))
    4703. 

  4703.       {
    4704. 

  4704. #ifdef WITH_IPV6
    4705. 

  4705. /* Use soap->host to store the numeric form of the remote host */
    4706. 

  4706.         getnameinfo((struct sockaddr*)&soap->peer, n, soap->host, sizeof(soap->host), NULL, 0, NI_NUMERICHOST | NI_NUMERICSERV); 
    4707. 

  4707.         DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Accept socket %d from %s\n", soap->socket, soap->host));
    4708. 

  4708.         //
    4709. 

  4709.         // Oracle customization
    4710. 

  4710.         //
    4711. 

  4711.         // bug fix: save off the remote host
    4712. 

  4712.         strcpy(soap->session_host, soap->host);
    4713. 

  4713.      soap->ip = 0; /* info stored in soap->peer and soap->host */
    4714. 

  4714.         soap->port = 0; /* info stored in soap->peer and soap->host */
    4715. 

  4715. #else
    4716. 

  4716.         soap->ip = ntohl(soap->peer.sin_addr.s_addr);
    4717. 

  4717.         soap->port = (int)ntohs(soap->peer.sin_port); /* does not return port number on some systems */
    4718. 

  4718.         DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Accept socket %d at port %d from IP %d.%d.%d.%d\n", soap->socket, soap->port, (int)(soap->ip>>24)&0xFF, (int)(soap->ip>>16)&0xFF, (int)(soap->ip>>8)&0xFF, (int)soap->ip&0xFF));
    4719. 

  4719. #endif
    4720. 

  4720. #ifndef WITH_LEAN
    4721. 

  4721.         if (soap->accept_flags == SO_LINGER)
    4722. 

  4722.         { struct linger linger;
    4723. 

  4723.           memset((void*)&linger, 0, sizeof(linger));
    4724. 

  4724.           linger.l_onoff = 1;
    4725. 

  4725.           linger.l_linger = soap->linger_time;
    4726. 

  4726.           if (setsockopt(soap->socket, SOL_SOCKET, SO_LINGER, (char*)&linger, sizeof(struct linger)))
    4727. 

  4727.           { soap->errnum = soap_socket_errno(soap->socket);
    4728. 

  4728.             soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_LINGER failed in soap_accept()", SOAP_TCP_ERROR);
    4729. 

  4729.             soap_closesock(soap);
    4730. 

  4730.             return SOAP_INVALID_SOCKET;
    4731. 

  4731.           }
    4732. 

  4732.         }
    4733. 

  4733.         else if (soap->accept_flags && setsockopt(soap->socket, SOL_SOCKET, soap->accept_flags, (char*)&set, sizeof(int)))
    4734. 

  4734.         { soap->errnum = soap_socket_errno(soap->socket);
    4735. 

  4735.           soap_set_receiver_error(soap, tcp_error(soap), "setsockopt failed in soap_accept()", SOAP_TCP_ERROR);
    4736. 

  4736.           soap_closesock(soap);
    4737. 

  4737.           return SOAP_INVALID_SOCKET;
    4738. 

  4738.         }
    4739. 

  4739.         if (((soap->imode | soap->omode) & SOAP_IO_KEEPALIVE) && setsockopt(soap->socket, SOL_SOCKET, SO_KEEPALIVE, (char*)&set, sizeof(int)))
    4740. 

  4740.         { soap->errnum = soap_socket_errno(soap->socket);
    4741. 

  4741.           soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_KEEPALIVE failed in soap_accept()", SOAP_TCP_ERROR);
    4742. 

  4742.           soap_closesock(soap);
    4743. 

  4743.           return SOAP_INVALID_SOCKET;
    4744. 

  4744.         }
    4745. 

  4745.         if (setsockopt(soap->socket, SOL_SOCKET, SO_SNDBUF, (char*)&len, sizeof(int)))
    4746. 

  4746.         { soap->errnum = soap_socket_errno(soap->socket);
    4747. 

  4747.           soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_SNDBUF failed in soap_accept()", SOAP_TCP_ERROR);
    4748. 

  4748.           soap_closesock(soap);
    4749. 

  4749.           return SOAP_INVALID_SOCKET;
    4750. 

  4750.         }
    4751. 

  4751.         if (setsockopt(soap->socket, SOL_SOCKET, SO_RCVBUF, (char*)&len, sizeof(int)))
    4752. 

  4752.         { soap->errnum = soap_socket_errno(soap->socket);
    4753. 

  4753.           soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_RCVBUF failed in soap_accept()", SOAP_TCP_ERROR);
    4754. 

  4754.           soap_closesock(soap);
    4755. 

  4755.           return SOAP_INVALID_SOCKET;
    4756. 

  4756.         }
    4757. 

  4757. #ifdef TCP_NODELAY
    4758. 

  4758.         if (!(soap->omode & SOAP_IO_UDP) && setsockopt(soap->socket, IPPROTO_TCP, TCP_NODELAY, (char*)&set, sizeof(int)))
    4759. 

  4759.         { soap->errnum = soap_socket_errno(soap->socket);
    4760. 

  4760.           soap_set_receiver_error(soap, tcp_error(soap), "setsockopt TCP_NODELAY failed in soap_accept()", SOAP_TCP_ERROR);
    4761. 

  4761.           soap_closesock(soap);
    4762. 

  4762.           return SOAP_INVALID_SOCKET;
    4763. 

  4763.         }
    4764. 

  4764. #endif
    4765. 

  4765. #endif
    4766. 

  4766.         soap->keep_alive = (((soap->imode | soap->omode) & SOAP_IO_KEEPALIVE) != 0);
    4767. 

  4767.         return soap->socket;
    4768. 

  4768.       }
    4769. 

  4769.       err = soap_socket_errno(soap->socket);
    4770. 

  4770.       if (err != 0 && err != SOAP_EINTR && err != SOAP_EAGAIN && err != SOAP_EWOULDBLOCK)
    4771. 

  4771.       { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Accept failed from %s\n", soap->host));
    4772. 

  4772.         soap->errnum = err;
    4773. 

  4773.         soap_set_receiver_error(soap, tcp_error(soap), "accept failed in soap_accept()", SOAP_TCP_ERROR);
    4774. 

  4774.         soap_closesock(soap);
    4775. 

  4775.         return SOAP_INVALID_SOCKET;
    4776. 

  4776.       }
    4777. 

  4777.     }
    4778. 

  4778.   }
    4779. 

  4779.   else
    4780. 

  4780.   { soap->errnum = 0;
    4781. 

  4781.     soap_set_receiver_error(soap, tcp_error(soap), "no master socket in soap_accept()", SOAP_TCP_ERROR);
    4782. 

  4782.     return SOAP_INVALID_SOCKET;
    4783. 

  4783.   }
    4784. 

  4784. }
    4785. 

  4785. #endif
    4786. 

  4786. #endif
    4787. 

  4787. 

  4788. /******************************************************************************/
    4789. 

  4789. #ifndef PALM_1
    4790. 

  4790. SOAP_FMAC1
    4791. 

  4791. int
    4792. 

  4792. SOAP_FMAC2
    4793. 

  4793. soap_closesock(struct soap *soap)
    4794. 

  4794. { register int status = soap->error;
    4795. 

  4795. #ifndef WITH_LEANER
    4796. 

  4796.   soap->mime.first = NULL;
    4797. 

  4797.   soap->mime.last = NULL;
    4798. 

  4798.   soap->dime.first = NULL;
    4799. 

  4799.   soap->dime.last = NULL;
    4800. 

  4800. #endif
    4801. 

  4801.   if (soap->fdisconnect && (soap->error = soap->fdisconnect(soap)))
    4802. 

  4802.     return soap->error;
    4803. 

  4803.   if (status == SOAP_EOF || status == SOAP_TCP_ERROR || status == SOAP_SSL_ERROR || !soap->keep_alive)
    4804. 

  4804.   { if (soap->fclose && (soap->error = soap->fclose(soap)))
    4805. 

  4805.       return soap->error;
    4806. 

  4806.     soap->keep_alive = 0;
    4807. 

  4807.   }
    4808. 

  4808. #ifdef WITH_ZLIB
    4809. 

  4809.   if (soap->zlib_state == SOAP_ZLIB_DEFLATE)
    4810. 

  4810.     deflateEnd(soap->d_stream);
    4811. 

  4811.   else if (soap->zlib_state == SOAP_ZLIB_INFLATE)
    4812. 

  4812.     inflateEnd(soap->d_stream);
    4813. 

  4813.   soap->zlib_state = SOAP_ZLIB_NONE;
    4814. 

  4814. #endif
    4815. 

  4815.   return soap->error = status;
    4816. 

  4816. }
    4817. 

  4817. #endif
    4818. 

  4818. 

  4819. /******************************************************************************/
    4820. 

  4820. #ifndef WITH_NOIO
    4821. 

  4821. #ifndef PALM_2
    4822. 

  4822. SOAP_FMAC1
    4823. 

  4823. void
    4824. 

  4824. SOAP_FMAC2
    4825. 

  4825. soap_cleanup(struct soap *soap)
    4826. 

  4826. { soap_done(soap);
    4827. 

  4827. #ifdef WIN32
    4828. 

  4828.   if (!tcp_done)
    4829. 

  4829.     return;
    4830. 

  4830.   tcp_done = 0;
    4831. 

  4831.   WSACleanup();
    4832. 

  4832. #endif
    4833. 

  4833. }
    4834. 

  4834. #endif
    4835. 

  4835. #endif
    4836. 

  4836. 

  4837. /******************************************************************************/
    4838. 

  4838. #ifndef PALM_1
    4839. 

  4839. SOAP_FMAC1
    4840. 

  4840. void
    4841. 

  4841. SOAP_FMAC2
    4842. 

  4842. soap_done(struct soap *soap)
    4843. 

  4843. { 
    4844. 

  4844. #ifdef SOAP_DEBUG
    4845. 

  4845.   int i;
    4846. 

  4846. #endif
    4847. 

  4847.   if (soap_check_state(soap))
    4848. 

  4848.     return;
    4849. 

  4849.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Done with context\n"));
    4850. 

  4850.   soap_free_temp(soap);
    4851. 

  4851.   while (soap->clist)
    4852. 

  4852.   { struct soap_clist *p = soap->clist->next;
    4853. 

  4853.     SOAP_FREE(soap, soap->clist);
    4854. 

  4854.     soap->clist = p;
    4855. 

  4855.   }
    4856. 

  4856.   if (soap->state == SOAP_INIT)
    4857. 

  4857.     soap->omode &= ~SOAP_IO_UDP; /* to force close the socket */
    4858. 

  4858.   soap->keep_alive = 0; /* to force close the socket */
    4859. 

  4859.   soap_closesock(soap);
    4860. 

  4860. #ifdef WITH_COOKIES
    4861. 

  4861.   soap_free_cookies(soap);
    4862. 

  4862. #endif
    4863. 

  4863.   while (soap->plugins)
    4864. 

  4864.   { register struct soap_plugin *p = soap->plugins->next;
    4865. 

  4865.     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Removing plugin '%s'\n", soap->plugins->id));
    4866. 

  4866.     if (soap->plugins->fcopy || soap->state == SOAP_INIT)
    4867. 

  4867.       soap->plugins->fdelete(soap, soap->plugins);
    4868. 

  4868.     SOAP_FREE(soap, soap->plugins);
    4869. 

  4869.     soap->plugins = p;
    4870. 

  4870.   }
    4871. 

  4871.   soap->fplugin = fplugin;
    4872. 

  4872.   soap->fmalloc = NULL;
    4873. 

  4873. #ifndef WITH_NOHTTP
    4874. 

  4874.   soap->fpost = http_post;
    4875. 

  4875.   soap->fget = http_get;
    4876. 

  4876.   soap->fput = http_405;
    4877. 

  4877.   soap->fdel = http_405;
    4878. 

  4878.   soap->fhead = http_405;
    4879. 

  4879.   soap->fform = NULL;
    4880. 

  4880.   soap->fposthdr = http_post_header;
    4881. 

  4881.   soap->fresponse = http_response;
    4882. 

  4882.   soap->fparse = http_parse;
    4883. 

  4883.   soap->fparsehdr = http_parse_header;
    4884. 

  4884. #endif
    4885. 

  4885.   soap->fheader = NULL;
    4886. 

  4886. #ifndef WITH_NOIO
    4887. 

  4887. #ifndef WITH_IPV6
    4888. 

  4888.   soap->fresolve = tcp_gethost;
    4889. 

  4889. #else
    4890. 

  4890.   soap->fresolve = NULL;
    4891. 

  4891. #endif
    4892. 

  4892.   soap->faccept = tcp_accept;
    4893. 

  4893.   soap->fopen = tcp_connect;
    4894. 

  4894.   soap->fclose = tcp_disconnect;
    4895. 

  4895.   soap->fclosesocket = tcp_closesocket;
    4896. 

  4896.   soap->fshutdownsocket = tcp_shutdownsocket;
    4897. 

  4897.   soap->fsend = fsend;
    4898. 

  4898.   soap->frecv = frecv;
    4899. 

  4899.   soap->fpoll = soap_poll;
    4900. 

  4900. #else
    4901. 

  4901.   soap->fopen = NULL;
    4902. 

  4902.   soap->fclose = NULL;
    4903. 

  4903.   soap->fpoll = NULL;
    4904. 

  4904. #endif
    4905. 

  4905. #ifndef WITH_LEANER
    4906. 

  4906.   soap->fprepareinitsend = NULL;
    4907. 

  4907.   soap->fprepareinitrecv = NULL;
    4908. 

  4908.   soap->fpreparesend = NULL;
    4909. 

  4909.   soap->fpreparerecv = NULL;
    4910. 

  4910.   soap->fpreparefinalsend = NULL;
    4911. 

  4911.   soap->fpreparefinalrecv = NULL;
    4912. 

  4912. #endif
    4913. 

  4913.   soap->fseterror = NULL;
    4914. 

  4914.   soap->fignore = NULL;
    4915. 

  4915.   soap->fserveloop = NULL;
    4916. 

  4916. #ifdef WITH_OPENSSL
    4917. 

  4917.   if (soap->session)
    4918. 

  4918.   { SSL_SESSION_free(soap->session);
    4919. 

  4919.     soap->session = NULL;
    4920. 

  4920.   }
    4921. 

  4921. #endif
    4922. 

  4922.   if (soap->state == SOAP_INIT)
    4923. 

  4923.   { if (soap_valid_socket(soap->master))
    4924. 

  4924.     { soap->fclosesocket(soap, soap->master);
    4925. 

  4925.       soap->master = SOAP_INVALID_SOCKET;
    4926. 

  4926.     }
    4927. 

  4927.   }
    4928. 

  4928. #ifdef WITH_OPENSSL
    4929. 

  4929.   if (soap->ssl)
    4930. 

  4930.   { SSL_free(soap->ssl);
    4931. 

  4931.     soap->ssl = NULL;
    4932. 

  4932.   }
    4933. 

  4933.   if (soap->state == SOAP_INIT)
    4934. 

  4934.   { if (soap->ctx)
    4935. 

  4935.     { SSL_CTX_free(soap->ctx);
    4936. 

  4936.       soap->ctx = NULL;
    4937. 

  4937.     }
    4938. 

  4938.   }
    4939. 

  4939. #endif
    4940. 

  4940. #ifdef WITH_OPENSSL
    4941. 

  4941.   ERR_remove_state(0);
    4942. 

  4942. #endif
    4943. 

  4943. #ifdef WITH_C_LOCALE
    4944. 

  4944.   freelocale(soap->c_locale);
    4945. 

  4945. #endif
    4946. 

  4946. #ifdef WITH_ZLIB
    4947. 

  4947.   if (soap->d_stream)
    4948. 

  4948.   { SOAP_FREE(soap, (void*)soap->d_stream);
    4949. 

  4949.     soap->d_stream = NULL;
    4950. 

  4950.   }
    4951. 

  4951.   if (soap->z_buf)
    4952. 

  4952.   { SOAP_FREE(soap, (void*)soap->z_buf);
    4953. 

  4953.     soap->z_buf = NULL;
    4954. 

  4954.   }
    4955. 

  4955. #endif
    4956. 

  4956. #ifdef SOAP_DEBUG
    4957. 

  4957.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free logfiles\n"));
    4958. 

  4958.   for (i = 0; i < SOAP_MAXLOGS; i++)
    4959. 

  4959.   { if (soap->logfile[i])
    4960. 

  4960.     { SOAP_FREE(soap, (void*)soap->logfile[i]);
    4961. 

  4961.       soap->logfile[i] = NULL;
    4962. 

  4962.     }
    4963. 

  4963.     soap_close_logfile(soap, i);
    4964. 

  4964.   }
    4965. 

  4965.   soap->state = SOAP_NONE;
    4966. 

  4966. #endif
    4967. 

  4967. #ifdef SOAP_MEM_DEBUG
    4968. 

  4968.   soap_free_mht(soap);
    4969. 

  4969. #endif
    4970. 

  4970. }
    4971. 

  4971. #endif
    4972. 

  4972. 

  4973. /******************************************************************************\
    4974. 

  4974.  *
    4975. 

  4975.  *	HTTP
    4976. 

  4976.  *
    4977. 

  4977. \******************************************************************************/
    4978. 

  4978. 

  4979. /******************************************************************************/
    4980. 

  4980. #ifndef WITH_NOHTTP
    4981. 

  4981. #ifndef PALM_1
    4982. 

  4982. static int
    4983. 

  4983. http_parse(struct soap *soap)
    4984. 

  4984. { char header[SOAP_HDRLEN], *s;
    4985. 

  4985.   unsigned short httpcmd = 0, status = 0;
    4986. 

  4986.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Waiting for HTTP request/response...\n"));
    4987. 

  4987.   *soap->endpoint = '\0';
    4988. 

  4988.   soap->length = 0;
    4989. 

  4989.   soap->userid = NULL;
    4990. 

  4990.   soap->passwd = NULL;
    4991. 

  4991.   soap->action = NULL;
    4992. 

  4992.   soap->authrealm = NULL;
    4993. 

  4993.   soap->proxy_from = NULL;
    4994. 

  4994.   soap->http_content = NULL;
    4995. 

  4995.   soap->status = 0;
    4996. 

  4996.   do
    4997. 

  4997.   { if (soap_getline(soap, soap->msgbuf, sizeof(soap->msgbuf)))
    4998. 

  4998.     { if (soap->error == SOAP_EOF)
    4999. 

  4999.         return SOAP_EOF;
    5000. 

  5000.       return soap->error = 414;
    5001. 

  5001.     }
    5002. 

  5002.     if ((s = strchr(soap->msgbuf, ' ')))
    5003. 

  5003.     { soap->status = (unsigned short)soap_strtoul(s, &s, 10);
    5004. 

  5004.       if (!soap_blank(*s))
    5005. 

  5005.         soap->status = 0;
    5006. 

  5006.     }
    5007. 

  5007.     else
    5008. 

  5008.       soap->status = 0;
    5009. 

  5009.     DBGLOG(TEST,SOAP_MESSAGE(fdebug, "HTTP status: %s\n", soap->msgbuf));
    5010. 

  5010.     for (;;)
    5011. 

  5011.     { if (soap_getline(soap, header, SOAP_HDRLEN))
    5012. 

  5012.       { if (soap->error == SOAP_EOF)
    5013. 

  5013.         { soap->error = SOAP_OK;
    5014. 

  5014.           DBGLOG(TEST,SOAP_MESSAGE(fdebug, "EOF in HTTP header, continue anyway\n"));
    5015. 

  5015.           break;
    5016. 

  5016.         }
    5017. 

  5017.         return soap->error;
    5018. 

  5018.       }
    5019. 

  5019.       if (!*header)
    5020. 

  5020.         break;
    5021. 

  5021.       DBGLOG(TEST,SOAP_MESSAGE(fdebug, "HTTP header: %s\n", header));
    5022. 

  5022.       s = strchr(header, ':');
    5023. 

  5023.       if (s)
    5024. 

  5024.       { char *t;
    5025. 

  5025.         *s = '\0';
    5026. 

  5026.         do s++;
    5027. 

  5027.         while (*s && *s <= 32);
    5028. 

  5028.         if (*s == '"')
    5029. 

  5029.           s++;
    5030. 

  5030.         t = s + strlen(s) - 1;
    5031. 

  5031.         while (t > s && *t <= 32)
    5032. 

  5032.           t--;
    5033. 

  5033.         if (t >= s && *t == '"')
    5034. 

  5034.           t--;
    5035. 

  5035.         t[1] = '\0';
    5036. 

  5036.         if ((soap->error = soap->fparsehdr(soap, header, s)))
    5037. 

  5037.         { if (soap->error < SOAP_STOP)
    5038. 

  5038.             return soap->error;
    5039. 

  5039.           status = soap->error;
    5040. 

  5040.           soap->error = SOAP_OK;
    5041. 

  5041.         }
    5042. 

  5042.       }
    5043. 

  5043.     }
    5044. 

  5044.   } while (soap->status == 100);
    5045. 

  5045.   DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Finished HTTP header parsing, status = %d\n", soap->status));
    5046. 

  5046.   s = strstr(soap->msgbuf, "HTTP/");
    5047. 

  5047.   if (s && s[7] != '1')
    5048. 

  5048.   { if (soap->keep_alive == 1)
    5049. 

  5049.       soap->keep_alive = 0;
    5050. 

  5050.     if (soap->status == 0 && (soap->omode & SOAP_IO) == SOAP_IO_CHUNK) /* soap->status == 0 for HTTP request */
    5051. 

  5051.     { soap->imode |= SOAP_IO_CHUNK;
    5052. 

  5052.       soap->omode = (soap->omode & ~SOAP_IO) | SOAP_IO_STORE;
    5053. 

  5053.     }
    5054. 

  5054.   }
    5055. 

  5055.   if (soap->keep_alive < 0)
    5056. 

  5056.     soap->keep_alive = 1;
    5057. 

  5057.   DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Keep alive connection = %d\n", soap->keep_alive));
    5058. 

  5058.   if (soap->status == 0)
    5059. 

  5059.   { size_t l = 0;
    5060. 

  5060.     if (s)
    5061. 

  5061.     { if (!strncmp(soap->msgbuf, "POST ", l = 5))
    5062. 

  5062.         httpcmd = 1;
    5063. 

  5063.       else if (!strncmp(soap->msgbuf, "GET ", l = 4))
    5064. 

  5064.         httpcmd = 2;
    5065. 

  5065.       else if (!strncmp(soap->msgbuf, "PUT ", l = 4))
    5066. 

  5066.         httpcmd = 3;
    5067. 

  5067.       else if (!strncmp(soap->msgbuf, "DELETE ", l = 7))
    5068. 

  5068.         httpcmd = 4;
    5069. 

  5069.       else if (!strncmp(soap->msgbuf, "HEAD ", l = 5))
    5070. 

  5070.         httpcmd = 5;
    5071. 

  5071.     }
    5072. 

  5072.     if (s && httpcmd) 
    5073. 

  5073.     { size_t m = strlen(soap->endpoint);
    5074. 

  5074.       size_t n = m + (s - soap->msgbuf) - l - 1;
    5075. 

  5075.       if (m > n)
    5076. 

  5076.         m = n;
    5077. 

  5077.       if (n >= sizeof(soap->endpoint))
    5078. 

  5078.         n = sizeof(soap->endpoint) - 1;
    5079. 

  5079.       strncpy(soap->path, soap->msgbuf + l, n - m);
    5080. 

  5080.       soap->path[n - m] = '\0';
    5081. 

  5081.       strcat(soap->endpoint, soap->path);
    5082. 

  5082.       DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Target endpoint='%s'\n", soap->endpoint));
    5083. 

  5083.       if (httpcmd > 1)
    5084. 

  5084.       { switch (httpcmd)
    5085. 

  5085.         { case  2: soap->error = soap->fget(soap); break;
    5086. 

  5086.           case  3: soap->error = soap->fput(soap); break;
    5087. 

  5087.           case  4: soap->error = soap->fdel(soap); break;
    5088. 

  5088.           case  5: soap->error = soap->fhead(soap); break;
    5089. 

  5089. 	  default: soap->error = 405; break;
    5090. 

  5090. 	}
    5091. 

  5091.         if (soap->error == SOAP_OK)
    5092. 

  5092.           soap->error = SOAP_STOP; /* prevents further processing */
    5093. 

  5093.         return soap->error;
    5094. 

  5094.       }
    5095. 

  5095.       if (status)
    5096. 

  5096.         return soap->error = status;
    5097. 

  5097.     }
    5098. 

  5098.     else if (status)
    5099. 

  5099.       return soap->error = status;
    5100. 

  5100.     else if (s)
    5101. 

  5101.       return soap->error = 405;
    5102. 

  5102.   }
    5103. 

  5103.   /* Status OK (HTTP 200) */
    5104. 

  5104.   if (soap->status == 0 || soap->status == 200)
    5105. 

  5105.     return SOAP_OK;
    5106. 

  5106.   /* Status 201 (Created), 202 (Accepted), ... and HTTP 400 and 500 errors
    5107. 

  5107.      may not have a body. When content length, content type, or chunking is
    5108. 

  5108.      used assume there is a message to parse, either XML or HTTP.
    5109. 

  5109.   This version allows parsing of content when length=0:
    5110. 

  5110.   if (soap->length > 0 || soap->http_content || (soap->imode & SOAP_IO) == SOAP_IO_CHUNK)
    5111. 

  5111.   */
    5112. 

  5112.   if (soap->length > 0 || (soap->imode & SOAP_IO) == SOAP_IO_CHUNK)
    5113. 

  5113.   { if (((soap->status > 200 && soap->status <= 299) || soap->status == 400 || soap->status == 500))
    5114. 

  5114.       return SOAP_OK;
    5115. 

  5115.     /* force close afterwards in soap_closesock() */
    5116. 

  5116.     soap->keep_alive = 0;
    5117. 

  5117.     /* read HTTP body for error details */
    5118. 

  5118.     s = soap_get_http_body(soap);
    5119. 

  5119.     if (s)
    5120. 

  5120.       return soap_set_receiver_error(soap, soap->msgbuf, s, soap->status);
    5121. 

  5121.   }
    5122. 

  5122.   DBGLOG(TEST,SOAP_MESSAGE(fdebug, "HTTP error %d\n", soap->status));
    5123. 

  5123.   return soap_set_receiver_error(soap, "HTTP Error", soap->msgbuf, soap->status);
    5124. 

  5124. }
    5125. 

  5125. #endif
    5126. 

  5126. #endif
    5127. 

  5127. 

  5128. /******************************************************************************/
    5129. 

  5129. #ifndef WITH_NOHTTP
    5130. 

  5130. #ifndef PALM_1
    5131. 

  5131. static int
    5132. 

  5132. http_parse_header(struct soap *soap, const char *key, const char *val)
    5133. 

  5133. { if (!soap_tag_cmp(key, "Host"))
    5134. 

  5134.   { 
    5135. 

  5135. #ifdef WITH_OPENSSL
    5136. 

  5136.     if (soap->imode & SOAP_ENC_SSL)
    5137. 

  5137.       strcpy(soap->endpoint, "https://");
    5138. 

  5138.     else
    5139. 

  5139. #endif
    5140. 

  5140.       strcpy(soap->endpoint, "http://");
    5141. 

  5141.     strncat(soap->endpoint, val, sizeof(soap->endpoint) - 8);
    5142. 

  5142.     soap->endpoint[sizeof(soap->endpoint) - 1] = '\0';
    5143. 

  5143.   }
    5144. 

  5144. #ifndef WITH_LEANER
    5145. 

  5145.   else if (!soap_tag_cmp(key, "Content-Type"))
    5146. 

  5146.   { const char *action;
    5147. 

  5147.     soap->http_content = soap_strdup(soap, val);
    5148. 

  5148.     if (soap_get_header_attribute(soap, val, "application/dime"))
    5149. 

  5149.       soap->imode |= SOAP_ENC_DIME;
    5150. 

  5150.     else if (soap_get_header_attribute(soap, val, "multipart/related")
    5151. 

  5151.           || soap_get_header_attribute(soap, val, "multipart/form-data"))
    5152. 

  5152.     { soap->mime.boundary = soap_strdup(soap, soap_get_header_attribute(soap, val, "boundary"));
    5153. 

  5153.       soap->mime.start = soap_strdup(soap, soap_get_header_attribute(soap, val, "start"));
    5154. 

  5154.       soap->imode |= SOAP_ENC_MIME;
    5155. 

  5155.     }
    5156. 

  5156.     action = soap_get_header_attribute(soap, val, "action");
    5157. 

  5157.     if (action)
    5158. 

  5158.     { if (*action == '"')
    5159. 

  5159.       { soap->action = soap_strdup(soap, action + 1);
    5160. 

  5160.         soap->action[strlen(soap->action) - 1] = '\0';
    5161. 

  5161.       }
    5162. 

  5162.       else
    5163. 

  5163.         soap->action = soap_strdup(soap, action);
    5164. 

  5164.     }
    5165. 

  5165.   }
    5166. 

  5166. #endif
    5167. 

  5167.   else if (!soap_tag_cmp(key, "Content-Length"))
    5168. 

  5168.   { soap->length = soap_strtoul(val, NULL, 10);
    5169. 

  5169.   }
    5170. 

  5170.   else if (!soap_tag_cmp(key, "Content-Encoding"))
    5171. 

  5171.   { if (!soap_tag_cmp(val, "deflate"))
    5172. 

  5172. #ifdef WITH_ZLIB
    5173. 

  5173.       soap->zlib_in = SOAP_ZLIB_DEFLATE;
    5174. 

  5174. #else
    5175. 

  5175.       return SOAP_ZLIB_ERROR;
    5176. 

  5176. #endif
    5177. 

  5177.     else if (!soap_tag_cmp(val, "gzip"))
    5178. 

  5178. #ifdef WITH_GZIP
    5179. 

  5179.       soap->zlib_in = SOAP_ZLIB_GZIP;
    5180. 

  5180. #else
    5181. 

  5181.       return SOAP_ZLIB_ERROR;
    5182. 

  5182. #endif
    5183. 

  5183.   }
    5184. 

  5184. #ifdef WITH_ZLIB
    5185. 

  5185.   else if (!soap_tag_cmp(key, "Accept-Encoding"))
    5186. 

  5186.   {
    5187. 

  5187. #ifdef WITH_GZIP
    5188. 

  5188.     if (strchr(val, '*') || soap_get_header_attribute(soap, val, "gzip"))
    5189. 

  5189.       soap->zlib_out = SOAP_ZLIB_GZIP;
    5190. 

  5190.     else
    5191. 

  5191. #endif
    5192. 

  5192.     if (strchr(val, '*') || soap_get_header_attribute(soap, val, "deflate"))
    5193. 

  5193.       soap->zlib_out = SOAP_ZLIB_DEFLATE;
    5194. 

  5194.     else
    5195. 

  5195.       soap->zlib_out = SOAP_ZLIB_NONE;
    5196. 

  5196.   }
    5197. 

  5197. #endif
    5198. 

  5198.   else if (!soap_tag_cmp(key, "Transfer-Encoding"))
    5199. 

  5199.   { soap->imode &= ~SOAP_IO;
    5200. 

  5200.     if (!soap_tag_cmp(val, "chunked"))
    5201. 

  5201.       soap->imode |= SOAP_IO_CHUNK;
    5202. 

  5202.   }
    5203. 

  5203.   else if (!soap_tag_cmp(key, "Connection"))
    5204. 

  5204.   { if (!soap_tag_cmp(val, "keep-alive"))
    5205. 

  5205.       soap->keep_alive = -soap->keep_alive;
    5206. 

  5206.     else if (!soap_tag_cmp(val, "close"))
    5207. 

  5207.       soap->keep_alive = 0;
    5208. 

  5208.   }
    5209. 

  5209. #ifndef WITH_LEAN
    5210. 

  5210.   else if (!soap_tag_cmp(key, "Authorization"))
    5211. 

  5211.   { if (!soap_tag_cmp(val, "Basic *"))
    5212. 

  5212.     { int n;
    5213. 

  5213.       char *s;
    5214. 

  5214.       soap_base642s(soap, val + 6, soap->tmpbuf, sizeof(soap->tmpbuf) - 1, &n);
    5215. 

  5215.       soap->tmpbuf[n] = '\0';
    5216. 

  5216.       if ((s = strchr(soap->tmpbuf, ':')))
    5217. 

  5217.       { *s = '\0';
    5218. 

  5218.         soap->userid = soap_strdup(soap, soap->tmpbuf);
    5219. 

  5219.         soap->passwd = soap_strdup(soap, s + 1);
    5220. 

  5220.       }
    5221. 

  5221.     }
    5222. 

  5222.   }
    5223. 

  5223.   else if (!soap_tag_cmp(key, "WWW-Authenticate"))
    5224. 

  5224.   { soap->authrealm = soap_strdup(soap, soap_get_header_attribute(soap, val + 6, "realm"));
    5225. 

  5225.   }
    5226. 

  5226.   else if (!soap_tag_cmp(key, "Expect"))
    5227. 

  5227.   { if (!soap_tag_cmp(val, "100-continue"))
    5228. 

  5228.     { if ((soap->error = soap->fposthdr(soap, "HTTP/1.1 100 Continue", NULL))
    5229. 

  5229.        || (soap->error = soap->fposthdr(soap, NULL, NULL)))
    5230. 

  5230.         return soap->error;
    5231. 

  5231.     }
    5232. 

  5232.   }
    5233. 

  5233. #endif
    5234. 

  5234.   else if (!soap_tag_cmp(key, "SOAPAction"))
    5235. 

  5235.   { if (*val == '"')
    5236. 

  5236.     { soap->action = soap_strdup(soap, val + 1);
    5237. 

  5237.       soap->action[strlen(soap->action) - 1] = '\0';
    5238. 

  5238.     }
    5239. 

  5239.     else
    5240. 

  5240.       soap->action = soap_strdup(soap, val);
    5241. 

  5241.   }
    5242. 

  5242.   else if (!soap_tag_cmp(key, "Location"))
    5243. 

  5243.   { strncpy(soap->endpoint, val, sizeof(soap->endpoint));
    5244. 

  5244.     soap->endpoint[sizeof(soap->endpoint) - 1] = '\0';
    5245. 

  5245.   }
    5246. 

  5246.   else if (!soap_tag_cmp(key, "X-Forwarded-For"))
    5247. 

  5247.   { soap->proxy_from = soap_strdup(soap, val);
    5248. 

  5248.   }
    5249. 

  5249. #ifdef WITH_COOKIES
    5250. 

  5250.   else if (!soap_tag_cmp(key, "Cookie")
    5251. 

  5251.    || !soap_tag_cmp(key, "Cookie2")
    5252. 

  5252.    || !soap_tag_cmp(key, "Set-Cookie")
    5253. 

  5253.    || !soap_tag_cmp(key, "Set-Cookie2"))
    5254. 

  5254.   { soap_getcookies(soap, val);
    5255. 

  5255.   }
    5256. 

  5256. #endif
    5257. 

  5257.   return SOAP_OK;
    5258. 

  5258. }
    5259. 

  5259. #endif
    5260. 

  5260. #endif
    5261. 

  5261. 

  5262. /******************************************************************************/
    5263. 

  5263. #if !defined(WITH_NOHTTP) || !defined(WITH_LEANER)
    5264. 

  5264. #ifndef PALM_1
    5265. 

  5265. SOAP_FMAC1
    5266. 

  5266. const char*
    5267. 

  5267. SOAP_FMAC2
    5268. 

  5268. soap_get_header_attribute(struct soap *soap, const char *line, const char *key)
    5269. 

  5269. { register const char *s = line;
    5270. 

  5270.   if (s)
    5271. 

  5271.   { while (*s)
    5272. 

  5272.     { register short flag;
    5273. 

  5273.       s = soap_decode_key(soap->tmpbuf, sizeof(soap->tmpbuf), s);
    5274. 

  5274.       flag = soap_tag_cmp(soap->tmpbuf, key);
    5275. 

  5275.       s = soap_decode_val(soap->tmpbuf, sizeof(soap->tmpbuf), s);
    5276. 

  5276.       if (!flag)
    5277. 

  5277.         return soap->tmpbuf;
    5278. 

  5278.     }
    5279. 

  5279.   }
    5280. 

  5280.   return NULL;
    5281. 

  5281. }
    5282. 

  5282. #endif
    5283. 

  5283. #endif
    5284. 

  5284. 

  5285. /******************************************************************************/
    5286. 

  5286. #if !defined(WITH_NOHTTP) || !defined(WITH_LEANER)
    5287. 

  5287. #ifndef PALM_1
    5288. 

  5288. SOAP_FMAC1
    5289. 

  5289. const char*
    5290. 

  5290. SOAP_FMAC2
    5291. 

  5291. soap_decode_key(char *buf, size_t len, const char *val)
    5292. 

  5292. { return soap_decode(buf, len, val, "=,;");
    5293. 

  5293. }
    5294. 

  5294. #endif
    5295. 

  5295. #endif
    5296. 

  5296. 

  5297. /******************************************************************************/
    5298. 

  5298. #if !defined(WITH_NOHTTP) || !defined(WITH_LEANER)
    5299. 

  5299. #ifndef PALM_1
    5300. 

  5300. SOAP_FMAC1
    5301. 

  5301. const char*
    5302. 

  5302. SOAP_FMAC2
    5303. 

  5303. soap_decode_val(char *buf, size_t len, const char *val)
    5304. 

  5304. { if (*val != '=')
    5305. 

  5305.   { *buf = '\0';
    5306. 

  5306.     return val;
    5307. 

  5307.   }
    5308. 

  5308.   return soap_decode(buf, len, val + 1, ",;");
    5309. 

  5309. }
    5310. 

  5310. #endif
    5311. 

  5311. #endif
    5312. 

  5312. 

  5313. /******************************************************************************/
    5314. 

  5314. #if !defined(WITH_NOHTTP) || !defined(WITH_LEANER)
    5315. 

  5315. #ifndef PALM_1
    5316. 

  5316. static const char*
    5317. 

  5317. soap_decode(char *buf, size_t len, const char *val, const char *sep)
    5318. 

  5318. { const char *s;
    5319. 

  5319.   char *t = buf;
    5320. 

  5320.   for (s = val; *s; s++)
    5321. 

  5321.     if (*s != ' ' && *s != '\t' && !strchr(sep, *s))
    5322. 

  5322.       break;
    5323. 

  5323.   if (*s == '"')
    5324. 

  5324.   { s++;
    5325. 

  5325.     while (*s && *s != '"' && --len)
    5326. 

  5326.       *t++ = *s++;
    5327. 

  5327.   }
    5328. 

  5328.   else
    5329. 

  5329.   { while (*s && !soap_blank(*s) && !strchr(sep, *s) && --len)
    5330. 

  5330.     { if (*s == '%')
    5331. 

  5331.       { *t++ = ((s[1] >= 'A' ? (s[1] & 0x7) + 9 : s[1] - '0') << 4)
    5332. 

  5332.               + (s[2] >= 'A' ? (s[2] & 0x7) + 9 : s[2] - '0');
    5333. 

  5333.         s += 3;
    5334. 

  5334.       }
    5335. 

  5335.       else
    5336. 

  5336.         *t++ = *s++;
    5337. 

  5337.     }
    5338. 

  5338.   }
    5339. 

  5339.   *t = '\0';
    5340. 

  5340.   while (*s && !strchr(sep, *s))
    5341. 

  5341.     s++;
    5342. 

  5342.   return s;
    5343. 

  5343. }
    5344. 

  5344. #endif
    5345. 

  5345. #endif
    5346. 

  5346. 

  5347. /******************************************************************************/
    5348. 

  5348. #ifndef WITH_NOHTTP
    5349. 

  5349. #ifndef PALM_1
    5350. 

  5350. static const char*
    5351. 

  5351. http_error(struct soap *soap, int status)
    5352. 

  5352. { register const char *msg = SOAP_STR_EOS;
    5353. 

  5353. #ifndef WITH_LEAN
    5354. 

  5354.   msg = soap_code_str(h_http_error_codes, status);
    5355. 

  5355.   if (!msg)
    5356. 

  5356.     msg = SOAP_STR_EOS;
    5357. 

  5357. #endif
    5358. 

  5358.   return msg;
    5359. 

  5359. }
    5360. 

  5360. #endif
    5361. 

  5361. #endif
    5362. 

  5362. 

  5363. /******************************************************************************/
    5364. 

  5364. #ifndef WITH_NOHTTP
    5365. 

  5365. #ifndef PALM_1
    5366. 

  5366. static int
    5367. 

  5367. http_get(struct soap *soap)
    5368. 

  5368. { return SOAP_GET_METHOD;
    5369. 

  5369. }
    5370. 

  5370. #endif
    5371. 

  5371. #endif
    5372. 

  5372. 

  5373. /******************************************************************************/
    5374. 

  5374. #ifndef WITH_NOHTTP
    5375. 

  5375. #ifndef PALM_1
    5376. 

  5376. static int
    5377. 

  5377. http_405(struct soap *soap)
    5378. 

  5378. { return 405;
    5379. 

  5379. }
    5380. 

  5380. #endif
    5381. 

  5381. #endif
    5382. 

  5382. 

  5383. /******************************************************************************/
    5384. 

  5384. #ifndef WITH_NOHTTP
    5385. 

  5385. #ifndef PALM_1
    5386. 

  5386. static int
    5387. 

  5387. http_post(struct soap *soap, const char *endpoint, const char *host, int port, const char *path, const char *action, size_t count)
    5388. 

  5388. { register const char *s;
    5389. 

  5389.   register int err;
    5390. 

  5390.   if (soap->status == SOAP_GET)
    5391. 

  5391.     s = "GET";
    5392. 

  5392.   else
    5393. 

  5393.     s = "POST";
    5394. 

  5394. #ifdef PALM
    5395. 

  5395.   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))
    5396. 

  5396. #else
    5397. 

  5397.   if (!endpoint || (soap_tag_cmp(endpoint, "http:*") && soap_tag_cmp(endpoint, "https:*") && strncmp(endpoint, "httpg:", 6)))
    5398. 

  5398. #endif
    5399. 

  5399.     return SOAP_OK;
    5400. 

  5400.   if (strlen(endpoint) + strlen(soap->http_version) > sizeof(soap->tmpbuf) - 80)
    5401. 

  5401.     return soap->error = SOAP_EOM;
    5402. 

  5402.   if (soap->proxy_host && soap_tag_cmp(endpoint, "https:*"))
    5403. 

  5403.     sprintf(soap->tmpbuf, "%s %s HTTP/%s", s, endpoint, soap->http_version);
    5404. 

  5404.   else
    5405. 

  5405.     sprintf(soap->tmpbuf, "%s /%s HTTP/%s", s, (*path == '/' ? path + 1 : path), soap->http_version);
    5406. 

  5406.   if ((err = soap->fposthdr(soap, soap->tmpbuf, NULL)))
    5407. 

  5407.     return err;
    5408. 

  5408. #ifdef WITH_OPENSSL
    5409. 

  5409.   if ((soap->ssl && soap->port != 443) || (!soap->ssl && soap->port != 80))
    5410. 

  5410.     sprintf(soap->tmpbuf, "%s:%d", host, port);
    5411. 

  5411.   else
    5412. 

  5412.     strcpy(soap->tmpbuf, host); 
    5413. 

  5413. #else
    5414. 

  5414.   if (port != 80)
    5415. 

  5415.     sprintf(soap->tmpbuf, "%s:%d", host, port);
    5416. 

  5416.   else
    5417. 

  5417.   {  /* Oracle customization */
    5418. 

  5418.     strncpy(soap->tmpbuf, host, sizeof(soap->tmpbuf) - 1);
    5419. 

  5419.     soap->tmpbuf[sizeof(soap->tmpbuf) - 1] = '\0';
    5420. 

  5420.   }
    5421. 

  5421. #endif
    5422. 

  5422. // Oracle customization
    5423. 

  5423.   if ((err = soap->fposthdr(soap, "Host", soap->tmpbuf))
    5424. 

  5424.    || (err = soap->fposthdr(soap, "User-Agent", "SunKMS gSOAP/2.7.17"))
    5425. 

  5425.    || (err = soap_puthttphdr(soap, SOAP_OK, count)))
    5426. 

  5426.     return err;
    5427. 

  5427. #ifdef WITH_ZLIB
    5428. 

  5428. #ifdef WITH_GZIP
    5429. 

  5429.   if ((err = soap->fposthdr(soap, "Accept-Encoding", "gzip, deflate")))
    5430. 

  5430. #else
    5431. 

  5431.   if ((err = soap->fposthdr(soap, "Accept-Encoding", "deflate")))
    5432. 

  5432. #endif
    5433. 

  5433.     return err;
    5434. 

  5434. #endif
    5435. 

  5435. #ifndef WITH_LEAN
    5436. 

  5436.   if (soap->userid && soap->passwd && strlen(soap->userid) + strlen(soap->passwd) < 761)
    5437. 

  5437.   { sprintf(soap->tmpbuf + 262, "%s:%s", soap->userid, soap->passwd);
    5438. 

  5438.     strcpy(soap->tmpbuf, "Basic ");
    5439. 

  5439.     soap_s2base64(soap, (const unsigned char*)(soap->tmpbuf + 262), soap->tmpbuf + 6, (int)strlen(soap->tmpbuf + 262));
    5440. 

  5440.     if ((err = soap->fposthdr(soap, "Authorization", soap->tmpbuf)))
    5441. 

  5441.       return err;
    5442. 

  5442.   }
    5443. 

  5443.   if (soap->proxy_userid && soap->proxy_passwd && strlen(soap->proxy_userid) + strlen(soap->proxy_passwd) < 761)
    5444. 

  5444.   { sprintf(soap->tmpbuf + 262, "%s:%s", soap->proxy_userid, soap->proxy_passwd);
    5445. 

  5445.     strcpy(soap->tmpbuf, "Basic ");
    5446. 

  5446.     soap_s2base64(soap, (const unsigned char*)(soap->tmpbuf + 262), soap->tmpbuf + 6, (int)strlen(soap->tmpbuf + 262));
    5447. 

  5447.     if ((err = soap->fposthdr(soap, "Proxy-Authorization", soap->tmpbuf)))
    5448. 

  5448.       return err;
    5449. 

  5449.   }
    5450. 

  5450. #endif
    5451. 

  5451. #ifdef WITH_COOKIES
    5452. 

  5452. #ifdef WITH_OPENSSL
    5453. 

  5453.   if (soap_putcookies(soap, host, path, soap->ssl != NULL))
    5454. 

  5454.     return soap->error;
    5455. 

  5455. #else
    5456. 

  5456.   if (soap_putcookies(soap, host, path, 0))
    5457. 

  5457.     return soap->error;
    5458. 

  5458. #endif
    5459. 

  5459. #endif
    5460. 

  5460.   if (soap->status != SOAP_GET && (soap->version == 1 || (action && *action)))
    5461. 

  5461.   { sprintf(soap->tmpbuf, "\"%s\"", action && strlen(action) < sizeof(soap->tmpbuf) - 3 ? action : SOAP_STR_EOS);
    5462. 

  5462.     if ((err = soap->fposthdr(soap, "SOAPAction", soap->tmpbuf)))
    5463. 

  5463.       return err;
    5464. 

  5464.   }
    5465. 

  5465.   return soap->fposthdr(soap, NULL, NULL);
    5466. 

  5466. }
    5467. 

  5467. #endif
    5468. 

  5468. #endif
    5469. 

  5469. 

  5470. /******************************************************************************/
    5471. 

  5471. #ifndef WITH_NOHTTP
    5472. 

  5472. #ifndef PALM_1
    5473. 

  5473. static int
    5474. 

  5474. http_send_header(struct soap *soap, const char *s)
    5475. 

  5475. { register const char *t;
    5476. 

  5476.   do
    5477. 

  5477.   { t = strchr(s, '\n'); /* disallow \n in HTTP headers */
    5478. 

  5478.     if (!t)
    5479. 

  5479.       t = s + strlen(s);
    5480. 

  5480.     if (soap_send_raw(soap, s, t - s))
    5481. 

  5481.       return soap->error;
    5482. 

  5482.     s = t + 1;
    5483. 

  5483.   } while (*t);
    5484. 

  5484.   return SOAP_OK;
    5485. 

  5485. }
    5486. 

  5486. #endif
    5487. 

  5487. #endif
    5488. 

  5488. 

  5489. /******************************************************************************/
    5490. 

  5490. #ifndef WITH_NOHTTP
    5491. 

  5491. #ifndef PALM_1
    5492. 

  5492. static int
    5493. 

  5493. http_post_header(struct soap *soap, const char *key, const char *val)
    5494. 

  5494. { if (key)
    5495. 

  5495.   { if (http_send_header(soap, key))
    5496. 

  5496.       return soap->error;
    5497. 

  5497.     if (val && (soap_send_raw(soap, ": ", 2) || http_send_header(soap, val)))
    5498. 

  5498.       return soap->error;
    5499. 

  5499.   }
    5500. 

  5500.   return soap_send_raw(soap, "\r\n", 2);
    5501. 

  5501. }
    5502. 

  5502. #endif
    5503. 

  5503. #endif
    5504. 

  5504. 

  5505. /******************************************************************************/
    5506. 

  5506. #ifndef WITH_NOHTTP
    5507. 

  5507. #ifndef PALM_1
    5508. 

  5508. static int
    5509. 

  5509. http_response(struct soap *soap, int status, size_t count)
    5510. 

  5510. { register int err;
    5511. 

  5511. #ifdef WMW_RPM_IO
    5512. 

  5512.   if (soap->rpmreqid)
    5513. 

  5513.     httpOutputEnable(soap->rpmreqid);
    5514. 

  5514. #endif
    5515. 

  5515.   if (strlen(soap->http_version) > 4)
    5516. 

  5516.     return soap->error = SOAP_EOM;
    5517. 

  5517.   if (!status || status == SOAP_HTML || status == SOAP_FILE)
    5518. 

  5518.   { const char *s;
    5519. 

  5519.     if (count || ((soap->omode & SOAP_IO) == SOAP_IO_CHUNK))
    5520. 

  5520.       s = "200 OK";
    5521. 

  5521.     else
    5522. 

  5522.       s = "202 ACCEPTED";
    5523. 

  5523.     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Status = %s\n", s));
    5524. 

  5524. #ifdef WMW_RPM_IO
    5525. 

  5525.     if (soap->rpmreqid || soap_valid_socket(soap->master) || soap_valid_socket(soap->socket)) /* RPM behaves as if standalone */
    5526. 

  5526. #else
    5527. 

  5527.     if (soap_valid_socket(soap->master) || soap_valid_socket(soap->socket)) /* standalone application (socket) or CGI (stdin/out)? */
    5528. 

  5528. #endif
    5529. 

  5529.     { sprintf(soap->tmpbuf, "HTTP/%s %s", soap->http_version, s);
    5530. 

  5530.       if ((err = soap->fposthdr(soap, soap->tmpbuf, NULL)))
    5531. 

  5531.         return err;
    5532. 

  5532.     }
    5533. 

  5533.     else if ((err = soap->fposthdr(soap, "Status", s))) /* CGI header */
    5534. 

  5534.       return err;
    5535. 

  5535.   }
    5536. 

  5536.   else if (status >= 200 && status < 600)
    5537. 

  5537.   { sprintf(soap->tmpbuf, "HTTP/%s %d %s", soap->http_version, status, http_error(soap, status));
    5538. 

  5538.     if ((err = soap->fposthdr(soap, soap->tmpbuf, NULL)))
    5539. 

  5539.       return err;
    5540. 

  5540. #ifndef WITH_LEAN 
    5541. 

  5541.     if (status == 401)
    5542. 

  5542.     { sprintf(soap->tmpbuf, "Basic realm=\"%s\"", (soap->authrealm && strlen(soap->authrealm) < sizeof(soap->tmpbuf) - 14) ? soap->authrealm : "gSOAP Web Service");
    5543. 

  5543.       if ((err = soap->fposthdr(soap, "WWW-Authenticate", soap->tmpbuf)))
    5544. 

  5544.         return err;
    5545. 

  5545.     }
    5546. 

  5546.     else if ((status >= 301 && status <= 303) || status == 307)
    5547. 

  5547.     { if ((err = soap->fposthdr(soap, "Location", soap->endpoint)))
    5548. 

  5548.         return err;
    5549. 

  5549.     }
    5550. 

  5550. #endif
    5551. 

  5551.   }
    5552. 

  5552.   else
    5553. 

  5553.   { const char *s = *soap_faultcode(soap);
    5554. 

  5554.     if (status >= SOAP_GET_METHOD && status <= SOAP_HTTP_METHOD)
    5555. 

  5555.       s = "405 Method Not Allowed";
    5556. 

  5556.     else if (soap->version == 2 && (!s || !strcmp(s, "SOAP-ENV:Sender")))
    5557. 

  5557.       s = "400 Bad Request";
    5558. 

  5558.     else
    5559. 

  5559.       s = "500 Internal Server Error";
    5560. 

  5560.     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Error %s (status=%d)\n", s, status));
    5561. 

  5561. #ifdef WMW_RPM_IO
    5562. 

  5562.     if (soap->rpmreqid || soap_valid_socket(soap->master) || soap_valid_socket(soap->socket)) /* RPM behaves as if standalone */
    5563. 

  5563. #else
    5564. 

  5564.     if (soap_valid_socket(soap->master) || soap_valid_socket(soap->socket)) /* standalone application */
    5565. 

  5565. #endif
    5566. 

  5566.     { sprintf(soap->tmpbuf, "HTTP/%s %s", soap->http_version, s);
    5567. 

  5567.       if ((err = soap->fposthdr(soap, soap->tmpbuf, NULL)))
    5568. 

  5568.         return err;
    5569. 

  5569.     }
    5570. 

  5570.     else if ((err = soap->fposthdr(soap, "Status", s)))	/* CGI */
    5571. 

  5571.       return err;
    5572. 

  5572.   }
    5573. 

  5573.   if ((err = soap->fposthdr(soap, "Server", "gSOAP/2.7"))
    5574. 

  5574.    || (err = soap_puthttphdr(soap, status, count)))
    5575. 

  5575.     return err;
    5576. 

  5576. #ifdef WITH_COOKIES
    5577. 

  5577.   if (soap_putsetcookies(soap))
    5578. 

  5578.     return soap->error;
    5579. 

  5579. #endif
    5580. 

  5580.   return soap->fposthdr(soap, NULL, NULL);
    5581. 

  5581. }
    5582. 

  5582. #endif
    5583. 

  5583. #endif
    5584. 

  5584. 

  5585. /******************************************************************************/
    5586. 

  5586. #ifndef PALM_1
    5587. 

  5587. SOAP_FMAC1
    5588. 

  5588. int
    5589. 

  5589. SOAP_FMAC2
    5590. 

  5590. soap_response(struct soap *soap, int status)
    5591. 

  5591. { register size_t count;
    5592. 

  5592.   if (!(soap->omode & (SOAP_ENC_XML | SOAP_IO_STORE /* this tests for chunking too */))
    5593. 

  5593.    && (status == SOAP_HTML || status == SOAP_FILE))
    5594. 

  5594.     soap->omode = (soap->omode & ~SOAP_IO) | SOAP_IO_STORE;
    5595. 

  5595.   soap->status = status;
    5596. 

  5596.   count = soap_count_attachments(soap);
    5597. 

  5597.   if (soap_begin_send(soap))
    5598. 

  5598.     return soap->error;
    5599. 

  5599. #ifndef WITH_NOHTTP
    5600. 

  5600.   if ((soap->mode & SOAP_IO) != SOAP_IO_STORE && !(soap->mode & SOAP_ENC_XML))
    5601. 

  5601.   { register int n = soap->mode;
    5602. 

  5602.     soap->mode &= ~(SOAP_IO | SOAP_ENC_ZLIB);
    5603. 

  5603.     if ((n & SOAP_IO) != SOAP_IO_FLUSH)
    5604. 

  5604.       soap->mode |= SOAP_IO_BUFFER;
    5605. 

  5605.     if ((soap->error = soap->fresponse(soap, status, count)))
    5606. 

  5606.       return soap->error;
    5607. 

  5607. #ifndef WITH_LEANER
    5608. 

  5608.     if ((n & SOAP_IO) == SOAP_IO_CHUNK)
    5609. 

  5609.     { if (soap_flush(soap))
    5610. 

  5610.         return soap->error;
    5611. 

  5611.     }
    5612. 

  5612. #endif
    5613. 

  5613.     soap->mode = n;
    5614. 

  5614.   }
    5615. 

  5615. #endif
    5616. 

  5616.   return SOAP_OK;
    5617. 

  5617. }
    5618. 

  5618. #endif
    5619. 

  5619. 

  5620. /******************************************************************************\
    5621. 

  5621.  *
    5622. 

  5622.  *	HTTP Cookies
    5623. 

  5623.  *
    5624. 

  5624. \******************************************************************************/
    5625. 

  5625. 

  5626. #ifdef WITH_COOKIES
    5627. 

  5627. /******************************************************************************/
    5628. 

  5628. SOAP_FMAC1
    5629. 

  5629. size_t
    5630. 

  5630. SOAP_FMAC2
    5631. 

  5631. soap_encode_cookie(const char *s, char *t, size_t len)
    5632. 

  5632. { register int c;
    5633. 

  5633.   register size_t n = len;
    5634. 

  5634.   while ((c = *s++) && --n > 0)
    5635. 

  5635.   { if (c > ' ' && c < 128 && !strchr("()<>@,;:\\\"/[]?={}#!$&'*+", c))
    5636. 

  5636.       *t++ = c;
    5637. 

  5637.     else if (n > 2)
    5638. 

  5638.     { *t++ = '%';
    5639. 

  5639.       *t++ = (c >> 4) + (c > 159 ? '7' : '0');
    5640. 

  5640.       c &= 0xF;
    5641. 

  5641.       *t++ = c + (c > 9 ? '7' : '0');
    5642. 

  5642.       n -= 2;
    5643. 

  5643.     }
    5644. 

  5644.     else
    5645. 

  5645.       break;
    5646. 

  5646.   }
    5647. 

  5647.   *t = '\0';
    5648. 

  5648.   return len - n;
    5649. 

  5649. }
    5650. 

  5650. 

  5651. /******************************************************************************/
    5652. 

  5652. SOAP_FMAC1
    5653. 

  5653. struct soap_cookie*
    5654. 

  5654. SOAP_FMAC2
    5655. 

  5655. soap_cookie(struct soap *soap, const char *name, const char *domain, const char *path)
    5656. 

  5656. { struct soap_cookie *p;
    5657. 

  5657.   if (!domain)
    5658. 

  5658.     domain = soap->cookie_domain;
    5659. 

  5659.   if (!path)
    5660. 

  5660.     path = soap->cookie_path;
    5661. 

  5661.   if (!path)
    5662. 

  5662.     path = SOAP_STR_EOS;
    5663. 

  5663.   else if (*path == '/')
    5664. 

  5664.     path++;
    5665. 

  5665.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Search cookie %s domain=%s path=%s\n", name, domain?domain:"(null)", path?path:"(null)"));
    5666. 

  5666.   for (p = soap->cookies; p; p = p->next)
    5667. 

  5667.   { 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));
    5668. 

  5668.     if (!strcmp(p->name, name)
    5669. 

  5669.      && p->domain
    5670. 

  5670.      && p->path
    5671. 

  5671.      && !strcmp(p->domain, domain)
    5672. 

  5672.      && (!*p->path || !strncmp(p->path, path, strlen(p->path))))
    5673. 

  5673.       break;
    5674. 

  5674.   }
    5675. 

  5675.   return p;
    5676. 

  5676. }
    5677. 

  5677. 

  5678. /******************************************************************************/
    5679. 

  5679. SOAP_FMAC1
    5680. 

  5680. struct soap_cookie*
    5681. 

  5681. SOAP_FMAC2
    5682. 

  5682. soap_set_cookie(struct soap *soap, const char *name, const char *value, const char *domain, const char *path)
    5683. 

  5683. { struct soap_cookie **p, *q;
    5684. 

  5684.   int n;
    5685. 

  5685.   if (!domain)
    5686. 

  5686.     domain = soap->cookie_domain;
    5687. 

  5687.   if (!path)
    5688. 

  5688.     path = soap->cookie_path;
    5689. 

  5689.   if (!path)
    5690. 

  5690.     path = SOAP_STR_EOS;
    5691. 

  5691.   else if (*path == '/')
    5692. 

  5692.     path++;
    5693. 

  5693.   q = soap_cookie(soap, name, domain, path);
    5694. 

  5694.   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)"));
    5695. 

  5695.   if (!q)
    5696. 

  5696.   { if ((q = (struct soap_cookie*)SOAP_MALLOC(soap, sizeof(struct soap_cookie))))
    5697. 

  5697.     { if ((q->name = (char*)SOAP_MALLOC(soap, strlen(name)+1)))
    5698. 

  5698.         strcpy(q->name, name);
    5699. 

  5699.       q->value = NULL;
    5700. 

  5700.       q->domain = NULL;
    5701. 

  5701.       q->path = NULL;
    5702. 

  5702.       q->expire = 0;
    5703. 

  5703.       q->maxage = -1;
    5704. 

  5704.       q->version = 1;
    5705. 

  5705.       q->secure = 0;
    5706. 

  5706.       q->modified = 0;
    5707. 

  5707.       for (p = &soap->cookies, n = soap->cookie_max; *p && n; p = &(*p)->next, n--)
    5708. 

  5708.         if (!strcmp((*p)->name, name) && (*p)->path && path && strcmp((*p)->path, path) < 0)
    5709. 

  5709.           break;
    5710. 

  5710.       if (n)
    5711. 

  5711.       { q->next = *p;
    5712. 

  5712.         *p = q;
    5713. 

  5713.       }
    5714. 

  5714.       else
    5715. 

  5715.       { SOAP_FREE(soap, q->name);
    5716. 

  5716.         SOAP_FREE(soap, q);
    5717. 

  5717.         q = NULL;
    5718. 

  5718.       }
    5719. 

  5719.     }
    5720. 

  5720.   }
    5721. 

  5721.   else
    5722. 

  5722.     q->modified = 1;
    5723. 

  5723.   if (q)
    5724. 

  5724.   { if (q->value)
    5725. 

  5725.     { if (!value || strcmp(value, q->value))
    5726. 

  5726.       { SOAP_FREE(soap, q->value);
    5727. 

  5727.         q->value = NULL;
    5728. 

  5728.       }
    5729. 

  5729.     }
    5730. 

  5730.     if (value && *value && !q->value && (q->value = (char*)SOAP_MALLOC(soap, strlen(value)+1)))
    5731. 

  5731.       strcpy(q->value, value);
    5732. 

  5732.     if (q->domain)
    5733. 

  5733.     { if (!domain || strcmp(domain, q->domain))
    5734. 

  5734.       { SOAP_FREE(soap, q->domain);
    5735. 

  5735.         q->domain = NULL;
    5736. 

  5736.       }
    5737. 

  5737.     }
    5738. 

  5738.     if (domain && !q->domain && (q->domain = (char*)SOAP_MALLOC(soap, strlen(domain)+1)))
    5739. 

  5739.       strcpy(q->domain, domain);
    5740. 

  5740.     if (q->path)
    5741. 

  5741.     { if (!path || strncmp(path, q->path, strlen(q->path)))
    5742. 

  5742.       { SOAP_FREE(soap, q->path);
    5743. 

  5743.         q->path = NULL;
    5744. 

  5744.       }
    5745. 

  5745.     }
    5746. 

  5746.     if (path && !q->path && (q->path = (char*)SOAP_MALLOC(soap, strlen(path)+1)))
    5747. 

  5747.       strcpy(q->path, path);
    5748. 

  5748.     q->session = 1;
    5749. 

  5749.     q->env = 0;
    5750. 

  5750.   }
    5751. 

  5751.   return q;
    5752. 

  5752. }
    5753. 

  5753. 

  5754. /******************************************************************************/
    5755. 

  5755. SOAP_FMAC1
    5756. 

  5756. void
    5757. 

  5757. SOAP_FMAC2
    5758. 

  5758. soap_clr_cookie(struct soap *soap, const char *name, const char *domain, const char *path)
    5759. 

  5759. { struct soap_cookie **p, *q;
    5760. 

  5760.   if (!domain)
    5761. 

  5761.     domain = soap->cookie_domain;
    5762. 

  5762.   if (!domain)
    5763. 

  5763.   { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Error in clear cookie %s: cookie domain not set\n", name?name:"(null)"));
    5764. 

  5764.     return;
    5765. 

  5765.   }
    5766. 

  5766.   if (!path)
    5767. 

  5767.     path = soap->cookie_path;
    5768. 

  5768.   if (!path)
    5769. 

  5769.   { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Error in clear cookie %s: cookie path not set\n", name?name:"(null)"));
    5770. 

  5770.     return;
    5771. 

  5771.   }
    5772. 

  5772.   if (*path == '/')
    5773. 

  5773.     path++;
    5774. 

  5774.   for (p = &soap->cookies, q = *p; q; q = *p)
    5775. 

  5775.   { if (!strcmp(q->name, name) && !strcmp(q->domain, domain) && !strncmp(q->path, path, strlen(q->path)))
    5776. 

  5776.     { if (q->value)
    5777. 

  5777.         SOAP_FREE(soap, q->value);
    5778. 

  5778.       if (q->domain)
    5779. 

  5779.         SOAP_FREE(soap, q->domain);
    5780. 

  5780.       if (q->path)
    5781. 

  5781.         SOAP_FREE(soap, q->path);
    5782. 

  5782.       *p = q->next;
    5783. 

  5783.       SOAP_FREE(soap, q);
    5784. 

  5784.     }
    5785. 

  5785.     else
    5786. 

  5786.       p = &q->next;
    5787. 

  5787.   }
    5788. 

  5788. }
    5789. 

  5789. 

  5790. /******************************************************************************/
    5791. 

  5791. SOAP_FMAC1
    5792. 

  5792. char *
    5793. 

  5793. SOAP_FMAC2
    5794. 

  5794. soap_cookie_value(struct soap *soap, const char *name, const char *domain, const char *path)
    5795. 

  5795. { struct soap_cookie *p;
    5796. 

  5796.   if ((p = soap_cookie(soap, name, domain, path)))
    5797. 

  5797.     return p->value;
    5798. 

  5798.   return NULL;
    5799. 

  5799. }
    5800. 

  5800. 

  5801. /******************************************************************************/
    5802. 

  5802. SOAP_FMAC1
    5803. 

  5803. char *
    5804. 

  5804. SOAP_FMAC2
    5805. 

  5805. soap_env_cookie_value(struct soap *soap, const char *name, const char *domain, const char *path)
    5806. 

  5806. { struct soap_cookie *p;
    5807. 

  5807.   if ((p = soap_cookie(soap, name, domain, path)) && p->env)
    5808. 

  5808.     return p->value;
    5809. 

  5809.   return NULL;
    5810. 

  5810. }
    5811. 

  5811. 

  5812. /******************************************************************************/
    5813. 

  5813. SOAP_FMAC1
    5814. 

  5814. time_t
    5815. 

  5815. SOAP_FMAC2
    5816. 

  5816. soap_cookie_expire(struct soap *soap, const char *name, const char *domain, const char *path)
    5817. 

  5817. { struct soap_cookie *p;
    5818. 

  5818.   if ((p = soap_cookie(soap, name, domain, path)))
    5819. 

  5819.     return p->expire;
    5820. 

  5820.   return -1;
    5821. 

  5821. }
    5822. 

  5822. 

  5823. /******************************************************************************/
    5824. 

  5824. SOAP_FMAC1
    5825. 

  5825. int
    5826. 

  5826. SOAP_FMAC2
    5827. 

  5827. soap_set_cookie_expire(struct soap *soap, const char *name, long expire, const char *domain, const char *path)
    5828. 

  5828. { struct soap_cookie *p;
    5829. 

  5829.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Set cookie expiration max-age %ld: %s domain=%s path=%s\n", expire, name, domain?domain:"(null)", path?path:"(null)"));
    5830. 

  5830.   if ((p = soap_cookie(soap, name, domain, path)))
    5831. 

  5831.   { p->maxage = expire;
    5832. 

  5832.     p->modified = 1;
    5833. 

  5833.     return SOAP_OK;
    5834. 

  5834.   }
    5835. 

  5835.   return SOAP_ERR;
    5836. 

  5836. }
    5837. 

  5837. 

  5838. /******************************************************************************/
    5839. 

  5839. SOAP_FMAC1
    5840. 

  5840. int
    5841. 

  5841. SOAP_FMAC2
    5842. 

  5842. soap_set_cookie_session(struct soap *soap, const char *name, const char *domain, const char *path)
    5843. 

  5843. { struct soap_cookie *p;
    5844. 

  5844.   if ((p = soap_cookie(soap, name, domain, path)))
    5845. 

  5845.   { p->session = 1;
    5846. 

  5846.     p->modified = 1;
    5847. 

  5847.     return SOAP_OK;
    5848. 

  5848.   }
    5849. 

  5849.   return SOAP_ERR;
    5850. 

  5850. }
    5851. 

  5851. 

  5852. /******************************************************************************/
    5853. 

  5853. SOAP_FMAC1
    5854. 

  5854. int
    5855. 

  5855. SOAP_FMAC2
    5856. 

  5856. soap_clr_cookie_session(struct soap *soap, const char *name, const char *domain, const char *path)
    5857. 

  5857. { struct soap_cookie *p;
    5858. 

  5858.   if ((p = soap_cookie(soap, name, domain, path)))
    5859. 

  5859.   { p->session = 0;
    5860. 

  5860.     p->modified = 1;
    5861. 

  5861.     return SOAP_OK;
    5862. 

  5862.   }
    5863. 

  5863.   return SOAP_ERR;
    5864. 

  5864. }
    5865. 

  5865. 

  5866. /******************************************************************************/
    5867. 

  5867. SOAP_FMAC1
    5868. 

  5868. int
    5869. 

  5869. SOAP_FMAC2
    5870. 

  5870. soap_putsetcookies(struct soap *soap)
    5871. 

  5871. { struct soap_cookie *p;
    5872. 

  5872.   char *s, tmp[4096];
    5873. 

  5873.   const char *t;
    5874. 

  5874.   for (p = soap->cookies; p; p = p->next)
    5875. 

  5875.   {
    5876. 

  5876.     if (p->modified
    5877. 

  5877. #ifdef WITH_OPENSSL
    5878. 

  5878.      || (!p->env && !soap->ssl == !p->secure)
    5879. 

  5879. #endif
    5880. 

  5880.        )
    5881. 

  5881.     { s = tmp;
    5882. 

  5882.       if (p->name)
    5883. 

  5883.         s += soap_encode_cookie(p->name, s, tmp-s+4064);
    5884. 

  5884.       if (p->value && *p->value)
    5885. 

  5885.       { *s++ = '=';
    5886. 

  5886.         s += soap_encode_cookie(p->value, s, tmp-s+4064);
    5887. 

  5887.       }
    5888. 

  5888.       if (p->domain && (int)strlen(p->domain) < tmp-s+4064)
    5889. 

  5889.       { strcpy(s, ";Domain=");
    5890. 

  5890.         strcat(s, p->domain);
    5891. 

  5891.       }
    5892. 

  5892.       else if (soap->cookie_domain && (int)strlen(soap->cookie_domain) < tmp-s+4064)
    5893. 

  5893.       { strcpy(s, ";Domain=");
    5894. 

  5894.         strcat(s, soap->cookie_domain);
    5895. 

  5895.       }
    5896. 

  5896.       strcat(s, ";Path=/");
    5897. 

  5897.       s += strlen(s);
    5898. 

  5898.       if (p->path)
    5899. 

  5899.         t = p->path;
    5900. 

  5900.       else
    5901. 

  5901.         t = soap->cookie_path;
    5902. 

  5902.       if (t)
    5903. 

  5903.       { if (*t == '/')
    5904. 

  5904.           t++;
    5905. 

  5905.         if ((int)strlen(t) < tmp-s+4064)
    5906. 

  5906.         { if (strchr(t, '%'))	/* already URL encoded? */
    5907. 

  5907.           { strcpy(s, t);
    5908. 

  5908.             s += strlen(s);
    5909. 

  5909.           }
    5910. 

  5910.           else
    5911. 

  5911.             s += soap_encode_cookie(t, s, tmp-s+4064);
    5912. 

  5912.         }
    5913. 

  5913.       }
    5914. 

  5914.       if (p->version > 0 && s-tmp < 4060)
    5915. 

  5915.       { sprintf(s, ";Version=%u", p->version);
    5916. 

  5916.         s += strlen(s);
    5917. 

  5917.       }
    5918. 

  5918.       if (p->maxage >= 0 && s-tmp < 4060)
    5919. 

  5919.       { sprintf(s, ";Max-Age=%ld", p->maxage);
    5920. 

  5920.         s += strlen(s);
    5921. 

  5921.       }
    5922. 

  5922.       if (s-tmp < 4073
    5923. 

  5923.        && (p->secure
    5924. 

  5924. #ifdef WITH_OPENSSL
    5925. 

  5925.        || soap->ssl
    5926. 

  5926. #endif
    5927. 

  5927.          ))
    5928. 

  5928.         strcpy(s, ";Secure");
    5929. 

  5929.       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Set-Cookie: %s\n", tmp));
    5930. 

  5930.       if ((soap->error = soap->fposthdr(soap, "Set-Cookie", tmp)))
    5931. 

  5931.         return soap->error;
    5932. 

  5932.     }
    5933. 

  5933.   }
    5934. 

  5934.   return SOAP_OK;
    5935. 

  5935. }
    5936. 

  5936. 

  5937. /******************************************************************************/
    5938. 

  5938. SOAP_FMAC1
    5939. 

  5939. int
    5940. 

  5940. SOAP_FMAC2
    5941. 

  5941. soap_putcookies(struct soap *soap, const char *domain, const char *path, int secure)
    5942. 

  5942. { struct soap_cookie **p, *q;
    5943. 

  5943.   unsigned int version = 0;
    5944. 

  5944.   time_t now = time(NULL);
    5945. 

  5945.   char *s, tmp[4096];
    5946. 

  5946.   p = &soap->cookies;
    5947. 

  5947.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Sending cookies for domain=%s path=%s\n", domain, path));
    5948. 

  5948.   if (*path == '/')
    5949. 

  5949.     path++;
    5950. 

  5950.   while ((q = *p))
    5951. 

  5951.   { if (q->expire && now > q->expire)
    5952. 

  5952.     { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Cookie %s expired\n", q->name));
    5953. 

  5953.       SOAP_FREE(soap, q->name);
    5954. 

  5954.       if (q->value)
    5955. 

  5955.         SOAP_FREE(soap, q->value);
    5956. 

  5956.       if (q->domain)
    5957. 

  5957.         SOAP_FREE(soap, q->domain);
    5958. 

  5958.       if (q->path)
    5959. 

  5959.         SOAP_FREE(soap, q->path);
    5960. 

  5960.       *p = q->next;
    5961. 

  5961.       SOAP_FREE(soap, q);
    5962. 

  5962.     }
    5963. 

  5963.     else
    5964. 

  5964.     { int flag;
    5965. 

  5965.       char *t = q->domain;
    5966. 

  5966.       size_t n = 0;
    5967. 

  5967.       if (!t)
    5968. 

  5968.         flag = 1;
    5969. 

  5969.       else
    5970. 

  5970.       { const char *r = strchr(t, ':');
    5971. 

  5971.         if (r)
    5972. 

  5972.           n = r - t;
    5973. 

  5973.         else
    5974. 

  5974.           n = strlen(t);
    5975. 

  5975.         flag = !strncmp(t, domain, n);
    5976. 

  5976.       }
    5977. 

  5977.       /* domain-level cookies, cannot compile when WITH_NOIO set */
    5978. 

  5978. #ifndef WITH_NOIO
    5979. 

  5979.       if (!flag)
    5980. 

  5980.       { struct hostent *hostent = gethostbyname((char*)domain);
    5981. 

  5981.         if (hostent)
    5982. 

  5982.         { const char *r = strchr(hostent->h_name, '.');
    5983. 

  5983.           if (!r)
    5984. 

  5984.             r = hostent->h_name;
    5985. 

  5985.           flag = !strncmp(t, r, n);
    5986. 

  5986.         }
    5987. 

  5987.       }
    5988. 

  5988. #endif
    5989. 

  5989.       if (flag
    5990. 

  5990.           && (!q->path || !strncmp(q->path, path, strlen(q->path)))
    5991. 

  5991.           && (!q->secure || secure))
    5992. 

  5992.       { s = tmp;
    5993. 

  5993.         if (q->version != version)
    5994. 

  5994.         { sprintf(s, "$Version=%u;", q->version);
    5995. 

  5995.           version = q->version;
    5996. 

  5996.         }
    5997. 

  5997.         if (q->name)
    5998. 

  5998.           s += soap_encode_cookie(q->name, s, tmp-s+4080);
    5999. 

  5999.         if (q->value && *q->value)
    6000. 

  6000.         { *s++ = '=';
    6001. 

  6001.           s += soap_encode_cookie(q->value, s, tmp-s+4080);
    6002. 

  6002.         }
    6003. 

  6003.         if (q->path && *q->path && (int)strlen(q->path) < tmp-s+4080)
    6004. 

  6004.         { sprintf(s, ";$Path=\"/%s\"", (*q->path == '/' ? q->path + 1 : q->path));
    6005. 

  6005.           s += strlen(s);
    6006. 

  6006.         }
    6007. 

  6007.         if (q->domain && (int)strlen(q->domain) < tmp-s+4080)
    6008. 

  6008.           sprintf(s, ";$Domain=\"%s\"", q->domain);
    6009. 

  6009.         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Cookie: %s\n", tmp));
    6010. 

  6010.         if ((soap->error = soap->fposthdr(soap, "Cookie", tmp)))
    6011. 

  6011.           return soap->error;
    6012. 

  6012.       }
    6013. 

  6013.       p = &q->next;
    6014. 

  6014.     }
    6015. 

  6015.   }
    6016. 

  6016.   return SOAP_OK;
    6017. 

  6017. }
    6018. 

  6018. 

  6019. /******************************************************************************/
    6020. 

  6020. SOAP_FMAC1
    6021. 

  6021. void
    6022. 

  6022. SOAP_FMAC2
    6023. 

  6023. soap_getcookies(struct soap *soap, const char *val)
    6024. 

  6024. { struct soap_cookie *p = NULL, *q;
    6025. 

  6025.   const char *s;
    6026. 

  6026.   char *t, tmp[4096]; /* cookie size is up to 4096 bytes [RFC2109] */
    6027. 

  6027.   char *domain = NULL;
    6028. 

  6028.   char *path = NULL;
    6029. 

  6029.   unsigned int version = 0;
    6030. 

  6030.   time_t now = time(NULL);
    6031. 

  6031.   if (!val)
    6032. 

  6032.     return;
    6033. 

  6033.   s = val;
    6034. 

  6034.   while (*s)
    6035. 

  6035.   { s = soap_decode_key(tmp, sizeof(tmp), s);
    6036. 

  6036.     if (!soap_tag_cmp(tmp, "$Version"))
    6037. 

  6037.     { if ((s = soap_decode_val(tmp, sizeof(tmp), s)))
    6038. 

  6038.       { if (p)
    6039. 

  6039. 	  p->version = (int)soap_strtol(tmp, NULL, 10);
    6040. 

  6040. 	else
    6041. 

  6041. 	  version = (int)soap_strtol(tmp, NULL, 10);
    6042. 

  6042.       }
    6043. 

  6043.     }
    6044. 

  6044.     else if (!soap_tag_cmp(tmp, "$Path"))
    6045. 

  6045.     { s = soap_decode_val(tmp, sizeof(tmp), s);
    6046. 

  6046.       if (*tmp)
    6047. 

  6047.       { if ((t = (char*)SOAP_MALLOC(soap, strlen(tmp)+1)))
    6048. 

  6048.           strcpy(t, tmp);
    6049. 

  6049.       }
    6050. 

  6050.       else
    6051. 

  6051.         t = NULL;
    6052. 

  6052.       if (p)
    6053. 

  6053.       { if (p->path)
    6054. 

  6054.           SOAP_FREE(soap, p->path);
    6055. 

  6055.         p->path = t;
    6056. 

  6056.       }
    6057. 

  6057.       else
    6058. 

  6058.       { if (path)
    6059. 

  6059.           SOAP_FREE(soap, path);
    6060. 

  6060.         path = t;
    6061. 

  6061.       }
    6062. 

  6062.     }
    6063. 

  6063.     else if (!soap_tag_cmp(tmp, "$Domain"))
    6064. 

  6064.     { s = soap_decode_val(tmp, sizeof(tmp), s);
    6065. 

  6065.       if (*tmp)
    6066. 

  6066.       { if ((t = (char*)SOAP_MALLOC(soap, strlen(tmp)+1)))
    6067. 

  6067.           strcpy(t, tmp);
    6068. 

  6068.       }
    6069. 

  6069.       else
    6070. 

  6070.         t = NULL;
    6071. 

  6071.       if (p)
    6072. 

  6072.       { if (p->domain)
    6073. 

  6073.           SOAP_FREE(soap, p->domain);
    6074. 

  6074.         p->domain = t;
    6075. 

  6075.       }
    6076. 

  6076.       else
    6077. 

  6077.       { if (domain)
    6078. 

  6078.           SOAP_FREE(soap, domain);
    6079. 

  6079.         domain = t;
    6080. 

  6080.       }
    6081. 

  6081.     }
    6082. 

  6082.     else if (p && !soap_tag_cmp(tmp, "Path"))
    6083. 

  6083.     { if (p->path)
    6084. 

  6084.         SOAP_FREE(soap, p->path);
    6085. 

  6085.       s = soap_decode_val(tmp, sizeof(tmp), s);
    6086. 

  6086.       if (*tmp)
    6087. 

  6087.       { if ((p->path = (char*)SOAP_MALLOC(soap, strlen(tmp)+1)))
    6088. 

  6088.           strcpy(p->path, tmp);
    6089. 

  6089.       }
    6090. 

  6090.       else
    6091. 

  6091.         p->path = NULL;
    6092. 

  6092.     }
    6093. 

  6093.     else if (p && !soap_tag_cmp(tmp, "Domain"))
    6094. 

  6094.     { if (p->domain)
    6095. 

  6095.         SOAP_FREE(soap, p->domain);
    6096. 

  6096.       s = soap_decode_val(tmp, sizeof(tmp), s);
    6097. 

  6097.       if (*tmp)
    6098. 

  6098.       { if ((p->domain = (char*)SOAP_MALLOC(soap, strlen(tmp)+1)))
    6099. 

  6099.           strcpy(p->domain, tmp);
    6100. 

  6100.       }
    6101. 

  6101.       else
    6102. 

  6102.         p->domain = NULL;
    6103. 

  6103.     }
    6104. 

  6104.     else if (p && !soap_tag_cmp(tmp, "Version"))
    6105. 

  6105.     { s = soap_decode_val(tmp, sizeof(tmp), s);
    6106. 

  6106.       p->version = (unsigned int)soap_strtoul(tmp, NULL, 10);
    6107. 

  6107.     }
    6108. 

  6108.     else if (p && !soap_tag_cmp(tmp, "Max-Age"))
    6109. 

  6109.     { s = soap_decode_val(tmp, sizeof(tmp), s);
    6110. 

  6110.       p->expire = now + soap_strtol(tmp, NULL, 10);
    6111. 

  6111.     }
    6112. 

  6112.     else if (p && !soap_tag_cmp(tmp, "Expires"))
    6113. 

  6113.     { struct tm T;
    6114. 

  6114.       char a[3]; 
    6115. 

  6115.       static const char mns[] = "anebarprayunulugepctovec";
    6116. 

  6116.       s = soap_decode_val(tmp, sizeof(tmp), s);
    6117. 

  6117.       if (strlen(tmp) > 20)
    6118. 

  6118.       { memset((void*)&T, 0, sizeof(T));
    6119. 

  6119.         a[0] = tmp[4];
    6120. 

  6120.         a[1] = tmp[5];
    6121. 

  6121.         a[2] = '\0';
    6122. 

  6122.         T.tm_mday = (int)soap_strtol(a, NULL, 10);
    6123. 

  6123.         a[0] = tmp[8];
    6124. 

  6124.         a[1] = tmp[9];
    6125. 

  6125.         T.tm_mon = (int)(strstr(mns, a) - mns) / 2;
    6126. 

  6126.         a[0] = tmp[11];
    6127. 

  6127.         a[1] = tmp[12];
    6128. 

  6128.         T.tm_year = 100 + (int)soap_strtol(a, NULL, 10);
    6129. 

  6129.         a[0] = tmp[13];
    6130. 

  6130.         a[1] = tmp[14];
    6131. 

  6131.         T.tm_hour = (int)soap_strtol(a, NULL, 10);
    6132. 

  6132.         a[0] = tmp[16];
    6133. 

  6133.         a[1] = tmp[17];
    6134. 

  6134.         T.tm_min = (int)soap_strtol(a, NULL, 10);
    6135. 

  6135.         a[0] = tmp[19];
    6136. 

  6136.         a[1] = tmp[20];
    6137. 

  6137.         T.tm_sec = (int)soap_strtol(a, NULL, 10);
    6138. 

  6138.         p->expire = soap_timegm(&T);
    6139. 

  6139.       }
    6140. 

  6140.     }
    6141. 

  6141.     else if (p && !soap_tag_cmp(tmp, "Secure"))
    6142. 

  6142.       p->secure = 1;
    6143. 

  6143.     else
    6144. 

  6144.     { if (p)
    6145. 

  6145.       { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Got environment cookie %s=%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));
    6146. 

  6146.         if ((q = soap_set_cookie(soap, p->name, p->value, p->domain, p->path)))
    6147. 

  6147.         { q->version = p->version;
    6148. 

  6148.           q->expire = p->expire;
    6149. 

  6149.           q->secure = p->secure;
    6150. 

  6150.           q->env = 1;
    6151. 

  6151.         }
    6152. 

  6152.         if (p->name)
    6153. 

  6153.           SOAP_FREE(soap, p->name);
    6154. 

  6154.         if (p->value)
    6155. 

  6155.           SOAP_FREE(soap, p->value);
    6156. 

  6156.         if (p->domain)
    6157. 

  6157.           SOAP_FREE(soap, p->domain);
    6158. 

  6158.         if (p->path)
    6159. 

  6159.           SOAP_FREE(soap, p->path);
    6160. 

  6160.         SOAP_FREE(soap, p);
    6161. 

  6161.       }
    6162. 

  6162.       if ((p = (struct soap_cookie*)SOAP_MALLOC(soap, sizeof(struct soap_cookie))))
    6163. 

  6163.       { p->name = (char*)SOAP_MALLOC(soap, strlen(tmp)+1);
    6164. 

  6164.         strcpy(p->name, tmp);
    6165. 

  6165.         s = soap_decode_val(tmp, sizeof(tmp), s);
    6166. 

  6166.         if (*tmp)
    6167. 

  6167.         { p->value = (char*)SOAP_MALLOC(soap, strlen(tmp)+1);
    6168. 

  6168.           strcpy(p->value, tmp);
    6169. 

  6169.         }
    6170. 

  6170.         else
    6171. 

  6171.           p->value = NULL;
    6172. 

  6172.         if (domain)
    6173. 

  6173.           p->domain = domain;
    6174. 

  6174.         else if (*soap->host)
    6175. 

  6175.         { p->domain = (char*)SOAP_MALLOC(soap, strlen(soap->host)+1);
    6176. 

  6176.           strcpy(p->domain, soap->host);
    6177. 

  6177.         }
    6178. 

  6178.         else
    6179. 

  6179.           p->domain = NULL;
    6180. 

  6180.         if (path)
    6181. 

  6181.           p->path = path;
    6182. 

  6182.         else if (soap->path && *soap->path)
    6183. 

  6183.         { p->path = (char*)SOAP_MALLOC(soap, strlen(soap->path)+1);
    6184. 

  6184.           strcpy(p->path, soap->path);
    6185. 

  6185.         }
    6186. 

  6186.         else
    6187. 

  6187.         { p->path = (char*)SOAP_MALLOC(soap, 2);
    6188. 

  6188.           strcpy(p->path, "/");
    6189. 

  6189.         }
    6190. 

  6190.         p->expire = 0;
    6191. 

  6191.         p->secure = 0;
    6192. 

  6192.         p->version = version;
    6193. 

  6193.       }
    6194. 

  6194.     }
    6195. 

  6195.   }
    6196. 

  6196.   if (p)
    6197. 

  6197.   { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Got environment cookie %s=%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));
    6198. 

  6198.     if ((q = soap_set_cookie(soap, p->name, p->value, p->domain, p->path)))
    6199. 

  6199.     { q->version = p->version;
    6200. 

  6200.       q->expire = p->expire;
    6201. 

  6201.       q->secure = p->secure;
    6202. 

  6202.       q->env = 1;
    6203. 

  6203.     }
    6204. 

  6204.     if (p->name)
    6205. 

  6205.       SOAP_FREE(soap, p->name);
    6206. 

  6206.     if (p->value)
    6207. 

  6207.       SOAP_FREE(soap, p->value);
    6208. 

  6208.     if (p->domain)
    6209. 

  6209.       SOAP_FREE(soap, p->domain);
    6210. 

  6210.     if (p->path)
    6211. 

  6211.       SOAP_FREE(soap, p->path);
    6212. 

  6212.     SOAP_FREE(soap, p);
    6213. 

  6213.   }
    6214. 

  6214.   if (domain)
    6215. 

  6215.     SOAP_FREE(soap, domain);
    6216. 

  6216.   if (path)
    6217. 

  6217.     SOAP_FREE(soap, path);
    6218. 

  6218. }
    6219. 

  6219. 

  6220. /******************************************************************************/
    6221. 

  6221. SOAP_FMAC1
    6222. 

  6222. int
    6223. 

  6223. SOAP_FMAC2
    6224. 

  6224. soap_getenv_cookies(struct soap *soap)
    6225. 

  6225. { struct soap_cookie *p;
    6226. 

  6226.   const char *s;
    6227. 

  6227.   char key[4096], val[4096]; /* cookie size is up to 4096 bytes [RFC2109] */
    6228. 

  6228.   if (!(s = getenv("HTTP_COOKIE")))
    6229. 

  6229.     return SOAP_ERR;
    6230. 

  6230.   do
    6231. 

  6231.   { s = soap_decode_key(key, sizeof(key), s);
    6232. 

  6232.     s = soap_decode_val(val, sizeof(val), s);
    6233. 

  6233.     p = soap_set_cookie(soap, key, val, NULL, NULL);
    6234. 

  6234.     if (p)
    6235. 

  6235.       p->env = 1;
    6236. 

  6236.   } while (*s);
    6237. 

  6237.   return SOAP_OK;
    6238. 

  6238. }
    6239. 

  6239. 

  6240. /******************************************************************************/
    6241. 

  6241. SOAP_FMAC1
    6242. 

  6242. struct soap_cookie*
    6243. 

  6243. SOAP_FMAC2
    6244. 

  6244. soap_copy_cookies(struct soap *copy, const struct soap *soap)
    6245. 

  6245. { struct soap_cookie *p, **q, *r;
    6246. 

  6246.   q = &r;
    6247. 

  6247.   for (p = soap->cookies; p; p = p->next)
    6248. 

  6248.   { if (!(*q = (struct soap_cookie*)SOAP_MALLOC(copy, sizeof(struct soap_cookie))))
    6249. 

  6249.       return r;
    6250. 

  6250.     **q = *p;
    6251. 

  6251.     if (p->name)
    6252. 

  6252.     { if (((*q)->name = (char*)SOAP_MALLOC(copy, strlen(p->name)+1)))
    6253. 

  6253.         strcpy((*q)->name, p->name);
    6254. 

  6254.     }
    6255. 

  6255.     if (p->value)
    6256. 

  6256.     { if (((*q)->value = (char*)SOAP_MALLOC(copy, strlen(p->value)+1)))
    6257. 

  6257.         strcpy((*q)->value, p->value);
    6258. 

  6258.     }
    6259. 

  6259.     if (p->domain)
    6260. 

  6260.     { if (((*q)->domain = (char*)SOAP_MALLOC(copy, strlen(p->domain)+1)))
    6261. 

  6261.         strcpy((*q)->domain, p->domain);
    6262. 

  6262.     }
    6263. 

  6263.     if (p->path)
    6264. 

  6264.     { if (((*q)->path = (char*)SOAP_MALLOC(copy, strlen(p->path)+1)))
    6265. 

  6265.         strcpy((*q)->path, p->path);
    6266. 

  6266.     }
    6267. 

  6267.     q = &(*q)->next;
    6268. 

  6268.   }
    6269. 

  6269.   *q = NULL;
    6270. 

  6270.   return r;
    6271. 

  6271. }
    6272. 

  6272. 

  6273. /******************************************************************************/
    6274. 

  6274. SOAP_FMAC1
    6275. 

  6275. void
    6276. 

  6276. SOAP_FMAC2
    6277. 

  6277. soap_free_cookies(struct soap *soap)
    6278. 

  6278. { struct soap_cookie *p;
    6279. 

  6279.   for (p = soap->cookies; p; p = soap->cookies)
    6280. 

  6280.   { soap->cookies = p->next;
    6281. 

  6281.     SOAP_FREE(soap, p->name);
    6282. 

  6282.     if (p->value)
    6283. 

  6283.       SOAP_FREE(soap, p->value);
    6284. 

  6284.     if (p->domain)
    6285. 

  6285.       SOAP_FREE(soap, p->domain);
    6286. 

  6286.     if (p->path)
    6287. 

  6287.       SOAP_FREE(soap, p->path);
    6288. 

  6288.     SOAP_FREE(soap, p);
    6289. 

  6289.   }
    6290. 

  6290. }
    6291. 

  6291. 

  6292. /******************************************************************************/
    6293. 

  6293. #endif /* WITH_COOKIES */
    6294. 

  6294. 

  6295. /******************************************************************************/
    6296. 

  6296. #ifndef WITH_NOIDREF
    6297. 

  6297. #ifndef PALM_2
    6298. 

  6298. SOAP_FMAC1
    6299. 

  6299. size_t
    6300. 

  6300. SOAP_FMAC2
    6301. 

  6301. soap_hash(register const char *s)
    6302. 

  6302. { register size_t h = 0;
    6303. 

  6303.   while (*s)
    6304. 

  6304.     h = 65599*h + *s++;
    6305. 

  6305.   return h % SOAP_IDHASH;
    6306. 

  6306. }
    6307. 

  6307. #endif
    6308. 

  6308. #endif
    6309. 

  6309. 

  6310. /******************************************************************************/
    6311. 

  6311. #ifndef WITH_NOIDREF
    6312. 

  6312. #ifndef PALM_1
    6313. 

  6313. static void
    6314. 

  6314. soap_init_pht(struct soap *soap)
    6315. 

  6315. { register int i;
    6316. 

  6316.   soap->pblk = NULL;
    6317. 

  6317.   soap->pidx = 0;
    6318. 

  6318.   for (i = 0; i < (int)SOAP_PTRHASH; i++)
    6319. 

  6319.     soap->pht[i] = NULL;
    6320. 

  6320. }
    6321. 

  6321. #endif
    6322. 

  6322. #endif
    6323. 

  6323. 

  6324. /******************************************************************************/
    6325. 

  6325. #ifndef PALM_1
    6326. 

  6326. SOAP_FMAC1
    6327. 

  6327. struct soap*
    6328. 

  6328. SOAP_FMAC2
    6329. 

  6329. soap_new1(soap_mode mode)
    6330. 

  6330. { return soap_new2(mode, mode);
    6331. 

  6331. }
    6332. 

  6332. #endif
    6333. 

  6333. 

  6334. /******************************************************************************/
    6335. 

  6335. #ifndef PALM_1
    6336. 

  6336. SOAP_FMAC1
    6337. 

  6337. struct soap*
    6338. 

  6338. SOAP_FMAC2
    6339. 

  6339. soap_new()
    6340. 

  6340. { return soap_new2(SOAP_IO_DEFAULT, SOAP_IO_DEFAULT);
    6341. 

  6341. }
    6342. 

  6342. #endif
    6343. 

  6343. 

  6344. /******************************************************************************/
    6345. 

  6345. #ifndef PALM_1
    6346. 

  6346. SOAP_FMAC1
    6347. 

  6347. struct soap*
    6348. 

  6348. SOAP_FMAC2
    6349. 

  6349. soap_new2(soap_mode imode, soap_mode omode)
    6350. 

  6350. { struct soap *soap = (struct soap*)malloc(sizeof(struct soap));
    6351. 

  6351.   if (soap)
    6352. 

  6352.     soap_init2(soap, imode, omode);
    6353. 

  6353.   return soap;
    6354. 

  6354. }
    6355. 

  6355. #endif
    6356. 

  6356. 

  6357. /******************************************************************************/
    6358. 

  6358. #ifndef PALM_1
    6359. 

  6359. SOAP_FMAC1
    6360. 

  6360. void
    6361. 

  6361. SOAP_FMAC2
    6362. 

  6362. soap_free(struct soap *soap)
    6363. 

  6363. { soap_done(soap);
    6364. 

  6364.   free(soap);
    6365. 

  6365. }
    6366. 

  6366. #endif
    6367. 

  6367. 

  6368. /******************************************************************************/
    6369. 

  6369. #ifndef PALM_1
    6370. 

  6370. SOAP_FMAC1
    6371. 

  6371. void
    6372. 

  6372. SOAP_FMAC2
    6373. 

  6373. soap_del(struct soap *soap)
    6374. 

  6374. { free(soap);
    6375. 

  6375. }
    6376. 

  6376. #endif
    6377. 

  6377. 

  6378. /******************************************************************************/
    6379. 

  6379. #ifndef WITH_NOIDREF
    6380. 

  6380. #ifndef PALM_1
    6381. 

  6381. static void
    6382. 

  6382. soap_free_pht(struct soap *soap)
    6383. 

  6383. { register struct soap_pblk *pb, *next;
    6384. 

  6384.   register int i;
    6385. 

  6385.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free pointer hashtable\n"));
    6386. 

  6386.   for (pb = soap->pblk; pb; pb = next)
    6387. 

  6387.   { next = pb->next;
    6388. 

  6388.     SOAP_FREE(soap, pb);
    6389. 

  6389.   }
    6390. 

  6390.   soap->pblk = NULL;
    6391. 

  6391.   soap->pidx = 0;
    6392. 

  6392.   for (i = 0; i < (int)SOAP_PTRHASH; i++)
    6393. 

  6393.     soap->pht[i] = NULL;
    6394. 

  6394. }
    6395. 

  6395. #endif
    6396. 

  6396. #endif
    6397. 

  6397. 

  6398. /******************************************************************************/
    6399. 

  6399. #ifndef WITH_NOIDREF
    6400. 

  6400. #ifndef PALM_2
    6401. 

  6401. SOAP_FMAC1
    6402. 

  6402. int
    6403. 

  6403. SOAP_FMAC2
    6404. 

  6404. soap_embed(struct soap *soap, const void *p, const struct soap_array *a, int n, const char *tag, int type)
    6405. 

  6405. { register int i;
    6406. 

  6406.   struct soap_plist *pp;
    6407. 

  6407.   if (soap->version == 2)
    6408. 

  6408.     soap->encoding = 1;
    6409. 

  6409.   if (a)
    6410. 

  6410.     i = soap_array_pointer_lookup(soap, p, a, n, type, &pp);
    6411. 

  6411.   else
    6412. 

  6412.     i = soap_pointer_lookup(soap, p, type, &pp);
    6413. 

  6413.   if (i)
    6414. 

  6414.   { if (soap_is_embedded(soap, pp)
    6415. 

  6415.      || soap_is_single(soap, pp))
    6416. 

  6416.       return 0;
    6417. 

  6417.     soap_set_embedded(soap, pp);
    6418. 

  6418.   }
    6419. 

  6419.   return i;
    6420. 

  6420. }
    6421. 

  6421. #endif
    6422. 

  6422. #endif
    6423. 

  6423. 

  6424. /******************************************************************************/
    6425. 

  6425. #ifndef WITH_NOIDREF
    6426. 

  6426. #ifndef PALM_2
    6427. 

  6427. SOAP_FMAC1
    6428. 

  6428. int
    6429. 

  6429. SOAP_FMAC2
    6430. 

  6430. soap_pointer_lookup(struct soap *soap, const void *p, int type, struct soap_plist **ppp)
    6431. 

  6431. { register struct soap_plist *pp;
    6432. 

  6432.   *ppp = NULL;
    6433. 

  6433.   if (p)
    6434. 

  6434.   { for (pp = soap->pht[soap_hash_ptr(p)]; pp; pp = pp->next)
    6435. 

  6435.     { if (pp->ptr == p && pp->type == type)
    6436. 

  6436.       { *ppp = pp;
    6437. 

  6437.         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Lookup location=%p type=%d id=%d\n", p, type, pp->id));
    6438. 

  6438.         return pp->id;
    6439. 

  6439.       }
    6440. 

  6440.     }
    6441. 

  6441.   }
    6442. 

  6442.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Lookup location=%p type=%d: not found\n", p, type));
    6443. 

  6443.   return 0;
    6444. 

  6444. }
    6445. 

  6445. #endif
    6446. 

  6446. #endif
    6447. 

  6447. 

  6448. /******************************************************************************/
    6449. 

  6449. #ifndef WITH_NOIDREF
    6450. 

  6450. #ifndef PALM_2
    6451. 

  6451. SOAP_FMAC1
    6452. 

  6452. int
    6453. 

  6453. SOAP_FMAC2
    6454. 

  6454. soap_pointer_enter(struct soap *soap, const void *p, const struct soap_array *a, int n, int type, struct soap_plist **ppp)
    6455. 

  6455. { register size_t h;
    6456. 

  6456.   register struct soap_plist *pp;
    6457. 

  6457.   if (!soap->pblk || soap->pidx >= SOAP_PTRBLK)
    6458. 

  6458.   { register struct soap_pblk *pb = (struct soap_pblk*)SOAP_MALLOC(soap, sizeof(struct soap_pblk));
    6459. 

  6459.     if (!pb)
    6460. 

  6460.     { soap->error = SOAP_EOM;
    6461. 

  6461.       return 0;
    6462. 

  6462.     }
    6463. 

  6463.     pb->next = soap->pblk;
    6464. 

  6464.     soap->pblk = pb;
    6465. 

  6465.     soap->pidx = 0;
    6466. 

  6466.   }
    6467. 

  6467.   *ppp = pp = &soap->pblk->plist[soap->pidx++];
    6468. 

  6468.   if (a)
    6469. 

  6469.     h = soap_hash_ptr(a->__ptr);
    6470. 

  6470.   else
    6471. 

  6471.     h = soap_hash_ptr(p);
    6472. 

  6472.   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));
    6473. 

  6473.   pp->next = soap->pht[h];
    6474. 

  6474.   pp->type = type;
    6475. 

  6475.   pp->mark1 = 0;
    6476. 

  6476.   pp->mark2 = 0;
    6477. 

  6477.   pp->ptr = p;
    6478. 

  6478.   pp->array = a;
    6479. 

  6479.   soap->pht[h] = pp;
    6480. 

  6480.   pp->id = ++soap->idnum;
    6481. 

  6481.   return pp->id;
    6482. 

  6482. }
    6483. 

  6483. #endif
    6484. 

  6484. #endif
    6485. 

  6485. 

  6486. /******************************************************************************/
    6487. 

  6487. #ifndef WITH_NOIDREF
    6488. 

  6488. #ifndef PALM_2
    6489. 

  6489. SOAP_FMAC1
    6490. 

  6490. int
    6491. 

  6491. SOAP_FMAC2
    6492. 

  6492. soap_array_pointer_lookup(struct soap *soap, const void *p, const struct soap_array *a, int n, int type, struct soap_plist **ppp)
    6493. 

  6493. { register struct soap_plist *pp;
    6494. 

  6494.   *ppp = NULL;
    6495. 

  6495.   if (!p || !a->__ptr)
    6496. 

  6496.     return 0;
    6497. 

  6497.   for (pp = soap->pht[soap_hash_ptr(a->__ptr)]; pp; pp = pp->next)
    6498. 

  6498.   { if (pp->type == type && pp->array && pp->array->__ptr == a->__ptr)
    6499. 

  6499.     { register int i;
    6500. 

  6500.       for (i = 0; i < n; i++)
    6501. 

  6501.         if (((const int*)&pp->array->__size)[i] != ((const int*)&a->__size)[i])
    6502. 

  6502.           break;
    6503. 

  6503.       if (i == n)
    6504. 

  6504.       { *ppp = pp;
    6505. 

  6505.         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Array lookup location=%p type=%d id=%d\n", a->__ptr, type, pp->id));
    6506. 

  6506.         return pp->id;
    6507. 

  6507.       }
    6508. 

  6508.     }
    6509. 

  6509.   }
    6510. 

  6510.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Array lookup location=%p type=%d: not found\n", a->__ptr, type));
    6511. 

  6511.   return 0;
    6512. 

  6512. }
    6513. 

  6513. #endif
    6514. 

  6514. #endif
    6515. 

  6515. 

  6516. /******************************************************************************/
    6517. 

  6517. #ifndef PALM_1
    6518. 

  6518. SOAP_FMAC1
    6519. 

  6519. int
    6520. 

  6520. SOAP_FMAC2
    6521. 

  6521. soap_begin_count(struct soap *soap)
    6522. 

  6522. { soap_free_ns(soap);
    6523. 

  6523. #ifndef WITH_LEANER
    6524. 

  6524.   if ((soap->mode & SOAP_ENC_DIME) || (soap->omode & SOAP_ENC_DIME))
    6525. 

  6525.     soap->mode = soap->omode | SOAP_IO_LENGTH | SOAP_ENC_DIME;
    6526. 

  6526.   else
    6527. 

  6527. #endif
    6528. 

  6528.   { soap->mode = soap->omode;
    6529. 

  6529.     if ((soap->mode & SOAP_IO_UDP))
    6530. 

  6530.       soap->mode |= SOAP_ENC_XML;
    6531. 

  6531.     if ((soap->mode & SOAP_IO) == SOAP_IO_STORE
    6532. 

  6532.      || (((soap->mode & SOAP_IO) == SOAP_IO_CHUNK || (soap->mode & SOAP_ENC_XML))
    6533. 

  6533. #ifndef WITH_LEANER
    6534. 

  6534.       && !soap->fpreparesend
    6535. 

  6535. #endif
    6536. 

  6536.       ))
    6537. 

  6537.       soap->mode &= ~SOAP_IO_LENGTH;
    6538. 

  6538.     else
    6539. 

  6539.       soap->mode |= SOAP_IO_LENGTH;
    6540. 

  6540.   }
    6541. 

  6541. #ifdef WITH_ZLIB
    6542. 

  6542.   if ((soap->mode & SOAP_ENC_ZLIB) && (soap->mode & SOAP_IO) == SOAP_IO_FLUSH)
    6543. 

  6543.   { if (!(soap->mode & SOAP_ENC_DIME))
    6544. 

  6544.       soap->mode &= ~SOAP_IO_LENGTH;
    6545. 

  6545.     if (soap->mode & SOAP_ENC_XML)
    6546. 

  6546.       soap->mode |= SOAP_IO_BUFFER;
    6547. 

  6547.     else
    6548. 

  6548.       soap->mode |= SOAP_IO_STORE;
    6549. 

  6549.   }
    6550. 

  6550. #endif
    6551. 

  6551.   if (!soap->encodingStyle && !(soap->mode & SOAP_XML_GRAPH))
    6552. 

  6552.     soap->mode |= SOAP_XML_TREE;
    6553. 

  6553. #ifndef WITH_LEANER
    6554. 

  6554.   if ((soap->mode & SOAP_ENC_MTOM) && (soap->mode & SOAP_ENC_DIME))
    6555. 

  6555.     soap->mode |= SOAP_ENC_MIME;
    6556. 

  6556.   else if (!(soap->mode & SOAP_ENC_MIME))
    6557. 

  6557.     soap->mode &= ~SOAP_ENC_MTOM;
    6558. 

  6558.   if (soap->mode & SOAP_ENC_MIME)
    6559. 

  6559.     soap_select_mime_boundary(soap);
    6560. 

  6560.   soap->dime.list = soap->dime.last;	/* keep track of last DIME attachment */
    6561. 

  6561. #endif
    6562. 

  6562.   soap->count = 0;
    6563. 

  6563.   soap->ns = 0;
    6564. 

  6564.   soap->null = 0;
    6565. 

  6565.   soap->position = 0;
    6566. 

  6566.   soap->mustUnderstand = 0;
    6567. 

  6567.   soap->encoding = 0;
    6568. 

  6568.   soap->part = SOAP_BEGIN;
    6569. 

  6569.   soap->idnum = 0;
    6570. 

  6570.   soap_clr_attr(soap);
    6571. 

  6571.   soap_set_local_namespaces(soap);
    6572. 

  6572.   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));
    6573. 

  6573. #ifndef WITH_LEANER
    6574. 

  6574.   soap->dime.count = 0; /* count # of attachments */
    6575. 

  6575.   soap->dime.size = 0; /* accumulate total size of attachments */
    6576. 

  6576.   if (soap->fprepareinitsend && (soap->mode & SOAP_IO) != SOAP_IO_STORE)
    6577. 

  6577.     return soap->error = soap->fprepareinitsend(soap);   
    6578. 

  6578. #endif
    6579. 

  6579.   return SOAP_OK;
    6580. 

  6580. }
    6581. 

  6581. #endif
    6582. 

  6582. 

  6583. /******************************************************************************/
    6584. 

  6584. #ifndef PALM_1
    6585. 

  6585. SOAP_FMAC1
    6586. 

  6586. int
    6587. 

  6587. SOAP_FMAC2
    6588. 

  6588. soap_end_count(struct soap *soap)
    6589. 

  6589. { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End of count phase\n"));
    6590. 

  6590. #ifndef WITH_LEANER
    6591. 

  6591.   if (soap->fpreparefinalsend && (soap->mode & SOAP_IO_LENGTH))
    6592. 

  6592.     return soap->error = soap->fpreparefinalsend(soap);
    6593. 

  6593. #endif
    6594. 

  6594.   return SOAP_OK;
    6595. 

  6595. }
    6596. 

  6596. #endif
    6597. 

  6597. 

  6598. /******************************************************************************/
    6599. 

  6599. #ifndef PALM_1
    6600. 

  6600. SOAP_FMAC1
    6601. 

  6601. int
    6602. 

  6602. SOAP_FMAC2
    6603. 

  6603. soap_begin_send(struct soap *soap)
    6604. 

  6604. { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Initializing for output\n"));
    6605. 

  6605.   soap_free_ns(soap);
    6606. 

  6606.   soap->error = SOAP_OK;
    6607. 

  6607.   soap->mode = soap->omode | (soap->mode & (SOAP_IO_LENGTH | SOAP_ENC_DIME));
    6608. 

  6608. #ifdef WITH_ZLIB
    6609. 

  6609.   if ((soap->mode & SOAP_ENC_ZLIB) && (soap->mode & SOAP_IO) == SOAP_IO_FLUSH)
    6610. 

  6610.   { if (soap->mode & SOAP_ENC_XML)
    6611. 

  6611.       soap->mode |= SOAP_IO_BUFFER;
    6612. 

  6612.     else
    6613. 

  6613.       soap->mode |= SOAP_IO_STORE;
    6614. 

  6614.   }
    6615. 

  6615. #endif
    6616. 

  6616. #ifndef WITH_LEAN
    6617. 

  6617.   if ((soap->mode & SOAP_IO_UDP))
    6618. 

  6618.   { soap->mode |= SOAP_ENC_XML;
    6619. 

  6619.     if (soap->count > SOAP_BUFLEN)
    6620. 

  6620.       return soap->error = SOAP_UDP_ERROR;
    6621. 

  6621.   }
    6622. 

  6622. #endif
    6623. 

  6623.   if ((soap->mode & SOAP_IO) == SOAP_IO_FLUSH && soap_valid_socket(soap->socket))
    6624. 

  6624.   { if (soap->count || (soap->mode & SOAP_IO_LENGTH) || (soap->mode & SOAP_ENC_XML))
    6625. 

  6625.       soap->mode |= SOAP_IO_BUFFER;
    6626. 

  6626.     else
    6627. 

  6627.       soap->mode |= SOAP_IO_STORE;
    6628. 

  6628.   }
    6629. 

  6629.   soap->mode &= ~SOAP_IO_LENGTH;
    6630. 

  6630.   if ((soap->mode & SOAP_IO) == SOAP_IO_STORE)
    6631. 

  6631.     if (soap_new_block(soap) == NULL)
    6632. 

  6632.       return soap->error;
    6633. 

  6633.   if (!(soap->mode & SOAP_IO_KEEPALIVE))
    6634. 

  6634.     soap->keep_alive = 0;
    6635. 

  6635.   if (!soap->encodingStyle && !(soap->mode & SOAP_XML_GRAPH))
    6636. 

  6636.     soap->mode |= SOAP_XML_TREE;
    6637. 

  6637. #ifndef WITH_LEANER
    6638. 

  6638.   if ((soap->mode & SOAP_ENC_MTOM) && (soap->mode & SOAP_ENC_DIME))
    6639. 

  6639.   { soap->mode |= SOAP_ENC_MIME;
    6640. 

  6640.     soap->mode &= ~SOAP_ENC_DIME;
    6641. 

  6641.   }
    6642. 

  6642.   else if (!(soap->mode & SOAP_ENC_MIME))
    6643. 

  6643.     soap->mode &= ~SOAP_ENC_MTOM;
    6644. 

  6644.   if (soap->mode & SOAP_ENC_MIME)
    6645. 

  6645.     soap_select_mime_boundary(soap);
    6646. 

  6646. #ifdef WIN32
    6647. 

  6647. #ifndef UNDER_CE
    6648. 

  6648. #ifndef WITH_FASTCGI
    6649. 

  6649.   if (!soap_valid_socket(soap->socket)) /* Set win32 stdout or soap->sendfd to BINARY, e.g. to support DIME */
    6650. 

  6650. #ifdef __BORLANDC__
    6651. 

  6651.     setmode(soap->sendfd, _O_BINARY);
    6652. 

  6652. #else
    6653. 

  6653.     _setmode(soap->sendfd, _O_BINARY);
    6654. 

  6654. #endif
    6655. 

  6655. #endif
    6656. 

  6656. #endif
    6657. 

  6657. #endif
    6658. 

  6658. #endif
    6659. 

  6659.   if (soap->mode & SOAP_IO)
    6660. 

  6660.   { soap->bufidx = 0;
    6661. 

  6661.     soap->buflen = 0;
    6662. 

  6662.   }
    6663. 

  6663.   soap->chunksize = 0;
    6664. 

  6664.   soap->ns = 0;
    6665. 

  6665.   soap->null = 0;
    6666. 

  6666.   soap->position = 0;
    6667. 

  6667.   soap->mustUnderstand = 0;
    6668. 

  6668.   soap->encoding = 0;
    6669. 

  6669.   soap->idnum = 0;
    6670. 

  6670.   soap->level = 0;
    6671. 

  6671.   soap_clr_attr(soap);
    6672. 

  6672.   soap_set_local_namespaces(soap);
    6673. 

  6673. #ifdef WITH_ZLIB
    6674. 

  6674.   soap->z_ratio_out = 1.0;
    6675. 

  6675.   if ((soap->mode & SOAP_ENC_ZLIB) && soap->zlib_state != SOAP_ZLIB_DEFLATE)
    6676. 

  6676.   { if (!soap->z_buf)
    6677. 

  6677.       soap->z_buf = (char*)SOAP_MALLOC(soap, SOAP_BUFLEN);
    6678. 

  6678.     soap->d_stream->next_out = (Byte*)soap->z_buf;
    6679. 

  6679.     soap->d_stream->avail_out = SOAP_BUFLEN;
    6680. 

  6680. #ifdef WITH_GZIP
    6681. 

  6681.     if (soap->zlib_out != SOAP_ZLIB_DEFLATE)
    6682. 

  6682.     { memcpy(soap->z_buf, "\37\213\10\0\0\0\0\0\0\377", 10);
    6683. 

  6683.       soap->d_stream->next_out = (Byte*)soap->z_buf + 10;
    6684. 

  6684.       soap->d_stream->avail_out = SOAP_BUFLEN - 10;
    6685. 

  6685.       soap->z_crc = crc32(0L, NULL, 0);
    6686. 

  6686.       soap->zlib_out = SOAP_ZLIB_GZIP;
    6687. 

  6687.       if (soap->z_dict)
    6688. 

  6688.         *((Byte*)soap->z_buf + 2) = 0xff;
    6689. 

  6689.       if (deflateInit2(soap->d_stream, soap->z_level, Z_DEFLATED, -MAX_WBITS, 8, Z_DEFAULT_STRATEGY) != Z_OK)
    6690. 

  6690.         return soap->error = SOAP_ZLIB_ERROR;
    6691. 

  6691.     }
    6692. 

  6692.     else
    6693. 

  6693. #endif
    6694. 

  6694.     if (deflateInit(soap->d_stream, soap->z_level) != Z_OK)
    6695. 

  6695.       return soap->error = SOAP_ZLIB_ERROR;
    6696. 

  6696.     if (soap->z_dict)
    6697. 

  6697.     { if (deflateSetDictionary(soap->d_stream, (const Bytef*)soap->z_dict, soap->z_dict_len) != Z_OK)
    6698. 

  6698.         return soap->error = SOAP_ZLIB_ERROR;
    6699. 

  6699.     }
    6700. 

  6700.     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Deflate initialized\n"));
    6701. 

  6701.     soap->zlib_state = SOAP_ZLIB_DEFLATE;
    6702. 

  6702.   }
    6703. 

  6703. #endif
    6704. 

  6704. #ifdef WITH_OPENSSL
    6705. 

  6705.   if (soap->ssl)
    6706. 

  6706.     ERR_clear_error();
    6707. 

  6707. #endif
    6708. 

  6708.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Begin send phase (socket=%d mode=0x%x count=%lu)\n", soap->socket, soap->mode, (unsigned long)soap->count));
    6709. 

  6709.   soap->part = SOAP_BEGIN;
    6710. 

  6710. #ifndef WITH_LEANER
    6711. 

  6711.   if (soap->fprepareinitsend && (soap->mode & SOAP_IO) == SOAP_IO_STORE)
    6712. 

  6712.     soap->fprepareinitsend(soap);   
    6713. 

  6713. #endif
    6714. 

  6714.   return SOAP_OK;
    6715. 

  6715. }
    6716. 

  6716. #endif
    6717. 

  6717. 

  6718. /******************************************************************************/
    6719. 

  6719. #ifndef WITH_NOIDREF
    6720. 

  6720. #ifndef PALM_2
    6721. 

  6721. SOAP_FMAC1
    6722. 

  6722. void
    6723. 

  6723. SOAP_FMAC2
    6724. 

  6724. soap_embedded(struct soap *soap, const void *p, int t)
    6725. 

  6725. { struct soap_plist *pp;
    6726. 

  6726.   if (soap_pointer_lookup(soap, p, t, &pp))
    6727. 

  6727.   { pp->mark1 = 1;
    6728. 

  6728.     pp->mark2 = 1;
    6729. 

  6729.     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Embedded %p type=%d mark set to 1\n", p, t));
    6730. 

  6730.   }
    6731. 

  6731. }
    6732. 

  6732. #endif
    6733. 

  6733. #endif
    6734. 

  6734. 

  6735. /******************************************************************************/
    6736. 

  6736. #ifndef WITH_NOIDREF
    6737. 

  6737. #ifndef PALM_2
    6738. 

  6738. SOAP_FMAC1
    6739. 

  6739. int
    6740. 

  6740. SOAP_FMAC2
    6741. 

  6741. soap_reference(struct soap *soap, const void *p, int t)
    6742. 

  6742. { struct soap_plist *pp;
    6743. 

  6743.   if (!p || (soap->mode & SOAP_XML_TREE))
    6744. 

  6744.     return 1;
    6745. 

  6745.   if (soap_pointer_lookup(soap, p, t, &pp))
    6746. 

  6746.   { if (pp->mark1 == 0)
    6747. 

  6747.     { pp->mark1 = 2;
    6748. 

  6748.       pp->mark2 = 2;
    6749. 

  6749.     }
    6750. 

  6750.   }
    6751. 

  6751.   else if (soap_pointer_enter(soap, p, NULL, 0, t, &pp))
    6752. 

  6752.   { pp->mark1 = 0;
    6753. 

  6753.     pp->mark2 = 0;
    6754. 

  6754.   }
    6755. 

  6755.   else
    6756. 

  6756.     return 1;
    6757. 

  6757.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Reference %p type=%d (%d %d)\n", p, t, (int)pp->mark1, (int)pp->mark2));
    6758. 

  6758.   return pp->mark1;
    6759. 

  6759. }
    6760. 

  6760. #endif
    6761. 

  6761. #endif
    6762. 

  6762. 

  6763. /******************************************************************************/
    6764. 

  6764. #ifndef WITH_NOIDREF
    6765. 

  6765. #ifndef PALM_2
    6766. 

  6766. SOAP_FMAC1
    6767. 

  6767. int
    6768. 

  6768. SOAP_FMAC2
    6769. 

  6769. soap_array_reference(struct soap *soap, const void *p, const struct soap_array *a, int n, int t)
    6770. 

  6770. { register int i;
    6771. 

  6771.   struct soap_plist *pp;
    6772. 

  6772.   if (!p || !a->__ptr)
    6773. 

  6773.     return 1;
    6774. 

  6774.   i = soap_array_pointer_lookup(soap, p, a, n, t, &pp);
    6775. 

  6775.   if (i)
    6776. 

  6776.   { if (pp->mark1 == 0)
    6777. 

  6777.     { pp->mark1 = 2;
    6778. 

  6778.       pp->mark2 = 2;
    6779. 

  6779.     }
    6780. 

  6780.   }
    6781. 

  6781.   else if (!soap_pointer_enter(soap, p, a, n, t, &pp))
    6782. 

  6782.     return 1;
    6783. 

  6783.   else
    6784. 

  6784.   { pp->mark1 = 0;
    6785. 

  6785.     pp->mark2 = 0;
    6786. 

  6786.   }
    6787. 

  6787.   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));
    6788. 

  6788.   return pp->mark1;
    6789. 

  6789. }
    6790. 

  6790. #endif
    6791. 

  6791. #endif
    6792. 

  6792. 

  6793. /******************************************************************************/
    6794. 

  6794. #ifndef WITH_NOIDREF
    6795. 

  6795. #ifndef PALM_2
    6796. 

  6796. SOAP_FMAC1
    6797. 

  6797. int
    6798. 

  6798. SOAP_FMAC2
    6799. 

  6799. soap_embedded_id(struct soap *soap, int id, const void *p, int t)
    6800. 

  6800. { struct soap_plist *pp = NULL;
    6801. 

  6801.   if (soap->mode & SOAP_XML_TREE)
    6802. 

  6802.     return id;
    6803. 

  6803.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Embedded_id %p type=%d id=%d\n", p, t, id));
    6804. 

  6804.   if (soap->version == 1 && soap->encodingStyle && !(soap->mode & SOAP_XML_GRAPH) && soap->part != SOAP_IN_HEADER)
    6805. 

  6805.   { if (id < 0)
    6806. 

  6806.     { id = soap_pointer_lookup(soap, p, t, &pp);
    6807. 

  6807.       if (id)
    6808. 

  6808.       { if (soap->mode & SOAP_IO_LENGTH)
    6809. 

  6809.           pp->mark1 = 2;
    6810. 

  6810.         else
    6811. 

  6811.           pp->mark2 = 2;
    6812. 

  6812.         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));
    6813. 

  6813.       }
    6814. 

  6814.       return -1;
    6815. 

  6815.     }
    6816. 

  6816.     return id;
    6817. 

  6817.   }
    6818. 

  6818.   if (id < 0)
    6819. 

  6819.     id = soap_pointer_lookup(soap, p, t, &pp);
    6820. 

  6820.   else if (id && !soap_pointer_lookup(soap, p, t, &pp))
    6821. 

  6821.     return 0;
    6822. 

  6822.   if (id && pp)
    6823. 

  6823.   { if (soap->mode & SOAP_IO_LENGTH)
    6824. 

  6824.       pp->mark1 = 1;
    6825. 

  6825.     else
    6826. 

  6826.       pp->mark2 = 1;
    6827. 

  6827.     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));
    6828. 

  6828.   }
    6829. 

  6829.   return id;
    6830. 

  6830. }
    6831. 

  6831. #endif
    6832. 

  6832. #endif
    6833. 

  6833. 

  6834. /******************************************************************************/
    6835. 

  6835. #ifndef WITH_NOIDREF
    6836. 

  6836. #ifndef PALM_2
    6837. 

  6837. SOAP_FMAC1
    6838. 

  6838. int
    6839. 

  6839. SOAP_FMAC2
    6840. 

  6840. soap_is_embedded(struct soap *soap, struct soap_plist *pp)
    6841. 

  6841. { if (!pp)
    6842. 

  6842.     return 0;
    6843. 

  6843.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Is embedded? %d %d\n", (int)pp->mark1, (int)pp->mark2));
    6844. 

  6844.   if (soap->version == 1 && soap->encodingStyle && !(soap->mode & SOAP_XML_GRAPH) && soap->part != SOAP_IN_HEADER)
    6845. 

  6845.   { if (soap->mode & SOAP_IO_LENGTH)
    6846. 

  6846.       return pp->mark1 != 0;
    6847. 

  6847.     return pp->mark2 != 0;
    6848. 

  6848.   }
    6849. 

  6849.   if (soap->mode & SOAP_IO_LENGTH)
    6850. 

  6850.     return pp->mark1 == 1;
    6851. 

  6851.   return pp->mark2 == 1;
    6852. 

  6852. }
    6853. 

  6853. #endif
    6854. 

  6854. #endif
    6855. 

  6855. 

  6856. /******************************************************************************/
    6857. 

  6857. #ifndef WITH_NOIDREF
    6858. 

  6858. #ifndef PALM_2
    6859. 

  6859. SOAP_FMAC1
    6860. 

  6860. int
    6861. 

  6861. SOAP_FMAC2
    6862. 

  6862. soap_is_single(struct soap *soap, struct soap_plist *pp)
    6863. 

  6863. { if (soap->part == SOAP_IN_HEADER)
    6864. 

  6864.     return 1;
    6865. 

  6865.   if (!pp)
    6866. 

  6866.     return 0;
    6867. 

  6867.   if (soap->mode & SOAP_IO_LENGTH)
    6868. 

  6868.     return pp->mark1 == 0;
    6869. 

  6869.   return pp->mark2 == 0;
    6870. 

  6870. }
    6871. 

  6871. #endif
    6872. 

  6872. #endif
    6873. 

  6873. 

  6874. /******************************************************************************/
    6875. 

  6875. #ifndef WITH_NOIDREF
    6876. 

  6876. #ifndef PALM_2
    6877. 

  6877. SOAP_FMAC1
    6878. 

  6878. void
    6879. 

  6879. SOAP_FMAC2
    6880. 

  6880. soap_set_embedded(struct soap *soap, struct soap_plist *pp)
    6881. 

  6881. { if (!pp)
    6882. 

  6882.     return;
    6883. 

  6883.   if (soap->mode & SOAP_IO_LENGTH)
    6884. 

  6884.     pp->mark1 = 1;
    6885. 

  6885.   else
    6886. 

  6886.     pp->mark2 = 1;
    6887. 

  6887. }
    6888. 

  6888. #endif
    6889. 

  6889. #endif
    6890. 

  6890. 

  6891. /******************************************************************************/
    6892. 

  6892. #ifndef WITH_LEANER
    6893. 

  6893. #ifndef PALM_1
    6894. 

  6894. SOAP_FMAC1
    6895. 

  6895. int
    6896. 

  6896. SOAP_FMAC2
    6897. 

  6897. 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) 
    6898. 

  6898. {
    6899. 

  6899. #ifndef WITH_NOIDREF
    6900. 

  6900.   struct soap_plist *pp = NULL;         /* Oracle customization */
    6901. 

  6901.   int i;
    6902. 

  6902.   if (!p || !a->__ptr || (!aid && !atype))
    6903. 

  6903.     return soap_element_id(soap, tag, id, p, a, n, type, t);
    6904. 

  6904.   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));
    6905. 

  6905.   i = soap_array_pointer_lookup(soap, p, a, n, t, &pp);
    6906. 

  6906.   if (!i)
    6907. 

  6907.   { i = soap_pointer_enter(soap, p, a, n, t, &pp);
    6908. 

  6908.     if (!i)
    6909. 

  6909.     { soap->error = SOAP_EOM;
    6910. 

  6910.       return -1;
    6911. 

  6911.     }
    6912. 

  6912.   }
    6913. 

  6913.   if (id <= 0)
    6914. 

  6914.     id = i;
    6915. 

  6915.   if (!aid)
    6916. 

  6916.   { sprintf(soap->tmpbuf, soap->dime_id_format, id);
    6917. 

  6917.     aid = soap_strdup(soap, soap->tmpbuf);
    6918. 

  6918.   }
    6919. 

  6919.   /* Add MTOM xop:Include element when necessary */
    6920. 

  6920.   /* TODO: this code to be obsoleted with new import/xop.h conventions */
    6921. 

  6921.   if ((soap->mode & SOAP_ENC_MTOM) && strcmp(tag, "xop:Include"))
    6922. 

  6922.   { if (soap_element_begin_out(soap, tag, 0, type)
    6923. 

  6923.      || soap_element_href(soap, "xop:Include", 0, "xmlns:xop=\"http://www.w3.org/2004/08/xop/include\" href", aid)
    6924. 

  6924.      || soap_element_end_out(soap, tag))
    6925. 

  6925.       return soap->error;
    6926. 

  6926.   }
    6927. 

  6927.   else if (soap_element_href(soap, tag, 0, "href", aid))
    6928. 

  6928.     return soap->error;
    6929. 

  6929.   if (soap->mode & SOAP_IO_LENGTH)
    6930. 

  6930.   { if (pp && (pp->mark1 != 3))        /* Oracle customization */
    6931. 

  6931.     { struct soap_multipart *content;
    6932. 

  6932.       if (soap->mode & SOAP_ENC_MTOM)
    6933. 

  6933.         content = soap_new_multipart(soap, &soap->mime.first, &soap->mime.last, (char*)a->__ptr, a->__size);
    6934. 

  6934.       else
    6935. 

  6935.         content = soap_new_multipart(soap, &soap->dime.first, &soap->dime.last, (char*)a->__ptr, a->__size);
    6936. 

  6936.       if (!content)
    6937. 

  6937.       { soap->error = SOAP_EOM;
    6938. 

  6938.         return -1;
    6939. 

  6939.       }
    6940. 

  6940.       if (!strncmp(aid, "cid:", 4)) /* RFC 2111 */
    6941. 

  6941.       { if (soap->mode & SOAP_ENC_MTOM)
    6942. 

  6942.         { char *s = (char*)soap_malloc(soap, strlen(aid) - 1);
    6943. 

  6943.           if (s)
    6944. 

  6944.           { *s = '<';
    6945. 

  6945.             strcpy(s + 1, aid + 4);
    6946. 

  6946.             strcat(s, ">");
    6947. 

  6947.             content->id = s;
    6948. 

  6948.           }
    6949. 

  6949.         }
    6950. 

  6950.         else
    6951. 

  6951.           content->id = aid + 4;
    6952. 

  6952.       }
    6953. 

  6953.       else
    6954. 

  6954.         content->id = aid;
    6955. 

  6955.       content->type = atype;
    6956. 

  6956.       content->options = aoptions;
    6957. 

  6957.       content->encoding = SOAP_MIME_BINARY;
    6958. 

  6958.       pp->mark1 = 3;
    6959. 

  6959.     }
    6960. 

  6960.   }
    6961. 

  6961.   else if (pp)        /* Oracle customization */
    6962. 

  6962.     pp->mark2 = 3;
    6963. 

  6963. #endif
    6964. 

  6964.   return -1;
    6965. 

  6965. }
    6966. 

  6966. #endif
    6967. 

  6967. #endif
    6968. 

  6968. 

  6969. /******************************************************************************/
    6970. 

  6970. #ifndef WITH_NOIDREF
    6971. 

  6971. #ifndef PALM_1
    6972. 

  6972. static void
    6973. 

  6973. soap_init_iht(struct soap *soap)
    6974. 

  6974. { register int i;
    6975. 

  6975.   for (i = 0; i < SOAP_IDHASH; i++)
    6976. 

  6976.     soap->iht[i] = NULL;
    6977. 

  6977. }
    6978. 

  6978. #endif
    6979. 

  6979. #endif
    6980. 

  6980. 

  6981. /******************************************************************************/
    6982. 

  6982. #ifndef WITH_NOIDREF
    6983. 

  6983. #ifndef PALM_1
    6984. 

  6984. static void
    6985. 

  6985. soap_free_iht(struct soap *soap)
    6986. 

  6986. { register int i;
    6987. 

  6987.   register struct soap_ilist *ip = NULL, *p = NULL;
    6988. 

  6988.   register struct soap_flist *fp = NULL, *fq = NULL;
    6989. 

  6989.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free ID hashtable\n"));
    6990. 

  6990.   for (i = 0; i < SOAP_IDHASH; i++)
    6991. 

  6991.   { for (ip = soap->iht[i]; ip; ip = p)
    6992. 

  6992.     { for (fp = ip->flist; fp; fp = fq)
    6993. 

  6993.       { fq = fp->next;
    6994. 

  6994.         SOAP_FREE(soap, fp);
    6995. 

  6995.       }
    6996. 

  6996.       p = ip->next;
    6997. 

  6997.       SOAP_FREE(soap, ip);
    6998. 

  6998.     }
    6999. 

  6999.     soap->iht[i] = NULL;
    7000. 

  7000.   }
    7001. 

  7001. }
    7002. 

  7002. #endif
    7003. 

  7003. #endif
    7004. 

  7004. 

  7005. /******************************************************************************/
    7006. 

  7006. #ifndef WITH_NOIDREF
    7007. 

  7007. #ifndef PALM_2
    7008. 

  7008. SOAP_FMAC1
    7009. 

  7009. struct soap_ilist *
    7010. 

  7010. SOAP_FMAC2
    7011. 

  7011. soap_lookup(struct soap *soap, const char *id)
    7012. 

  7012. { register struct soap_ilist *ip = NULL;
    7013. 

  7013.   for (ip = soap->iht[soap_hash(id)]; ip; ip = ip->next)
    7014. 

  7014.     if (!strcmp(ip->id, id))
    7015. 

  7015.       return ip;
    7016. 

  7016.   return NULL;
    7017. 

  7017. }
    7018. 

  7018. #endif
    7019. 

  7019. #endif
    7020. 

  7020. 

  7021. /******************************************************************************/
    7022. 

  7022. #ifndef WITH_NOIDREF
    7023. 

  7023. #ifndef PALM_2
    7024. 

  7024. SOAP_FMAC1
    7025. 

  7025. struct soap_ilist *
    7026. 

  7026. SOAP_FMAC2
    7027. 

  7027. soap_enter(struct soap *soap, const char *id)
    7028. 

  7028. { register size_t h;
    7029. 

  7029.   register struct soap_ilist *ip;
    7030. 

  7030.   ip = (struct soap_ilist*)SOAP_MALLOC(soap, sizeof(struct soap_ilist) + strlen(id));
    7031. 

  7031.   if (ip)
    7032. 

  7032.   { h = soap_hash(id);
    7033. 

  7033.     strcpy(ip->id, id);
    7034. 

  7034.     ip->next = soap->iht[h];
    7035. 

  7035.     soap->iht[h] = ip;
    7036. 

  7036.   }
    7037. 

  7037.   return ip;
    7038. 

  7038. }
    7039. 

  7039. #endif
    7040. 

  7040. #endif
    7041. 

  7041. 

  7042. /******************************************************************************/
    7043. 

  7043. #ifndef PALM_2
    7044. 

  7044. SOAP_FMAC1
    7045. 

  7045. void*
    7046. 

  7046. SOAP_FMAC2
    7047. 

  7047. soap_malloc(struct soap *soap, size_t n)
    7048. 

  7048. { register char *p;
    7049. 

  7049.   if (!n)
    7050. 

  7050.     return (void*)SOAP_NON_NULL;
    7051. 

  7051.   if (!soap)
    7052. 

  7052.     return SOAP_MALLOC(soap, n);
    7053. 

  7053.   if (soap->fmalloc)
    7054. 

  7054.     p = (char*)soap->fmalloc(soap, n);
    7055. 

  7055.   else
    7056. 

  7056.   { n += sizeof(short);
    7057. 

  7057.     n += (-(long)n) & (sizeof(void*)-1); /* align at 4-, 8- or 16-byte boundary */
    7058. 

  7058.     if (!(p = (char*)SOAP_MALLOC(soap, n + sizeof(void*) + sizeof(size_t))))
    7059. 

  7059.     { soap->error = SOAP_EOM;
    7060. 

  7060.       return NULL;
    7061. 

  7061.     }
    7062. 

  7062.     /* set the canary to detect corruption */
    7063. 

  7063.     *(unsigned short*)(p + n - sizeof(unsigned short)) = (unsigned short)SOAP_CANARY;
    7064. 

  7064.     /* keep chain of alloced cells for destruction */
    7065. 

  7065.     *(void**)(p + n) = soap->alist;
    7066. 

  7066.     *(size_t*)(p + n + sizeof(void*)) = n;
    7067. 

  7067.     soap->alist = p + n;
    7068. 

  7068.   }
    7069. 

  7069.   soap->alloced = 1;
    7070. 

  7070.   return p;
    7071. 

  7071. }
    7072. 

  7072. #endif
    7073. 

  7073. 

  7074. /******************************************************************************/
    7075. 

  7075. #ifdef SOAP_MEM_DEBUG
    7076. 

  7076. static void
    7077. 

  7077. soap_init_mht(struct soap *soap)
    7078. 

  7078. { register int i;
    7079. 

  7079.   for (i = 0; i < (int)SOAP_PTRHASH; i++)
    7080. 

  7080.     soap->mht[i] = NULL;
    7081. 

  7081. }
    7082. 

  7082. #endif
    7083. 

  7083. 

  7084. /******************************************************************************/
    7085. 

  7085. #ifdef SOAP_MEM_DEBUG
    7086. 

  7086. static void
    7087. 

  7087. soap_free_mht(struct soap *soap)
    7088. 

  7088. { register int i;
    7089. 

  7089.   register struct soap_mlist *mp, *mq;
    7090. 

  7090.   for (i = 0; i < (int)SOAP_PTRHASH; i++)
    7091. 

  7091.   { for (mp = soap->mht[i]; mp; mp = mq)
    7092. 

  7092.     { mq = mp->next;
    7093. 

  7093.       if (mp->live)
    7094. 

  7094.       {
    7095. 

  7095.         fprintf(stderr, "%s(%d): malloc() = %p not freed (memory leak or forgot to call soap_end()?)\n", mp->file, mp->line, mp->ptr);
    7096. 

  7096. #ifndef WIN32
    7097. 

  7097.         (void) printstack( 2 );   /* Oracle customization */
    7098. 

  7098. #endif
    7099. 

  7099.       }
    7100. 

  7100.       free(mp);
    7101. 

  7101.     }
    7102. 

  7102.     soap->mht[i] = NULL;
    7103. 

  7103.   }
    7104. 

  7104. }
    7105. 

  7105. #endif
    7106. 

  7106. 

  7107. /******************************************************************************/
    7108. 

  7108. #ifdef SOAP_MEM_DEBUG
    7109. 

  7109. SOAP_FMAC1
    7110. 

  7110. void*
    7111. 

  7111. SOAP_FMAC2
    7112. 

  7112. soap_track_malloc(struct soap *soap, const char *file, int line, size_t size)
    7113. 

  7113. { register void *p = malloc(size);
    7114. 

  7114.   if (soap)
    7115. 

  7115.   { register size_t h = soap_hash_ptr(p);
    7116. 

  7116.     register struct soap_mlist *mp = (struct soap_mlist*)malloc(sizeof(struct soap_mlist));
    7117. 

  7117.     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "%s(%d): malloc(%lu) = %p\n", file, line, (unsigned long)size, p));
    7118. 

  7118.     mp->next = soap->mht[h];
    7119. 

  7119.     mp->ptr = p;
    7120. 

  7120.     mp->file = file;
    7121. 

  7121.     mp->line = line;
    7122. 

  7122.     mp->live = 1;
    7123. 

  7123.     soap->mht[h] = mp;
    7124. 

  7124.   }
    7125. 

  7125.   return p;
    7126. 

  7126. }
    7127. 

  7127. #endif
    7128. 

  7128. 

  7129. /******************************************************************************/
    7130. 

  7130. #ifdef SOAP_MEM_DEBUG
    7131. 

  7131. SOAP_FMAC1
    7132. 

  7132. void
    7133. 

  7133. SOAP_FMAC2
    7134. 

  7134. soap_track_free(struct soap *soap, const char *file, int line, void *p)
    7135. 

  7135. { register size_t h = soap_hash_ptr(p);
    7136. 

  7136.   register struct soap_mlist *mp;
    7137. 

  7137.   for (mp = soap->mht[h]; mp; mp = mp->next)
    7138. 

  7138.     if (mp->ptr == p)
    7139. 

  7139.       break;
    7140. 

  7140.   if (mp)
    7141. 

  7141.   { if (mp->live)
    7142. 

  7142.     { free(p);
    7143. 

  7143.       if (soap->fdebug[SOAP_INDEX_TEST])
    7144. 

  7144.       { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "%s(%d): free(%p)\n", file, line, p));
    7145. 

  7145.       }
    7146. 

  7146.       mp->live = 0;
    7147. 

  7147.     }
    7148. 

  7148.     else
    7149. 

  7149.       fprintf(stderr, "%s(%d): free(%p) double free of pointer malloced at %s(%d)\n", file, line, p, mp->file, mp->line);
    7150. 

  7150.   }
    7151. 

  7151.   else
    7152. 

  7152.     fprintf(stderr, "%s(%d): free(%p) pointer not malloced\n", file, line, p);
    7153. 

  7153. }
    7154. 

  7154. #endif
    7155. 

  7155. 

  7156. /******************************************************************************/
    7157. 

  7157. #ifdef SOAP_MEM_DEBUG
    7158. 

  7158. static void
    7159. 

  7159. soap_track_unlink(struct soap *soap, const void *p)
    7160. 

  7160. { register size_t h = soap_hash_ptr(p);
    7161. 

  7161.   register struct soap_mlist *mp;
    7162. 

  7162.   for (mp = soap->mht[h]; mp; mp = mp->next)
    7163. 

  7163.     if (mp->ptr == p)
    7164. 

  7164.       break;
    7165. 

  7165.   if (mp)
    7166. 

  7166.     mp->live = 0;
    7167. 

  7167. }
    7168. 

  7168. #endif
    7169. 

  7169. 

  7170. /******************************************************************************/
    7171. 

  7171. #ifndef PALM_2
    7172. 

  7172. SOAP_FMAC1
    7173. 

  7173. void
    7174. 

  7174. SOAP_FMAC2
    7175. 

  7175. soap_dealloc(struct soap *soap, void *p)
    7176. 

  7176. { if (soap_check_state(soap))
    7177. 

  7177.     return;
    7178. 

  7178.   if (p)
    7179. 

  7179.   { register char **q;
    7180. 

  7180.     for (q = (char**)&soap->alist; *q; q = *(char***)q)
    7181. 

  7181.     { 
    7182. 

  7182.       if (*(unsigned short*)(char*)(*q - sizeof(unsigned short)) != (unsigned short)SOAP_CANARY)
    7183. 

  7183.       {
    7184. 

  7184. #ifdef SOAP_MEM_DEBUG
    7185. 

  7185.         fprintf(stderr, "Data corruption in dynamic allocation (see logs)\n");
    7186. 

  7186. #endif
    7187. 

  7187.         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Data corruption:\n"));
    7188. 

  7188.         DBGHEX(TEST, *q - 200, 200);
    7189. 

  7189.         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "\n"));
    7190. 

  7190.         soap->error = SOAP_MOE;
    7191. 

  7191.         return;
    7192. 

  7192.       }
    7193. 

  7193.       if (p == (void*)(*q - *(size_t*)(*q + sizeof(void*))))
    7194. 

  7194.       { *q = **(char***)q;
    7195. 

  7195.         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Freed data at %p\n", p));
    7196. 

  7196.         SOAP_FREE(soap, p);
    7197. 

  7197.         return;
    7198. 

  7198.       }
    7199. 

  7199.     }
    7200. 

  7200.     soap_delete(soap, p);
    7201. 

  7201.   }
    7202. 

  7202.   else
    7203. 

  7203.   { register char *q;
    7204. 

  7204.     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free all soap_malloc() data\n"));
    7205. 

  7205.     while (soap->alist)
    7206. 

  7206.     { q = (char*)soap->alist;
    7207. 

  7207.       if (*(unsigned short*)(char*)(q - sizeof(unsigned short)) != (unsigned short)SOAP_CANARY)
    7208. 

  7208.       {
    7209. 

  7209. #ifdef SOAP_MEM_DEBUG
    7210. 

  7210.         fprintf(stderr, "Data corruption in dynamic allocation (see logs)\n");
    7211. 

  7211. #endif
    7212. 

  7212.         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Data corruption:\n"));
    7213. 

  7213.         DBGHEX(TEST, q - 200, 200);
    7214. 

  7214.         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "\n"));
    7215. 

  7215.         soap->error = SOAP_MOE;
    7216. 

  7216.         return;
    7217. 

  7217.       }
    7218. 

  7218.       soap->alist = *(void**)q;
    7219. 

  7219.       q -= *(size_t*)(q + sizeof(void*));
    7220. 

  7220.       SOAP_FREE(soap, q);
    7221. 

  7221.     }
    7222. 

  7222.     /* we must assume these were deallocated: */
    7223. 

  7223.     soap->action = NULL;
    7224. 

  7224.     soap->fault = NULL;
    7225. 

  7225.     soap->header = NULL;
    7226. 

  7226.     soap->userid = NULL;
    7227. 

  7227.     soap->passwd = NULL;
    7228. 

  7228.     soap->authrealm = NULL;
    7229. 

  7229.     soap->http_content = NULL;
    7230. 

  7230. #ifndef WITH_LEANER
    7231. 

  7231.     soap_clr_mime(soap);
    7232. 

  7232. #endif
    7233. 

  7233.   }
    7234. 

  7234. }
    7235. 

  7235. #endif
    7236. 

  7236. 

  7237. /******************************************************************************/
    7238. 

  7238. #ifndef PALM_2
    7239. 

  7239. SOAP_FMAC1
    7240. 

  7240. void
    7241. 

  7241. SOAP_FMAC2
    7242. 

  7242. soap_delete(struct soap *soap, void *p)
    7243. 

  7243. { register struct soap_clist **cp;
    7244. 

  7244.   if (soap_check_state(soap))
    7245. 

  7245.     return;
    7246. 

  7246.   cp = &soap->clist;
    7247. 

  7247.   if (p)
    7248. 

  7248.   { while (*cp)
    7249. 

  7249.     { if (p == (*cp)->ptr)
    7250. 

  7250.       { register struct soap_clist *q = *cp;
    7251. 

  7251.         *cp = q->next;
    7252. 

  7252.         if (q->fdelete(q))
    7253. 

  7253.         { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not dealloc data %p: deletion callback failed for object type %d\n", q->ptr, q->type));
    7254. 

  7254. #ifdef SOAP_MEM_DEBUG
    7255. 

  7255.           fprintf(stderr, "new(object type = %d) = %p not freed: deletion callback failed\n", q->type, q->ptr);
    7256. 

  7256. #endif
    7257. 

  7257.         }
    7258. 

  7258.         SOAP_FREE(soap, q);
    7259. 

  7259.         return;
    7260. 

  7260.       }
    7261. 

  7261.       cp = &(*cp)->next;
    7262. 

  7262.     }
    7263. 

  7263.     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not dealloc data %p: address not in list\n", p));
    7264. 

  7264.   }
    7265. 

  7265.   else
    7266. 

  7266.   { while (*cp)
    7267. 

  7267.     { register struct soap_clist *q = *cp;
    7268. 

  7268.       *cp = q->next;
    7269. 

  7269.       if (q->fdelete(q))
    7270. 

  7270.       { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not dealloc data %p: deletion callback failed for object type %d\n", q->ptr, q->type));
    7271. 

  7271. #ifdef SOAP_MEM_DEBUG
    7272. 

  7272.         fprintf(stderr, "new(object type = %d) = %p not freed: deletion callback failed\n", q->type, q->ptr);
    7273. 

  7273. #endif
    7274. 

  7274.       }
    7275. 

  7275.       SOAP_FREE(soap, q);
    7276. 

  7276.     }
    7277. 

  7277.   }
    7278. 

  7278.   soap->fault = NULL; /* this was possibly deallocated */
    7279. 

  7279.   soap->header = NULL; /* this was possibly deallocated */
    7280. 

  7280. }
    7281. 

  7281. #endif
    7282. 

  7282. 

  7283. /******************************************************************************/
    7284. 

  7284. #ifndef PALM_2
    7285. 

  7285. SOAP_FMAC1
    7286. 

  7286. void
    7287. 

  7287. SOAP_FMAC2
    7288. 

  7288. soap_delegate_deletion(struct soap *soap, struct soap *soap_to)
    7289. 

  7289. { register struct soap_clist *cp;
    7290. 

  7290.   register char **q;
    7291. 

  7291. #ifdef SOAP_MEM_DEBUG
    7292. 

  7292.   register void *p;
    7293. 

  7293.   register struct soap_mlist **mp, *mq;
    7294. 

  7294.   size_t h;
    7295. 

  7295. #endif
    7296. 

  7296.   for (q = (char**)&soap->alist; *q; q = *(char***)q)
    7297. 

  7297.   {
    7298. 

  7298.     if (*(unsigned short*)(char*)(*q - sizeof(unsigned short)) != (unsigned short)SOAP_CANARY)
    7299. 

  7299.     {
    7300. 

  7300. #ifdef SOAP_MEM_DEBUG
    7301. 

  7301.       fprintf(stderr, "Data corruption in dynamic allocation (see logs)\n");
    7302. 

  7302. #endif
    7303. 

  7303.       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Data corruption:\n"));
    7304. 

  7304.       DBGHEX(TEST, *q - 200, 200);
    7305. 

  7305.       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "\n"));
    7306. 

  7306.       soap->error = SOAP_MOE;
    7307. 

  7307.       return;
    7308. 

  7308.     }
    7309. 

  7309. #ifdef SOAP_MEM_DEBUG
    7310. 

  7310.     p = (void*)(*q - *(size_t*)(*q + sizeof(void*)));
    7311. 

  7311.     h = soap_hash_ptr(p);
    7312. 

  7312.     for (mp = &soap->mht[h]; *mp; mp = &(*mp)->next)
    7313. 

  7313.     { if ((*mp)->ptr == p)
    7314. 

  7314.       { mq = *mp;
    7315. 

  7315.         *mp = mq->next;
    7316. 

  7316. 	mq->next = soap_to->mht[h];
    7317. 

  7317.         soap_to->mht[h] = mq;
    7318. 

  7318.         break;
    7319. 

  7319.       }
    7320. 

  7320.     }
    7321. 

  7321. #endif
    7322. 

  7322.   }
    7323. 

  7323.   *q = (char*)soap_to->alist;
    7324. 

  7324.   soap_to->alist = soap->alist;
    7325. 

  7325.   soap->alist = NULL;
    7326. 

  7326.   cp = soap_to->clist;
    7327. 

  7327.   if (cp)
    7328. 

  7328.   { while (cp->next)
    7329. 

  7329.       cp = cp->next;
    7330. 

  7330.     cp->next = soap->clist;
    7331. 

  7331.   }
    7332. 

  7332.   else
    7333. 

  7333.     soap_to->clist = soap->clist;
    7334. 

  7334.   soap->clist = NULL;
    7335. 

  7335. }
    7336. 

  7336. #endif
    7337. 

  7337. 

  7338. /******************************************************************************/
    7339. 

  7339. #ifndef PALM_2
    7340. 

  7340. SOAP_FMAC1
    7341. 

  7341. struct soap_clist *
    7342. 

  7342. SOAP_FMAC2
    7343. 

  7343. soap_link(struct soap *soap, void *p, int t, int n, int (*fdelete)(struct soap_clist*))
    7344. 

  7344. { register struct soap_clist *cp;
    7345. 

  7345.   if ((cp = (struct soap_clist*)SOAP_MALLOC(soap, sizeof(struct soap_clist))))
    7346. 

  7346.   { cp->next = soap->clist;
    7347. 

  7347.     cp->type = t;
    7348. 

  7348.     cp->size = n; 
    7349. 

  7349.     cp->ptr = p;
    7350. 

  7350.     cp->fdelete = fdelete;
    7351. 

  7351.     soap->clist = cp;
    7352. 

  7352.   }
    7353. 

  7353.   return cp;
    7354. 

  7354. }
    7355. 

  7355. #endif
    7356. 

  7356. 

  7357. /******************************************************************************/
    7358. 

  7358. #ifndef PALM_2
    7359. 

  7359. SOAP_FMAC1
    7360. 

  7360. void
    7361. 

  7361. SOAP_FMAC2
    7362. 

  7362. soap_unlink(struct soap *soap, const void *p)
    7363. 

  7363. { register char **q;
    7364. 

  7364.   register struct soap_clist **cp;
    7365. 

  7365.   if (!soap || !p)
    7366. 

  7366.     return;
    7367. 

  7367.   for (q = (char**)&soap->alist; *q; q = *(char***)q)
    7368. 

  7368.   { if (p == (void*)(*q - *(size_t*)(*q + sizeof(void*))))
    7369. 

  7369.     { *q = **(char***)q;
    7370. 

  7370.       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unlinked data %p\n", p));
    7371. 

  7371. #ifdef SOAP_MEM_DEBUG
    7372. 

  7372.       soap_track_unlink(soap, p);
    7373. 

  7373. #endif
    7374. 

  7374.       return;
    7375. 

  7375.     }
    7376. 

  7376.   }
    7377. 

  7377.   for (cp = &soap->clist; *cp; cp = &(*cp)->next)
    7378. 

  7378.   { if (p == (*cp)->ptr)
    7379. 

  7379.     { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unlinked class instance %p\n", p));
    7380. 

  7380.       q = (char**)*cp;
    7381. 

  7381.       *cp = (*cp)->next;
    7382. 

  7382.       SOAP_FREE(soap, q);
    7383. 

  7383.       return;
    7384. 

  7384.     }
    7385. 

  7385.   }
    7386. 

  7386. }
    7387. 

  7387. #endif
    7388. 

  7388. 

  7389. /******************************************************************************/
    7390. 

  7390. #ifndef WITH_NOIDREF
    7391. 

  7391. #ifndef PALM_2
    7392. 

  7392. SOAP_FMAC1
    7393. 

  7393. int
    7394. 

  7394. SOAP_FMAC2
    7395. 

  7395. soap_lookup_type(struct soap *soap, const char *id)
    7396. 

  7396. { register struct soap_ilist *ip;
    7397. 

  7397.   if (id && *id)
    7398. 

  7398.   { ip = soap_lookup(soap, id);
    7399. 

  7399.     if (ip)
    7400. 

  7400.     { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Lookup id='%s' type=%d\n", id, ip->type));
    7401. 

  7401.       return ip->type;
    7402. 

  7402.     }
    7403. 

  7403.   }
    7404. 

  7404.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "lookup type id='%s' NOT FOUND! Need to get it from xsi:type\n", id));
    7405. 

  7405.   return 0;
    7406. 

  7406. }
    7407. 

  7407. #endif
    7408. 

  7408. #endif
    7409. 

  7409. 

  7410. /******************************************************************************/
    7411. 

  7411. #ifndef WITH_NOIDREF
    7412. 

  7412. #ifndef PALM_2
    7413. 

  7413. SOAP_FMAC1
    7414. 

  7414. void*
    7415. 

  7415. SOAP_FMAC2
    7416. 

  7416. soap_id_lookup(struct soap *soap, const char *id, void **p, int t, size_t n, unsigned int k)
    7417. 

  7417. { struct soap_ilist *ip;
    7418. 

  7418.   void **q;
    7419. 

  7419.   if (!p || !id || !*id)
    7420. 

  7420.     return p;
    7421. 

  7421.   ip = soap_lookup(soap, id); /* lookup pointer to hash table entry for string id */
    7422. 

  7422.   if (!ip)
    7423. 

  7423.   { if (!(ip = soap_enter(soap, id))) /* new hash table entry for string id */
    7424. 

  7424.       return NULL;
    7425. 

  7425.     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Forwarding first href='%s' type=%d %p (%u bytes)\n", id, t, p, (unsigned int)n));
    7426. 

  7426.     ip->type = t;
    7427. 

  7427.     ip->size = n; 
    7428. 

  7428.     ip->link = p;
    7429. 

  7429.     ip->copy = NULL;
    7430. 

  7430.     ip->flist = NULL;
    7431. 

  7431.     ip->ptr = NULL;
    7432. 

  7432.     ip->level = k;
    7433. 

  7433.     *p = NULL;
    7434. 

  7434.   }
    7435. 

  7435.   else if (ip->ptr)
    7436. 

  7436.   { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Resolved href='%s' type=%d location=%p (%u bytes)\n", id, t, ip->ptr, (unsigned int)n));
    7437. 

  7437.     if (ip->type != t)
    7438. 

  7438.     { 
    7439. 

  7439.       /* Oracle customization */
    7440. 

  7440.       strncpy(soap->id, id, sizeof(soap->id) - 1);
    7441. 

  7441.       soap->id[sizeof(soap->id) - 1] = '\0';
    7442. 

  7442.       soap->error = SOAP_HREF;
    7443. 

  7443.       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Type incompatibility: href='%s' id-type=%d href-type=%d\n", id, ip->type, t));
    7444. 

  7444.       return NULL;
    7445. 

  7445.     }
    7446. 

  7446.     while (ip->level < k)
    7447. 

  7447.     { q = (void**)soap_malloc(soap, sizeof(void*));  
    7448. 

  7448.       if (!q)
    7449. 

  7449.         return NULL;
    7450. 

  7450.       *p = (void*)q;
    7451. 

  7451.       p = q;
    7452. 

  7452.       k--;
    7453. 

  7453.       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Descending one level...\n"));
    7454. 

  7454.     }
    7455. 

  7455.     *p = ip->ptr;
    7456. 

  7456.   }
    7457. 

  7457.   else if (ip->level > k)
    7458. 

  7458.   { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Resolving level %u pointers to href='%s'\n", ip->level, id));
    7459. 

  7459.     while (ip->level > k)
    7460. 

  7460.     { void *s, **r = &ip->link;
    7461. 

  7461.       q = (void**)ip->link;
    7462. 

  7462.       while (q)
    7463. 

  7463.       { *r = (void*)soap_malloc(soap, sizeof(void*));
    7464. 

  7464.         if (!*r)
    7465. 

  7465. 	  return NULL;
    7466. 

  7466.         s = *q;
    7467. 

  7467.         *q = *r;
    7468. 

  7468.         r = (void**)*r;
    7469. 

  7469.         q = (void**)s;
    7470. 

  7470.       }
    7471. 

  7471.       *r = NULL;
    7472. 

  7472.       ip->size = n; 
    7473. 

  7473.       ip->copy = NULL;
    7474. 

  7474.       ip->level = ip->level - 1;
    7475. 

  7475.       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Descending one level...\n"));
    7476. 

  7476.     }
    7477. 

  7477.     q = (void**)ip->link;
    7478. 

  7478.     ip->link = p;
    7479. 

  7479.     *p = (void*)q;
    7480. 

  7480.   }
    7481. 

  7481.   else
    7482. 

  7482.   { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Forwarded href='%s' type=%d location=%p (%u bytes)\n", id, t, p, (unsigned int)n));
    7483. 

  7483.     while (ip->level < k)
    7484. 

  7484.     { q = (void**)soap_malloc(soap, sizeof(void*));  
    7485. 

  7485.       if (!q)
    7486. 

  7486.         return NULL;
    7487. 

  7487.       *p = q;
    7488. 

  7488.       p = q;
    7489. 

  7489.       k--;
    7490. 

  7490.       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Descending one level...\n"));
    7491. 

  7491.     }
    7492. 

  7492.     q = (void**)ip->link;
    7493. 

  7493.     ip->link = p;
    7494. 

  7494.     *p = (void*)q;
    7495. 

  7495.   }
    7496. 

  7496.   return p;
    7497. 

  7497. }
    7498. 

  7498. #endif
    7499. 

  7499. #endif
    7500. 

  7500. 

  7501. /******************************************************************************/
    7502. 

  7502. #ifndef WITH_NOIDREF
    7503. 

  7503. #ifndef PALM_2
    7504. 

  7504. SOAP_FMAC1
    7505. 

  7505. void*
    7506. 

  7506. SOAP_FMAC2
    7507. 

  7507. 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))
    7508. 

  7508. { struct soap_ilist *ip;
    7509. 

  7509.   if (!p || !href || !*href)
    7510. 

  7510.     return p;
    7511. 

  7511.   ip = soap_lookup(soap, href); /* lookup pointer to hash table entry for string id */
    7512. 

  7512.   if (!ip)
    7513. 

  7513.   { if (!(ip = soap_enter(soap, href))) /* new hash table entry for string id */
    7514. 

  7514.       return NULL;
    7515. 

  7515.     ip->type = st;
    7516. 

  7516.     ip->size = n;
    7517. 

  7517.     ip->link = NULL;
    7518. 

  7518.     ip->copy = NULL;
    7519. 

  7519.     ip->ptr = NULL;
    7520. 

  7520.     ip->level = 0;
    7521. 

  7521.     ip->flist = NULL;
    7522. 

  7522.     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));
    7523. 

  7523.   }
    7524. 

  7524.   else if (ip->type != st || (ip->level == k && ip->size != n))
    7525. 

  7525.   { 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));
    7526. 

  7526.     /* Oracle customization */
    7527. 

  7527.     strncpy(soap->id, href, sizeof(soap->id) - 1);
    7528. 

  7528.     soap->id[sizeof(soap->id) - 1] = '\0';
    7529. 

  7529.     soap->error = SOAP_HREF;
    7530. 

  7530.     return NULL;
    7531. 

  7531.   }
    7532. 

  7532.   if (fcopy || n < sizeof(void*) || *href != '#')
    7533. 

  7533.   { register struct soap_flist *fp = (struct soap_flist*)SOAP_MALLOC(soap, sizeof(struct soap_flist));
    7534. 

  7534.     if (!fp)
    7535. 

  7535.     { soap->error = SOAP_EOM;
    7536. 

  7536.       return NULL;
    7537. 

  7537.     }
    7538. 

  7538.     fp->next = ip->flist;
    7539. 

  7539.     fp->type = tt;
    7540. 

  7540.     fp->ptr = p;
    7541. 

  7541.     fp->level = k;
    7542. 

  7542.     fp->len = len;
    7543. 

  7543.     if (fcopy)
    7544. 

  7544.       fp->fcopy = fcopy;
    7545. 

  7545.     else
    7546. 

  7546.       fp->fcopy = soap_fcopy;
    7547. 

  7547.     ip->flist = fp;
    7548. 

  7548.     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));
    7549. 

  7549.   }
    7550. 

  7550.   else
    7551. 

  7551.   { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Forwarding copying address %p for type=%d href='%s'\n", p, st, href));
    7552. 

  7552.     *(void**)p = ip->copy;
    7553. 

  7553.     ip->copy = p;
    7554. 

  7554.   }
    7555. 

  7555.   return p;
    7556. 

  7556. }
    7557. 

  7557. #endif
    7558. 

  7558. #endif
    7559. 

  7559. 

  7560. /******************************************************************************/
    7561. 

  7561. #ifndef PALM_2
    7562. 

  7562. SOAP_FMAC1
    7563. 

  7563. void*
    7564. 

  7564. SOAP_FMAC2
    7565. 

  7565. 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*))
    7566. 

  7566. {
    7567. 

  7567. #ifndef WITH_NOIDREF
    7568. 

  7568.   struct soap_ilist *ip;
    7569. 

  7569. #endif
    7570. 

  7570.   DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Enter id='%s' type=%d loc=%p size=%lu level=%u\n", id, t, p, (unsigned long)n, k));
    7571. 

  7571.   soap->alloced = 0;
    7572. 

  7572.   if (!p)
    7573. 

  7573.   { if (finstantiate)
    7574. 

  7574.       p = finstantiate(soap, t, type, arrayType, &n);
    7575. 

  7575.     else
    7576. 

  7576.       p = soap_malloc(soap, n);
    7577. 

  7577.     if (p)
    7578. 

  7578.       soap->alloced = 1;
    7579. 

  7579.   }
    7580. 

  7580. #ifndef WITH_NOIDREF
    7581. 

  7581.   if (!id || !*id)
    7582. 

  7582. #endif
    7583. 

  7583.     return p;
    7584. 

  7584. #ifndef WITH_NOIDREF
    7585. 

  7585.   ip = soap_lookup(soap, id); /* lookup pointer to hash table entry for string id */
    7586. 

  7586.   DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Lookup entry id='%s for location=%p'\n", id, p));
    7587. 

  7587.   if (!ip)
    7588. 

  7588.   { if (!(ip = soap_enter(soap, id))) /* new hash table entry for string id */
    7589. 

  7589.       return NULL;
    7590. 

  7590.     ip->type = t;
    7591. 

  7591.     ip->link = NULL;
    7592. 

  7592.     ip->copy = NULL;
    7593. 

  7593.     ip->flist = NULL;
    7594. 

  7594.     ip->size = n;
    7595. 

  7595.     ip->ptr = p;
    7596. 

  7596.     ip->level = k;
    7597. 

  7597.     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));
    7598. 

  7598.   }
    7599. 

  7599.   else if ((ip->type != t || (ip->level == k && ip->size != n)) && (ip->copy || ip->flist))
    7600. 

  7600.   { 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));
    7601. 

  7601.     /* Oracle customization */
    7602. 

  7602.     strncpy(soap->id, id, sizeof(soap->id) - 1);
    7603. 

  7603.     soap->id[sizeof(soap->id) - 1] = '\0';
    7604. 

  7604.     soap->error = SOAP_HREF;
    7605. 

  7605.     return NULL;
    7606. 

  7606.   }
    7607. 

  7607.   else if (ip->ptr)
    7608. 

  7608.   { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Multiply defined id='%s'\n", id));
    7609. 

  7609.     /* Oracle customization */
    7610. 

  7610.     strncpy(soap->id, id, sizeof(soap->id) - 1);
    7611. 

  7611.     soap->id[sizeof(soap->id) - 1] = '\0';
    7612. 

  7612.     soap->error = SOAP_DUPLICATE_ID;
    7613. 

  7613.     return NULL;
    7614. 

  7614.   }
    7615. 

  7615.   else 
    7616. 

  7616.   { ip->size = n;
    7617. 

  7617.     ip->ptr = p;
    7618. 

  7618.     ip->level = k;
    7619. 

  7619.     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));
    7620. 

  7620.   }
    7621. 

  7621.   return ip->ptr;
    7622. 

  7622. #endif
    7623. 

  7623. }
    7624. 

  7624. #endif
    7625. 

  7625. 

  7626. /******************************************************************************/
    7627. 

  7627. #ifndef PALM_2
    7628. 

  7628. SOAP_FMAC1
    7629. 

  7629. void
    7630. 

  7630. SOAP_FMAC2
    7631. 

  7631. soap_fcopy(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
    7632. 

  7632. { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Copying data type=%d (target type=%d) %p -> %p (%lu bytes)\n", st, tt, q, p, (unsigned long)n));
    7633. 

  7633.   memcpy(p, q, n);
    7634. 

  7634. }
    7635. 

  7635. #endif
    7636. 

  7636. 

  7637. /******************************************************************************/
    7638. 

  7638. #ifndef PALM_1
    7639. 

  7639. SOAP_FMAC1
    7640. 

  7640. int
    7641. 

  7641. SOAP_FMAC2
    7642. 

  7642. soap_end_send(struct soap *soap)
    7643. 

  7643. { 
    7644. 

  7644. #ifndef WITH_LEANER
    7645. 

  7645.   int err;
    7646. 

  7646.   if (soap->dime.list)
    7647. 

  7647.   { /* SOAP body referenced attachments must appear first */
    7648. 

  7648.     soap->dime.last->next = soap->dime.first;
    7649. 

  7649.     soap->dime.first = soap->dime.list->next;
    7650. 

  7650.     soap->dime.list->next = NULL;
    7651. 

  7651.     soap->dime.last = soap->dime.list;
    7652. 

  7652.   }
    7653. 

  7653.   if (!(err = soap_putdime(soap)))
    7654. 

  7654.     err = soap_putmime(soap);
    7655. 

  7655.   soap->mime.list = NULL;
    7656. 

  7656.   soap->mime.first = NULL;
    7657. 

  7657.   soap->mime.last = NULL;
    7658. 

  7658.   soap->dime.list = NULL;
    7659. 

  7659.   soap->dime.first = NULL;
    7660. 

  7660.   soap->dime.last = NULL;
    7661. 

  7661.   if (err)
    7662. 

  7662.     return err;
    7663. 

  7663. #endif
    7664. 

  7664.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End send\n"));
    7665. 

  7665.   if (soap->mode & SOAP_IO) /* need to flush the remaining data in buffer */
    7666. 

  7666.   { if (soap_flush(soap))
    7667. 

  7667. #ifdef WITH_ZLIB
    7668. 

  7668.     { if (soap->mode & SOAP_ENC_ZLIB && soap->zlib_state == SOAP_ZLIB_DEFLATE)
    7669. 

  7669.       { soap->zlib_state = SOAP_ZLIB_NONE;
    7670. 

  7670.         deflateEnd(soap->d_stream);
    7671. 

  7671.       }
    7672. 

  7672.       return soap->error;
    7673. 

  7673.     }
    7674. 

  7674. #else
    7675. 

  7675.       return soap->error;
    7676. 

  7676. #endif
    7677. 

  7677. #ifdef WITH_ZLIB
    7678. 

  7678.     if (soap->mode & SOAP_ENC_ZLIB)
    7679. 

  7679.     { int r;
    7680. 

  7680.       soap->d_stream->avail_in = 0;
    7681. 

  7681.       do
    7682. 

  7682.       { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Deflating remainder\n"));
    7683. 

  7683.         r = deflate(soap->d_stream, Z_FINISH);
    7684. 

  7684.         if (soap->d_stream->avail_out != SOAP_BUFLEN)
    7685. 

  7685.         { if (soap_flush_raw(soap, soap->z_buf, SOAP_BUFLEN - soap->d_stream->avail_out))
    7686. 

  7686.           { soap->zlib_state = SOAP_ZLIB_NONE;
    7687. 

  7687.             deflateEnd(soap->d_stream);
    7688. 

  7688.             return soap->error;
    7689. 

  7689.           }
    7690. 

  7690.           soap->d_stream->next_out = (Byte*)soap->z_buf;
    7691. 

  7691.           soap->d_stream->avail_out = SOAP_BUFLEN;
    7692. 

  7692.         }
    7693. 

  7693.       } while (r == Z_OK);
    7694. 

  7694.       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Deflated total %lu->%lu bytes\n", soap->d_stream->total_in, soap->d_stream->total_out));
    7695. 

  7695.       soap->z_ratio_out = (float)soap->d_stream->total_out / (float)soap->d_stream->total_in;
    7696. 

  7696.       soap->mode &= ~SOAP_ENC_ZLIB;
    7697. 

  7697.       soap->zlib_state = SOAP_ZLIB_NONE;
    7698. 

  7698.       if (deflateEnd(soap->d_stream) != Z_OK || r != Z_STREAM_END)
    7699. 

  7699.       { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unable to end deflate: %s\n", soap->d_stream->msg?soap->d_stream->msg:SOAP_STR_EOS));
    7700. 

  7700.         return soap->error = SOAP_ZLIB_ERROR;
    7701. 

  7701.       }
    7702. 

  7702. #ifdef WITH_GZIP
    7703. 

  7703.       if (soap->zlib_out != SOAP_ZLIB_DEFLATE)
    7704. 

  7704.       { soap->z_buf[0] = soap->z_crc & 0xFF;
    7705. 

  7705.         soap->z_buf[1] = (soap->z_crc >> 8) & 0xFF;
    7706. 

  7706.         soap->z_buf[2] = (soap->z_crc >> 16) & 0xFF;
    7707. 

  7707.         soap->z_buf[3] = (soap->z_crc >> 24) & 0xFF;
    7708. 

  7708.         soap->z_buf[4] = soap->d_stream->total_in & 0xFF;
    7709. 

  7709.         soap->z_buf[5] = (soap->d_stream->total_in >> 8) & 0xFF;
    7710. 

  7710.         soap->z_buf[6] = (soap->d_stream->total_in >> 16) & 0xFF;
    7711. 

  7711.         soap->z_buf[7] = (soap->d_stream->total_in >> 24) & 0xFF;
    7712. 

  7712.         if (soap_flush_raw(soap, soap->z_buf, 8))
    7713. 

  7713.           return soap->error;
    7714. 

  7714.         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "gzip crc32=%lu\n", (unsigned long)soap->z_crc));
    7715. 

  7715.       }
    7716. 

  7716. #endif
    7717. 

  7717.     }
    7718. 

  7718. #endif
    7719. 

  7719.     if ((soap->mode & SOAP_IO) == SOAP_IO_STORE)
    7720. 

  7720.     { char *p;
    7721. 

  7721. #ifndef WITH_NOHTTP
    7722. 

  7722.       if (!(soap->mode & SOAP_ENC_XML))
    7723. 

  7723.       { soap->mode--;
    7724. 

  7724.         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Sending buffered message of length %u\n", (unsigned int)soap->blist->size));
    7725. 

  7725.         if (soap->status >= SOAP_POST)
    7726. 

  7726.           soap->error = soap->fpost(soap, soap->endpoint, soap->host, soap->port, soap->path, soap->action, soap->blist->size);
    7727. 

  7727.         else if (soap->status != SOAP_STOP)
    7728. 

  7728.           soap->error = soap->fresponse(soap, soap->status, soap->blist->size);
    7729. 

  7729.         if (soap->error || soap_flush(soap))
    7730. 

  7730.           return soap->error;
    7731. 

  7731.         soap->mode++;
    7732. 

  7732.       }
    7733. 

  7733. #endif
    7734. 

  7734.       for (p = soap_first_block(soap, NULL); p; p = soap_next_block(soap, NULL))
    7735. 

  7735.       { DBGMSG(SENT, p, soap_block_size(soap, NULL));
    7736. 

  7736.         if ((soap->error = soap->fsend(soap, p, soap_block_size(soap, NULL))))
    7737. 

  7737.         { soap_end_block(soap, NULL);
    7738. 

  7738.           return soap->error;
    7739. 

  7739.         }
    7740. 

  7740.       }
    7741. 

  7741.       soap_end_block(soap, NULL);
    7742. 

  7742.     }
    7743. 

  7743. #ifndef WITH_LEANER
    7744. 

  7744.     else if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK)
    7745. 

  7745.     { DBGMSG(SENT, "\r\n0\r\n\r\n", 7);
    7746. 

  7746.       if ((soap->error = soap->fsend(soap, "\r\n0\r\n\r\n", 7)))
    7747. 

  7747.         return soap->error;
    7748. 

  7748.     }
    7749. 

  7749. #endif
    7750. 

  7750.   }
    7751. 

  7751. #ifdef WITH_TCPFIN
    7752. 

  7752. #ifdef WITH_OPENSSL
    7753. 

  7753.   if (!soap->ssl && soap_valid_socket(soap->socket) && !soap->keep_alive && !(soap->omode & SOAP_IO_UDP))
    7754. 

  7754.     soap->fshutdownsocket(soap, soap->socket, 1); /* Send TCP FIN */
    7755. 

  7755. #else
    7756. 

  7756.   if (soap_valid_socket(soap->socket) && !soap->keep_alive && !(soap->omode & SOAP_IO_UDP))
    7757. 

  7757.     soap->fshutdownsocket(soap, soap->socket, 1); /* Send TCP FIN */
    7758. 

  7758. #endif
    7759. 

  7759. #endif
    7760. 

  7760.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End of send phase\n"));
    7761. 

  7761.   soap->omode &= ~SOAP_XML_SEC;
    7762. 

  7762.   soap->count = 0;
    7763. 

  7763.   soap->part = SOAP_END;
    7764. 

  7764.   return SOAP_OK;
    7765. 

  7765. }
    7766. 

  7766. #endif
    7767. 

  7767. 

  7768. /******************************************************************************/
    7769. 

  7769. #ifndef PALM_1
    7770. 

  7770. SOAP_FMAC1
    7771. 

  7771. int
    7772. 

  7772. SOAP_FMAC2
    7773. 

  7773. soap_end_recv(struct soap *soap)
    7774. 

  7774. { soap->part = SOAP_END;
    7775. 

  7775. #ifndef WITH_LEAN
    7776. 

  7776.   soap->wsuid = NULL;		/* reset before next send */
    7777. 

  7777.   soap->c14nexclude = NULL;	/* reset before next send */
    7778. 

  7778. #endif
    7779. 

  7779. #ifndef WITH_LEANER
    7780. 

  7780.   if ((soap->mode & SOAP_ENC_DIME) && soap_getdime(soap))
    7781. 

  7781.   { soap->dime.first = NULL;
    7782. 

  7782.     soap->dime.last = NULL;
    7783. 

  7783.     return soap->error;
    7784. 

  7784.   }
    7785. 

  7785.   soap->dime.list = soap->dime.first;
    7786. 

  7786.   soap->dime.first = NULL;
    7787. 

  7787.   soap->dime.last = NULL;
    7788. 

  7788.   /* Check if MIME attachments and mime-post-check flag is set, if set call soap_resolve() and return */
    7789. 

  7789.   if (soap->mode & SOAP_ENC_MIME)
    7790. 

  7790.   { 
    7791. 

  7791. #ifndef WITH_NOIDREF
    7792. 

  7792.     if (soap->mode & SOAP_MIME_POSTCHECK)
    7793. 

  7793.     { soap_resolve(soap);
    7794. 

  7794.       return SOAP_OK;
    7795. 

  7795.     }
    7796. 

  7796. #endif
    7797. 

  7797.     if (soap_getmime(soap))
    7798. 

  7798.       return soap->error;
    7799. 

  7799.   }
    7800. 

  7800.   soap->mime.list = soap->mime.first;
    7801. 

  7801.   soap->mime.first = NULL;
    7802. 

  7802.   soap->mime.last = NULL;
    7803. 

  7803.   soap->mime.boundary = NULL;
    7804. 

  7804.   if (soap->xlist)
    7805. 

  7805.   { struct soap_multipart *content;
    7806. 

  7806.     for (content = soap->mime.list; content; content = content->next)
    7807. 

  7807.       soap_resolve_attachment(soap, content);
    7808. 

  7808.   }
    7809. 

  7809. #endif
    7810. 

  7810.   DBGLOG(TEST,SOAP_MESSAGE(fdebug, "End of receive message ok\n"));
    7811. 

  7811. #ifdef WITH_ZLIB
    7812. 

  7812.   if (soap->mode & SOAP_ENC_ZLIB)
    7813. 

  7813.   { /* Make sure end of compressed content is reached */
    7814. 

  7814.     while (soap->d_stream->next_out != Z_NULL)
    7815. 

  7815.       if ((int)soap_get1(soap) == EOF)
    7816. 

  7816.         break;
    7817. 

  7817.     soap->mode &= ~SOAP_ENC_ZLIB;
    7818. 

  7818.     memcpy(soap->buf, soap->z_buf, SOAP_BUFLEN);
    7819. 

  7819.     soap->bufidx = (char*)soap->d_stream->next_in - soap->z_buf;
    7820. 

  7820.     soap->buflen = soap->z_buflen;
    7821. 

  7821.     soap->zlib_state = SOAP_ZLIB_NONE;
    7822. 

  7822.     if (inflateEnd(soap->d_stream) != Z_OK)
    7823. 

  7823.       return soap->error = SOAP_ZLIB_ERROR;
    7824. 

  7824.     DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Inflate end ok\n"));
    7825. 

  7825. #ifdef WITH_GZIP
    7826. 

  7826.     if (soap->zlib_in == SOAP_ZLIB_GZIP)
    7827. 

  7827.     { soap_wchar c;
    7828. 

  7828.       short i;
    7829. 

  7829.       DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Inflate gzip crc check\n"));
    7830. 

  7830.       for (i = 0; i < 8; i++)
    7831. 

  7831.       { if ((int)(c = soap_get1(soap)) == EOF)
    7832. 

  7832.           return soap->error = SOAP_EOF;
    7833. 

  7833.         soap->z_buf[i] = (char)c;
    7834. 

  7834.       }
    7835. 

  7835.       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)))
    7836. 

  7836.       { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Gzip error: crc check failed, message corrupted? (crc32=%lu)\n", (unsigned long)soap->z_crc));
    7837. 

  7837.         return soap->error = SOAP_ZLIB_ERROR;
    7838. 

  7838.       }
    7839. 

  7839.       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)))
    7840. 

  7840.       { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Gzip error: incorrect message length\n"));
    7841. 

  7841.         return soap->error = SOAP_ZLIB_ERROR;
    7842. 

  7842.       }
    7843. 

  7843.     }
    7844. 

  7844.     soap->zlib_in = SOAP_ZLIB_NONE;
    7845. 

  7845. #endif
    7846. 

  7846.   }
    7847. 

  7847. #endif
    7848. 

  7848.   if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK)
    7849. 

  7849.     while ((int)soap_getchar(soap) != EOF) /* advance to last chunk */
    7850. 

  7850.       ;
    7851. 

  7851. #ifndef WITH_NOIDREF
    7852. 

  7852.   if (soap_resolve(soap))
    7853. 

  7853.     return soap->error;
    7854. 

  7854. #endif
    7855. 

  7855. #ifndef WITH_LEANER
    7856. 

  7856.   if (soap->xlist)
    7857. 

  7857.   { if (soap->mode & SOAP_ENC_MTOM)
    7858. 

  7858.       return soap->error = SOAP_MIME_HREF;
    7859. 

  7859.     return soap->error = SOAP_DIME_HREF;
    7860. 

  7860.   }
    7861. 

  7861. #endif
    7862. 

  7862.   soap_free_ns(soap);
    7863. 

  7863. #ifndef WITH_LEANER
    7864. 

  7864.   if (soap->fpreparefinalrecv)
    7865. 

  7865.     return soap->error = soap->fpreparefinalrecv(soap);
    7866. 

  7866. #endif
    7867. 

  7867.   return SOAP_OK;
    7868. 

  7868. }
    7869. 

  7869. #endif
    7870. 

  7870. 

  7871. /******************************************************************************/
    7872. 

  7872. #ifndef PALM_1
    7873. 

  7873. SOAP_FMAC1
    7874. 

  7874. void
    7875. 

  7875. SOAP_FMAC2
    7876. 

  7876. soap_free_temp(struct soap *soap)
    7877. 

  7877. { register struct soap_attribute *tp, *tq;
    7878. 

  7878.   register struct Namespace *ns;
    7879. 

  7879.   soap_free_ns(soap);
    7880. 

  7880.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free any remaining temp blocks\n"));
    7881. 

  7881.   while (soap->blist)
    7882. 

  7882.     soap_end_block(soap, NULL);
    7883. 

  7883.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free attribute storage\n"));
    7884. 

  7884.   for (tp = soap->attributes; tp; tp = tq)
    7885. 

  7885.   { tq = tp->next;
    7886. 

  7886.     if (tp->value)
    7887. 

  7887.       SOAP_FREE(soap, tp->value);
    7888. 

  7888.     SOAP_FREE(soap, tp);
    7889. 

  7889.   }
    7890. 

  7890.   soap->attributes = NULL;
    7891. 

  7891. #ifdef WITH_FAST
    7892. 

  7892.   if (soap->labbuf)
    7893. 

  7893.     SOAP_FREE(soap, soap->labbuf);
    7894. 

  7894.   soap->labbuf = NULL;
    7895. 

  7895.   soap->lablen = 0;
    7896. 

  7896.   soap->labidx = 0;
    7897. 

  7897. #endif
    7898. 

  7898.   ns = soap->local_namespaces;
    7899. 

  7899.   if (ns)
    7900. 

  7900.   { for (; ns->id; ns++)
    7901. 

  7901.     { if (ns->out)
    7902. 

  7902.       { if (soap->encodingStyle == ns->out)
    7903. 

  7903.           soap->encodingStyle = SOAP_STR_EOS;
    7904. 

  7904.         SOAP_FREE(soap, ns->out);
    7905. 

  7905.         ns->out = NULL;
    7906. 

  7906.       }
    7907. 

  7907.       if (soap->encodingStyle == ns->ns)
    7908. 

  7908.         soap->encodingStyle = SOAP_STR_EOS;
    7909. 

  7909.     }
    7910. 

  7910.     SOAP_FREE(soap, soap->local_namespaces);
    7911. 

  7911.     soap->local_namespaces = NULL;
    7912. 

  7912.   }
    7913. 

  7913. #ifndef WITH_LEANER
    7914. 

  7914.   while (soap->xlist)
    7915. 

  7915.   { struct soap_xlist *xp = soap->xlist->next;
    7916. 

  7916.     SOAP_FREE(soap, soap->xlist);
    7917. 

  7917.     soap->xlist = xp;
    7918. 

  7918.   }
    7919. 

  7919. #endif
    7920. 

  7920. #ifndef WITH_NOIDREF
    7921. 

  7921.   soap_free_pht(soap);
    7922. 

  7922.   soap_free_iht(soap);
    7923. 

  7923. #endif
    7924. 

  7924. }
    7925. 

  7925. #endif
    7926. 

  7926. 

  7927. /******************************************************************************/
    7928. 

  7928. #ifndef PALM_1
    7929. 

  7929. static void
    7930. 

  7930. soap_free_ns(struct soap *soap)
    7931. 

  7931. { register struct soap_nlist *np, *nq;
    7932. 

  7932.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free namespace stack\n"));
    7933. 

  7933.   for (np = soap->nlist; np; np = nq)
    7934. 

  7934.   { nq = np->next;
    7935. 

  7935.     SOAP_FREE(soap, np);
    7936. 

  7936.   }
    7937. 

  7937.   soap->nlist = NULL;
    7938. 

  7938. }
    7939. 

  7939. #endif
    7940. 

  7940. 

  7941. /******************************************************************************/
    7942. 

  7942. #ifndef PALM_1
    7943. 

  7943. #if !defined(WITH_LEAN) || defined(SOAP_DEBUG)
    7944. 

  7944. static void
    7945. 

  7945. soap_init_logs(struct soap *soap)
    7946. 

  7946. { int i;
    7947. 

  7947.   for (i = 0; i < SOAP_MAXLOGS; i++)
    7948. 

  7948.   { soap->logfile[i] = NULL;
    7949. 

  7949.     soap->fdebug[i] = NULL;
    7950. 

  7950.   }
    7951. 

  7951. }
    7952. 

  7952. #endif
    7953. 

  7953. #endif
    7954. 

  7954. 

  7955. /******************************************************************************/
    7956. 

  7956. #if !defined(WITH_LEAN) || defined(SOAP_DEBUG)
    7957. 

  7957. SOAP_FMAC1
    7958. 

  7958. void
    7959. 

  7959. SOAP_FMAC2
    7960. 

  7960. soap_open_logfile(struct soap *soap, int i)
    7961. 

  7961. { if (soap->logfile[i])
    7962. 

  7962.     soap->fdebug[i] = fopen(soap->logfile[i], i < 2 ? "ab" : "a");
    7963. 

  7963. }
    7964. 

  7964. #endif
    7965. 

  7965. 

  7966. /******************************************************************************/
    7967. 

  7967. #ifdef SOAP_DEBUG
    7968. 

  7968. static void
    7969. 

  7969. soap_close_logfile(struct soap *soap, int i)
    7970. 

  7970. { if (soap->fdebug[i])
    7971. 

  7971.   { fclose(soap->fdebug[i]);
    7972. 

  7972.     soap->fdebug[i] = NULL;
    7973. 

  7973.   }
    7974. 

  7974. }
    7975. 

  7975. #endif
    7976. 

  7976. 

  7977. /******************************************************************************/
    7978. 

  7978. #ifdef SOAP_DEBUG
    7979. 

  7979. SOAP_FMAC1
    7980. 

  7980. void
    7981. 

  7981. SOAP_FMAC2
    7982. 

  7982. soap_close_logfiles(struct soap *soap)
    7983. 

  7983. { int i;
    7984. 

  7984.   for (i = 0; i < SOAP_MAXLOGS; i++)
    7985. 

  7985.     soap_close_logfile(soap, i);
    7986. 

  7986. }
    7987. 

  7987. #endif
    7988. 

  7988. 

  7989. /******************************************************************************/
    7990. 

  7990. #ifdef SOAP_DEBUG
    7991. 

  7991. static void
    7992. 

  7992. soap_set_logfile(struct soap *soap, int i, const char *logfile)
    7993. 

  7993. { const char *s;
    7994. 

  7994.   char *t = NULL;
    7995. 

  7995.   soap_close_logfile(soap, i);
    7996. 

  7996.   s = soap->logfile[i];
    7997. 

  7997.   soap->logfile[i] = logfile;
    7998. 

  7998.   if (s)
    7999. 

  7999.     SOAP_FREE(soap, (void*)s);
    8000. 

  8000.   if (logfile)
    8001. 

  8001.     if ((t = (char*)SOAP_MALLOC(soap, strlen(logfile) + 1)))
    8002. 

  8002.       strcpy(t, logfile);
    8003. 

  8003.   soap->logfile[i] = t;
    8004. 

  8004. }
    8005. 

  8005. #endif
    8006. 

  8006. 

  8007. /******************************************************************************/
    8008. 

  8008. #ifdef SOAP_DEBUG
    8009. 

  8009. SOAP_FMAC1
    8010. 

  8010. void
    8011. 

  8011. SOAP_FMAC2
    8012. 

  8012. soap_set_recv_logfile(struct soap *soap, const char *logfile)
    8013. 

  8013. { soap_set_logfile(soap, SOAP_INDEX_RECV, logfile);
    8014. 

  8014. }
    8015. 

  8015. #endif
    8016. 

  8016. 

  8017. /******************************************************************************/
    8018. 

  8018. #ifdef SOAP_DEBUG
    8019. 

  8019. SOAP_FMAC1
    8020. 

  8020. void
    8021. 

  8021. SOAP_FMAC2
    8022. 

  8022. soap_set_sent_logfile(struct soap *soap, const char *logfile)
    8023. 

  8023. { soap_set_logfile(soap, SOAP_INDEX_SENT, logfile);
    8024. 

  8024. }
    8025. 

  8025. #endif
    8026. 

  8026. 

  8027. /******************************************************************************/
    8028. 

  8028. #ifdef SOAP_DEBUG
    8029. 

  8029. SOAP_FMAC1
    8030. 

  8030. void
    8031. 

  8031. SOAP_FMAC2
    8032. 

  8032. soap_set_test_logfile(struct soap *soap, const char *logfile)
    8033. 

  8033. { soap_set_logfile(soap, SOAP_INDEX_TEST, logfile);
    8034. 

  8034. }
    8035. 

  8035. #endif
    8036. 

  8036. 

  8037. /******************************************************************************/
    8038. 

  8038. #ifndef PALM_1
    8039. 

  8039. SOAP_FMAC1
    8040. 

  8040. struct soap*
    8041. 

  8041. SOAP_FMAC2
    8042. 

  8042. soap_copy(const struct soap *soap)
    8043. 

  8043. { return soap_copy_context((struct soap*)malloc(sizeof(struct soap)), soap);
    8044. 

  8044. }
    8045. 

  8045. #endif
    8046. 

  8046. 

  8047. /******************************************************************************/
    8048. 

  8048. #ifndef PALM_1
    8049. 

  8049. SOAP_FMAC1
    8050. 

  8050. struct soap*
    8051. 

  8051. SOAP_FMAC2
    8052. 

  8052. soap_copy_context(struct soap *copy, const struct soap *soap)
    8053. 

  8053. { if (soap_check_state(soap))
    8054. 

  8054.     return NULL;
    8055. 

  8055.   if (copy)
    8056. 

  8056.   { register struct soap_plugin *p = NULL;
    8057. 

  8057. #ifdef __cplusplus
    8058. 

  8058.     *copy = *soap;
    8059. 

  8059. #else
    8060. 

  8060.     memcpy(copy, soap, sizeof(struct soap));
    8061. 

  8061. #endif
    8062. 

  8062.     copy->state = SOAP_COPY;
    8063. 

  8063.     copy->error = SOAP_OK;
    8064. 

  8064.     copy->userid = NULL;
    8065. 

  8065.     copy->passwd = NULL;
    8066. 

  8066.     copy->nlist = NULL;
    8067. 

  8067.     copy->blist = NULL;
    8068. 

  8068.     copy->clist = NULL;
    8069. 

  8069.     copy->alist = NULL;
    8070. 

  8070.     copy->attributes = NULL;
    8071. 

  8071.     copy->labbuf = NULL;
    8072. 

  8072.     copy->lablen = 0;
    8073. 

  8073.     copy->labidx = 0;
    8074. 

  8074. #ifdef SOAP_MEM_DEBUG
    8075. 

  8075.     soap_init_mht(copy);
    8076. 

  8076. #endif
    8077. 

  8077. #if !defined(WITH_LEAN) || defined(SOAP_DEBUG)
    8078. 

  8078.     soap_init_logs(copy);
    8079. 

  8079. #endif
    8080. 

  8080. #ifdef SOAP_DEBUG
    8081. 

  8081.     soap_set_test_logfile(copy, soap->logfile[SOAP_INDEX_TEST]);
    8082. 

  8082.     soap_set_sent_logfile(copy, soap->logfile[SOAP_INDEX_SENT]);
    8083. 

  8083.     soap_set_recv_logfile(copy, soap->logfile[SOAP_INDEX_RECV]);
    8084. 

  8084. #endif
    8085. 

  8085. #ifdef WITH_C_LOCALE
    8086. 

  8086.     copy->c_locale = duplocale(soap->c_locale);
    8087. 

  8087. #else
    8088. 

  8088.     copy->c_locale = NULL;
    8089. 

  8089. #endif
    8090. 

  8090. #ifdef WITH_OPENSSL
    8091. 

  8091.     copy->bio = NULL;
    8092. 

  8092.     copy->ssl = NULL;
    8093. 

  8093.     copy->session = NULL;
    8094. 

  8094. #endif
    8095. 

  8095. #ifdef WITH_ZLIB
    8096. 

  8096.     copy->d_stream = (z_stream*)SOAP_MALLOC(copy, sizeof(z_stream));
    8097. 

  8097.     copy->d_stream->zalloc = Z_NULL;
    8098. 

  8098.     copy->d_stream->zfree = Z_NULL;
    8099. 

  8099.     copy->d_stream->opaque = Z_NULL;
    8100. 

  8100.     copy->z_buf = NULL;
    8101. 

  8101. #endif
    8102. 

  8102.     copy->local_namespaces = NULL;
    8103. 

  8103. #ifndef WITH_NOIDREF
    8104. 

  8104.     soap_init_iht(copy);
    8105. 

  8105.     soap_init_pht(copy);
    8106. 

  8106. #endif
    8107. 

  8107.     copy->header = NULL;
    8108. 

  8108.     copy->fault = NULL;
    8109. 

  8109.     copy->action = NULL;
    8110. 

  8110. #ifndef WITH_LEAN
    8111. 

  8111. #ifdef WITH_COOKIES
    8112. 

  8112.     copy->cookies = soap_copy_cookies(copy, soap);
    8113. 

  8113. #else
    8114. 

  8114.     copy->cookies = NULL;
    8115. 

  8115. #endif
    8116. 

  8116. #endif
    8117. 

  8117.     copy->plugins = NULL;
    8118. 

  8118.     for (p = soap->plugins; p; p = p->next)
    8119. 

  8119.     { register struct soap_plugin *q = (struct soap_plugin*)SOAP_MALLOC(copy, sizeof(struct soap_plugin));
    8120. 

  8120.       if (!q)
    8121. 

  8121.         return NULL;
    8122. 

  8122.       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying plugin '%s'\n", p->id));
    8123. 

  8123.       *q = *p;
    8124. 

  8124.       if (p->fcopy && p->fcopy(copy, q, p))
    8125. 

  8125.       { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not copy plugin '%s'\n", p->id));
    8126. 

  8126.         SOAP_FREE(copy, q);
    8127. 

  8127.         return NULL;
    8128. 

  8128.       }
    8129. 

  8129.       q->next = copy->plugins;
    8130. 

  8130.       copy->plugins = q;
    8131. 

  8131.     }
    8132. 

  8132.   }
    8133. 

  8133.   return copy;
    8134. 

  8134. }
    8135. 

  8135. #endif
    8136. 

  8136. 

  8137. /******************************************************************************/
    8138. 

  8138. #ifndef PALM_1
    8139. 

  8139. SOAP_FMAC1
    8140. 

  8140. void
    8141. 

  8141. SOAP_FMAC2
    8142. 

  8142. soap_copy_stream(struct soap *copy, struct soap *soap)
    8143. 

  8143. { copy->mode = soap->mode;
    8144. 

  8144.   copy->imode = soap->imode;
    8145. 

  8145.   copy->omode = soap->omode;
    8146. 

  8146.   copy->socket = soap->socket;
    8147. 

  8147.   copy->recv_timeout = soap->recv_timeout;
    8148. 

  8148.   copy->send_timeout = soap->send_timeout;
    8149. 

  8149. #if defined(__cplusplus) && !defined(WITH_LEAN)
    8150. 

  8150.   copy->os = soap->os;
    8151. 

  8151.   copy->is = soap->is;
    8152. 

  8152. #endif
    8153. 

  8153.   copy->sendfd = soap->sendfd;
    8154. 

  8154.   copy->recvfd = soap->recvfd;
    8155. 

  8155.   copy->bufidx = soap->bufidx;
    8156. 

  8156.   copy->buflen = soap->buflen;
    8157. 

  8157.   copy->ahead = soap->ahead;
    8158. 

  8158.   copy->cdata = soap->cdata;
    8159. 

  8159.   copy->chunksize = soap->chunksize;
    8160. 

  8160.   copy->chunkbuflen = soap->chunkbuflen;
    8161. 

  8161.   copy->keep_alive = soap->keep_alive;
    8162. 

  8162.   copy->tcp_keep_alive = soap->tcp_keep_alive;
    8163. 

  8163.   copy->tcp_keep_idle = soap->tcp_keep_idle;
    8164. 

  8164.   copy->tcp_keep_intvl = soap->tcp_keep_intvl;
    8165. 

  8165.   copy->tcp_keep_cnt = soap->tcp_keep_cnt;
    8166. 

  8166.   copy->max_keep_alive = soap->max_keep_alive;
    8167. 

  8167. #ifndef WITH_NOIO
    8168. 

  8168.   copy->peer = soap->peer;
    8169. 

  8169.   copy->peerlen = soap->peerlen;
    8170. 

  8170. #endif
    8171. 

  8171. #ifdef WITH_OPENSSL
    8172. 

  8172.   copy->bio = soap->bio;
    8173. 

  8173.   copy->ssl = soap->ssl;
    8174. 

  8174.   copy->ctx = soap->ctx;
    8175. 

  8175. #endif
    8176. 

  8176. #ifdef WITH_ZLIB
    8177. 

  8177.   copy->zlib_state = soap->zlib_state;
    8178. 

  8178.   copy->zlib_in = soap->zlib_in;
    8179. 

  8179.   copy->zlib_out = soap->zlib_out;
    8180. 

  8180.   copy->d_stream = (z_stream*)SOAP_MALLOC(copy, sizeof(z_stream));
    8181. 

  8181.   memcpy(copy->d_stream, soap->d_stream, sizeof(z_stream));
    8182. 

  8182.   copy->z_crc = soap->z_crc;
    8183. 

  8183.   copy->z_ratio_in = soap->z_ratio_in;
    8184. 

  8184.   copy->z_ratio_out = soap->z_ratio_out;
    8185. 

  8185.   copy->z_buf = NULL;
    8186. 

  8186.   copy->z_buflen = soap->z_buflen;
    8187. 

  8187.   copy->z_level = soap->z_level;
    8188. 

  8188.   if (soap->z_buf && soap->zlib_state != SOAP_ZLIB_NONE)
    8189. 

  8189.   { copy->z_buf = (char*)SOAP_MALLOC(copy, SOAP_BUFLEN);
    8190. 

  8190.     memcpy(copy->z_buf, soap->z_buf, sizeof(soap->z_buf));
    8191. 

  8191.   }
    8192. 

  8192.   copy->z_dict = soap->z_dict;
    8193. 

  8193.   copy->z_dict_len = soap->z_dict_len;
    8194. 

  8194. #endif
    8195. 

  8195.   memcpy(copy->buf, soap->buf, sizeof(soap->buf));
    8196. 

  8196. }
    8197. 

  8197. #endif
    8198. 

  8198. 

  8199. /******************************************************************************/
    8200. 

  8200. #ifndef PALM_1
    8201. 

  8201. SOAP_FMAC1
    8202. 

  8202. void
    8203. 

  8203. SOAP_FMAC2
    8204. 

  8204. soap_free_stream(struct soap *soap)
    8205. 

  8205. { soap->socket = SOAP_INVALID_SOCKET;
    8206. 

  8206. #ifdef WITH_OPENSSL
    8207. 

  8207.   soap->bio = NULL;
    8208. 

  8208.   soap->ssl = NULL;
    8209. 

  8209. #endif
    8210. 

  8210. #ifdef WITH_ZLIB
    8211. 

  8211.   if (soap->d_stream)
    8212. 

  8212.     SOAP_FREE(soap, soap->d_stream);
    8213. 

  8213.   soap->d_stream = NULL;
    8214. 

  8214.   if (soap->z_buf)
    8215. 

  8215.     SOAP_FREE(soap, soap->z_buf);
    8216. 

  8216.   soap->z_buf = NULL;
    8217. 

  8217. #endif
    8218. 

  8218. }
    8219. 

  8219. #endif
    8220. 

  8220. 

  8221. /******************************************************************************/
    8222. 

  8222. #ifndef PALM_1
    8223. 

  8223. SOAP_FMAC1
    8224. 

  8224. void
    8225. 

  8225. SOAP_FMAC2
    8226. 

  8226. soap_init(struct soap *soap)
    8227. 

  8227. { soap->state = SOAP_INIT;
    8228. 

  8228. #ifdef SOAP_MEM_DEBUG
    8229. 

  8229.   soap_init_mht(soap);
    8230. 

  8230. #endif
    8231. 

  8231. #if !defined(WITH_LEAN) || defined(SOAP_DEBUG)
    8232. 

  8232.   soap_init_logs(soap);
    8233. 

  8233. #endif
    8234. 

  8234. #ifdef SOAP_DEBUG
    8235. 

  8235. /*
    8236. 

  8236.  Oracle customization for KMS server debug
    8237. 

  8237. */
    8238. 

  8238. #ifdef SOAP_DEBUG_SERVER
    8239. 

  8239.     soap_set_test_logfile(soap, "/var/log/SUNWkms2/TEST.log");
    8240. 

  8240.     soap_set_sent_logfile(soap, "/var/log/SUNWkms2/SENT.log");
    8241. 

  8241.     soap_set_recv_logfile(soap, "/var/log/SUNWkms2/RECV.log");
    8242. 

  8242. #else
    8243. 

  8243.   soap_set_test_logfile(soap, "TEST.log");
    8244. 

  8244.   soap_set_sent_logfile(soap, "SENT.log");
    8245. 

  8245.   soap_set_recv_logfile(soap, "RECV.log");
    8246. 

  8246. #endif
    8247. 

  8247.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Initializing context\n"));
    8248. 

  8248. #endif
    8249. 

  8249.   soap->version = 0;
    8250. 

  8250.   soap_imode(soap, SOAP_IO_DEFAULT);
    8251. 

  8251.   soap_omode(soap, SOAP_IO_DEFAULT);
    8252. 

  8252.   soap->plugins = NULL;
    8253. 

  8253.   soap->user = NULL;
    8254. 

  8254.   soap->userid = NULL;
    8255. 

  8255.   soap->passwd = NULL;
    8256. 

  8256. #ifndef WITH_NOHTTP
    8257. 

  8257.   soap->fpost = http_post;
    8258. 

  8258.   soap->fget = http_get;
    8259. 

  8259.   soap->fput = http_405;
    8260. 

  8260.   soap->fdel = http_405;
    8261. 

  8261.   soap->fhead = http_405;
    8262. 

  8262.   soap->fform = NULL;
    8263. 

  8263.   soap->fposthdr = http_post_header;
    8264. 

  8264.   soap->fresponse = http_response;
    8265. 

  8265.   soap->fparse = http_parse;
    8266. 

  8266.   soap->fparsehdr = http_parse_header;
    8267. 

  8267. #endif
    8268. 

  8268.   soap->fheader = NULL;
    8269. 

  8269.   soap->fconnect = NULL;
    8270. 

  8270.   soap->fdisconnect = NULL;
    8271. 

  8271. #ifndef WITH_NOIO
    8272. 

  8272.   soap->ipv6_multicast_if = 0;
    8273. 

  8273.   soap->ipv4_multicast_if = NULL;
    8274. 

  8274. #ifndef WITH_IPV6
    8275. 

  8275.   soap->fresolve = tcp_gethost;
    8276. 

  8276. #else
    8277. 

  8277.   soap->fresolve = NULL;
    8278. 

  8278. #endif
    8279. 

  8279.   soap->faccept = tcp_accept;
    8280. 

  8280.   soap->fopen = tcp_connect;
    8281. 

  8281.   soap->fclose = tcp_disconnect;
    8282. 

  8282.   soap->fclosesocket = tcp_closesocket;
    8283. 

  8283.   soap->fshutdownsocket = tcp_shutdownsocket;
    8284. 

  8284.   soap->fsend = fsend;
    8285. 

  8285.   soap->frecv = frecv;
    8286. 

  8286.   soap->fpoll = soap_poll;
    8287. 

  8287. #else
    8288. 

  8288.   soap->fopen = NULL;
    8289. 

  8289.   soap->fclose = NULL;
    8290. 

  8290.   soap->fpoll = NULL;
    8291. 

  8291. #endif
    8292. 

  8292.   soap->fseterror = NULL;
    8293. 

  8293.   soap->fignore = NULL;
    8294. 

  8294.   soap->fserveloop = NULL;
    8295. 

  8295.   soap->fplugin = fplugin;
    8296. 

  8296.   soap->fmalloc = NULL;
    8297. 

  8297. #ifndef WITH_LEANER
    8298. 

  8298.   soap->fprepareinitsend = NULL;
    8299. 

  8299.   soap->fprepareinitrecv = NULL;
    8300. 

  8300.   soap->fpreparesend = NULL;
    8301. 

  8301.   soap->fpreparerecv = NULL;
    8302. 

  8302.   soap->fpreparefinalsend = NULL;
    8303. 

  8303.   soap->fpreparefinalrecv = NULL;
    8304. 

  8304.   soap->fdimereadopen = NULL;
    8305. 

  8305.   soap->fdimewriteopen = NULL;
    8306. 

  8306.   soap->fdimereadclose = NULL;
    8307. 

  8307.   soap->fdimewriteclose = NULL;
    8308. 

  8308.   soap->fdimeread = NULL;
    8309. 

  8309.   soap->fdimewrite = NULL;
    8310. 

  8310.   soap->fmimereadopen = NULL;
    8311. 

  8311.   soap->fmimewriteopen = NULL;
    8312. 

  8312.   soap->fmimereadclose = NULL;
    8313. 

  8313.   soap->fmimewriteclose = NULL;
    8314. 

  8314.   soap->fmimeread = NULL;
    8315. 

  8315.   soap->fmimewrite = NULL;
    8316. 

  8316. #endif
    8317. 

  8317.   soap->float_format = "%.9G"; /* Alternative: use "%G" */
    8318. 

  8318.   soap->double_format = "%.17lG"; /* Alternative: use "%lG" */
    8319. 

  8319.   soap->dime_id_format = "cid:id%d"; /* default DIME id format */
    8320. 

  8320.   soap->http_version = "1.1";
    8321. 

  8321.   soap->proxy_http_version = "1.0";
    8322. 

  8322.   soap->http_content = NULL;
    8323. 

  8323.   soap->actor = NULL;
    8324. 

  8324.   soap->lang = "en";
    8325. 

  8325.   soap->keep_alive = 0;
    8326. 

  8326.   soap->tcp_keep_alive = 0;
    8327. 

  8327.   soap->tcp_keep_idle = 0;
    8328. 

  8328.   soap->tcp_keep_intvl = 0;
    8329. 

  8329.   soap->tcp_keep_cnt = 0;
    8330. 

  8330.   soap->max_keep_alive = SOAP_MAXKEEPALIVE;
    8331. 

  8331.   soap->recv_timeout = 0;
    8332. 

  8332.   soap->send_timeout = 0;
    8333. 

  8333.   soap->connect_timeout = 0;
    8334. 

  8334.   soap->accept_timeout = 0;
    8335. 

  8335. #if defined(WITH_OPENSSL) && defined(KMS_SERVER)
    8336. 

  8336.   /* Oracle customization for Ultra 2 KMS Server */
    8337. 

  8337.   soap->ssl_accept_timeout = 0;
    8338. 

  8338. #endif
    8339. 

  8339.   soap->socket_flags = 0;
    8340. 

  8340.   soap->connect_flags = 0;
    8341. 

  8341.   soap->bind_flags = 0;
    8342. 

  8342.   soap->accept_flags = 0;
    8343. 

  8343.   soap->linger_time = 0;
    8344. 

  8344.   soap->ip = 0;
    8345. 

  8345.   soap->labbuf = NULL;
    8346. 

  8346.   soap->lablen = 0;
    8347. 

  8347.   soap->labidx = 0;
    8348. 

  8348.   soap->encodingStyle = SOAP_STR_EOS;
    8349. 

  8349. #ifndef WITH_NONAMESPACES
    8350. 

  8350.   soap->namespaces = namespaces;
    8351. 

  8351. #else
    8352. 

  8352.   soap->namespaces = NULL;
    8353. 

  8353. #endif
    8354. 

  8354.   soap->local_namespaces = NULL;
    8355. 

  8355.   soap->nlist = NULL;
    8356. 

  8356.   soap->blist = NULL;
    8357. 

  8357.   soap->clist = NULL;
    8358. 

  8358.   soap->alist = NULL;
    8359. 

  8359.   soap->attributes = NULL;
    8360. 

  8360.   soap->header = NULL;
    8361. 

  8361.   soap->fault = NULL;
    8362. 

  8362.   soap->master = SOAP_INVALID_SOCKET;
    8363. 

  8363.   soap->socket = SOAP_INVALID_SOCKET;
    8364. 

  8364.   soap->os = NULL;
    8365. 

  8365.   soap->is = NULL;
    8366. 

  8366. #ifndef WITH_LEANER
    8367. 

  8367.   soap->dom = NULL;
    8368. 

  8368.   soap->dime.list = NULL;
    8369. 

  8369.   soap->dime.first = NULL;
    8370. 

  8370.   soap->dime.last = NULL;
    8371. 

  8371.   soap->mime.list = NULL;
    8372. 

  8372.   soap->mime.first = NULL;
    8373. 

  8373.   soap->mime.last = NULL;
    8374. 

  8374.   soap->mime.boundary = NULL;
    8375. 

  8375.   soap->mime.start = NULL;
    8376. 

  8376.   soap->xlist = NULL;
    8377. 

  8377. #endif
    8378. 

  8378. #ifndef UNDER_CE
    8379. 

  8379.   soap->recvfd = 0;
    8380. 

  8380.   soap->sendfd = 1;
    8381. 

  8381. #else
    8382. 

  8382.   soap->recvfd = stdin;
    8383. 

  8383.   soap->sendfd = stdout;
    8384. 

  8384. #endif 
    8385. 

  8385.   soap->host[0] = '\0';
    8386. 

  8386.   soap->session_host[0] = '\0';      /* Oracle customization */
    8387. 

  8387.   soap->session_port = 0;            /* Oracle customization */
    8388. 

  8388.   soap->port = 0;
    8389. 

  8389.   soap->action = NULL;
    8390. 

  8390.   soap->proxy_host = NULL;
    8391. 

  8391.   soap->proxy_port = 8080;
    8392. 

  8392.   soap->proxy_userid = NULL;
    8393. 

  8393.   soap->proxy_passwd = NULL;
    8394. 

  8394.   soap->authrealm = NULL;
    8395. 

  8395.   soap->prolog = NULL;
    8396. 

  8396. #ifdef WITH_ZLIB
    8397. 

  8397.   soap->zlib_state = SOAP_ZLIB_NONE;
    8398. 

  8398.   soap->zlib_in = SOAP_ZLIB_NONE;
    8399. 

  8399.   soap->zlib_out = SOAP_ZLIB_NONE;
    8400. 

  8400.   soap->d_stream = (z_stream*)SOAP_MALLOC(soap, sizeof(z_stream));
    8401. 

  8401.   soap->d_stream->zalloc = Z_NULL;
    8402. 

  8402.   soap->d_stream->zfree = Z_NULL;
    8403. 

  8403.   soap->d_stream->opaque = Z_NULL;
    8404. 

  8404.   soap->z_buf = NULL;
    8405. 

  8405.   soap->z_level = 6;
    8406. 

  8406.   soap->z_dict = NULL;
    8407. 

  8407.   soap->z_dict_len = 0;
    8408. 

  8408. #endif
    8409. 

  8409. #ifndef WITH_LEAN
    8410. 

  8410.   soap->wsuid = NULL;
    8411. 

  8411.   soap->c14nexclude = NULL;
    8412. 

  8412.   soap->cookies = NULL;
    8413. 

  8413.   soap->cookie_domain = NULL;
    8414. 

  8414.   soap->cookie_path = NULL;
    8415. 

  8415.   soap->cookie_max = 32;
    8416. 

  8416. #endif
    8417. 

  8417. #ifdef WMW_RPM_IO
    8418. 

  8418.   soap->rpmreqid = NULL;
    8419. 

  8419. #endif
    8420. 

  8420. #ifdef PALM
    8421. 

  8421.   palmNetLibOpen();
    8422. 

  8422. #endif
    8423. 

  8423. #ifndef WITH_NOIDREF
    8424. 

  8424.   soap_init_iht(soap);
    8425. 

  8425.   soap_init_pht(soap);
    8426. 

  8426. #endif
    8427. 

  8427. #ifdef WITH_OPENSSL
    8428. 

  8428.   if (!soap_ssl_init_done)
    8429. 

  8429.     soap_ssl_init();
    8430. 

  8430.   soap->fsslauth = ssl_auth_init;
    8431. 

  8431.   soap->fsslverify = ssl_verify_callback;
    8432. 

  8432.   soap->bio = NULL;
    8433. 

  8433.   soap->ssl = NULL;
    8434. 

  8434.   soap->ctx = NULL;
    8435. 

  8435.   soap->ssl_flags = SOAP_SSL_DEFAULT;
    8436. 

  8436.   soap->keyfile = NULL;
    8437. 

  8437.   soap->password = NULL;
    8438. 

  8438.   soap->dhfile = NULL;
    8439. 

  8439.   soap->cafile = NULL;
    8440. 

  8440.   soap->capath = NULL;
    8441. 

  8441.   soap->crlfile = NULL;
    8442. 

  8442.   soap->randfile = NULL;
    8443. 

  8443.   soap->session = NULL;
    8444. 

  8444. #endif
    8445. 

  8445. #ifdef WITH_C_LOCALE
    8446. 

  8446.   soap->c_locale = newlocale(LC_ALL_MASK, "C", NULL);
    8447. 

  8447. #else
    8448. 

  8448.   soap->c_locale = NULL;
    8449. 

  8449. #endif
    8450. 

  8450.   soap->buflen = 0;
    8451. 

  8451.   soap->bufidx = 0;
    8452. 

  8452. #ifndef WITH_LEANER
    8453. 

  8453.   soap->dime.chunksize = 0;
    8454. 

  8454.   soap->dime.buflen = 0;
    8455. 

  8455. #endif
    8456. 

  8456.   soap->null = 0;
    8457. 

  8457.   soap->position = 0;
    8458. 

  8458.   soap->encoding = 0;
    8459. 

  8459.   soap->mustUnderstand = 0;
    8460. 

  8460.   soap->ns = 0;
    8461. 

  8461.   soap->part = SOAP_END;
    8462. 

  8462.   soap->alloced = 0;
    8463. 

  8463.   soap->count = 0;
    8464. 

  8464.   soap->length = 0;
    8465. 

  8465.   soap->cdata = 0;
    8466. 

  8466.   soap->peeked = 0;
    8467. 

  8467.   soap->ahead = 0;
    8468. 

  8468.   soap->idnum = 0;
    8469. 

  8469.   soap->level = 0;
    8470. 

  8470.   soap->endpoint[0] = '\0';
    8471. 

  8471.   soap->error = SOAP_OK;
    8472. 

  8472. }
    8473. 

  8473. #endif
    8474. 

  8474. 

  8475. /******************************************************************************/
    8476. 

  8476. #ifndef PALM_1
    8477. 

  8477. SOAP_FMAC1
    8478. 

  8478. void
    8479. 

  8479. SOAP_FMAC2
    8480. 

  8480. soap_init1(struct soap *soap, soap_mode mode)
    8481. 

  8481. { soap_init2(soap, mode, mode);
    8482. 

  8482. }
    8483. 

  8483. #endif
    8484. 

  8484. 

  8485. /******************************************************************************/
    8486. 

  8486. #ifndef PALM_1
    8487. 

  8487. SOAP_FMAC1
    8488. 

  8488. void
    8489. 

  8489. SOAP_FMAC2
    8490. 

  8490. soap_init2(struct soap *soap, soap_mode imode, soap_mode omode)
    8491. 

  8491. { soap_init(soap);
    8492. 

  8492.   soap_imode(soap, imode);
    8493. 

  8493.   soap_omode(soap, omode);
    8494. 

  8494. }
    8495. 

  8495. #endif
    8496. 

  8496. 

  8497. /******************************************************************************/
    8498. 

  8498. #ifndef PALM_2
    8499. 

  8499. SOAP_FMAC1
    8500. 

  8500. void
    8501. 

  8501. SOAP_FMAC2
    8502. 

  8502. soap_begin(struct soap *soap)
    8503. 

  8503. { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Reinitializing context\n"));
    8504. 

  8504.   if (!soap->keep_alive)
    8505. 

  8505.   { soap->buflen = 0;
    8506. 

  8506.     soap->bufidx = 0;
    8507. 

  8507.   }
    8508. 

  8508.   soap->keep_alive = (((soap->imode | soap->omode) & SOAP_IO_KEEPALIVE) != 0);
    8509. 

  8509.   soap->null = 0;
    8510. 

  8510.   soap->position = 0;
    8511. 

  8511.   soap->encoding = 0;
    8512. 

  8512.   soap->mustUnderstand = 0;
    8513. 

  8513.   soap->mode = 0;
    8514. 

  8514.   soap->ns = 0;
    8515. 

  8515.   soap->part = SOAP_END;
    8516. 

  8516.   soap->alloced = 0;
    8517. 

  8517.   soap->count = 0;
    8518. 

  8518.   soap->length = 0;
    8519. 

  8519.   soap->cdata = 0;
    8520. 

  8520.   soap->error = SOAP_OK;
    8521. 

  8521.   soap->peeked = 0;
    8522. 

  8522.   soap->ahead = 0;
    8523. 

  8523.   soap->idnum = 0;
    8524. 

  8524.   soap->level = 0;
    8525. 

  8525.   soap->endpoint[0] = '\0';
    8526. 

  8526. #ifndef WITH_LEANER
    8527. 

  8527.   soap->dime.chunksize = 0;
    8528. 

  8528.   soap->dime.buflen = 0;
    8529. 

  8529. #endif
    8530. 

  8530.   soap_free_temp(soap);
    8531. 

  8531. }
    8532. 

  8532. #endif
    8533. 

  8533. 

  8534. /******************************************************************************/
    8535. 

  8535. #ifndef PALM_2
    8536. 

  8536. SOAP_FMAC1
    8537. 

  8537. void
    8538. 

  8538. SOAP_FMAC2
    8539. 

  8539. soap_end(struct soap *soap)
    8540. 

  8540. { if (soap_check_state(soap))
    8541. 

  8541.     return;
    8542. 

  8542.   soap_free_temp(soap);
    8543. 

  8543.   soap_dealloc(soap, NULL);
    8544. 

  8544.   while (soap->clist)
    8545. 

  8545.   { register struct soap_clist *cp = soap->clist->next;
    8546. 

  8546.     SOAP_FREE(soap, soap->clist);
    8547. 

  8547.     soap->clist = cp;
    8548. 

  8548.   }
    8549. 

  8549.   soap_closesock(soap);
    8550. 

  8550. #ifdef SOAP_DEBUG
    8551. 

  8551.   soap_close_logfiles(soap);
    8552. 

  8552. #endif
    8553. 

  8553. #ifdef PALM
    8554. 

  8554.   palmNetLibClose();
    8555. 

  8555. #endif
    8556. 

  8556. }
    8557. 

  8557. #endif
    8558. 

  8558. 

  8559. /******************************************************************************/
    8560. 

  8560. #ifndef PALM_1
    8561. 

  8561. SOAP_FMAC1
    8562. 

  8562. int
    8563. 

  8563. SOAP_FMAC2
    8564. 

  8564. soap_set_namespaces(struct soap *soap, const struct Namespace *p)
    8565. 

  8565. { register struct Namespace *ns = soap->local_namespaces;
    8566. 

  8566.   register struct soap_nlist *np, *nq, *nr;
    8567. 

  8567.   register unsigned int level = soap->level;
    8568. 

  8568.   soap->namespaces = p;
    8569. 

  8569.   soap->local_namespaces = NULL;
    8570. 

  8570.   soap_set_local_namespaces(soap);
    8571. 

  8571.   /* reverse the namespace list */
    8572. 

  8572.   np = soap->nlist;
    8573. 

  8573.   soap->nlist = NULL;
    8574. 

  8574.   if (np)
    8575. 

  8575.   { nq = np->next;
    8576. 

  8576.     np->next = NULL;
    8577. 

  8577.     while (nq)
    8578. 

  8578.     { nr = nq->next;
    8579. 

  8579.       nq->next = np;
    8580. 

  8580.       np = nq;
    8581. 

  8581.       nq = nr;
    8582. 

  8582.     }
    8583. 

  8583.   }
    8584. 

  8584.   /* then push on new stack */
    8585. 

  8585.   while (np)
    8586. 

  8586.   { register const char *s;
    8587. 

  8587.     soap->level = np->level; /* preserve element nesting level */
    8588. 

  8588.     s = np->ns;
    8589. 

  8589.     if (!s && np->index >= 0 && ns)
    8590. 

  8590.     { s = ns[np->index].out;
    8591. 

  8591.       if (!s)
    8592. 

  8592.         s = ns[np->index].ns;
    8593. 

  8593.     }
    8594. 

  8594.     if (s && soap_push_namespace(soap, np->id, s) == NULL)
    8595. 

  8595.       return soap->error;
    8596. 

  8596.     nq = np;
    8597. 

  8597.     np = np->next;
    8598. 

  8598.     SOAP_FREE(soap, nq);
    8599. 

  8599.   }
    8600. 

  8600.   if (ns)
    8601. 

  8601.   { register int i;
    8602. 

  8602.     for (i = 0; ns[i].id; i++)
    8603. 

  8603.     { if (ns[i].out)
    8604. 

  8604.       { SOAP_FREE(soap, ns[i].out);
    8605. 

  8605.         ns[i].out = NULL;
    8606. 

  8606.       }
    8607. 

  8607.     }
    8608. 

  8608.     SOAP_FREE(soap, ns);
    8609. 

  8609.   }
    8610. 

  8610.   soap->level = level; /* restore level */
    8611. 

  8611.   return SOAP_OK;
    8612. 

  8612. }
    8613. 

  8613. #endif
    8614. 

  8614. 

  8615. /******************************************************************************/
    8616. 

  8616. #ifndef PALM_1
    8617. 

  8617. SOAP_FMAC1
    8618. 

  8618. void
    8619. 

  8619. SOAP_FMAC2
    8620. 

  8620. soap_set_local_namespaces(struct soap *soap)
    8621. 

  8621. { if (soap->namespaces && !soap->local_namespaces)
    8622. 

  8622.   { register const struct Namespace *ns1;
    8623. 

  8623.     register struct Namespace *ns2;
    8624. 

  8624.     register size_t n = 1;
    8625. 

  8625.     for (ns1 = soap->namespaces; ns1->id; ns1++)
    8626. 

  8626.       n++;
    8627. 

  8627.     n *= sizeof(struct Namespace);
    8628. 

  8628.     ns2 = (struct Namespace*)SOAP_MALLOC(soap, n);
    8629. 

  8629.     if (ns2)
    8630. 

  8630.     { memcpy(ns2, soap->namespaces, n);
    8631. 

  8631.       if (ns2[0].ns)
    8632. 

  8632.       { if (!strcmp(ns2[0].ns, soap_env1))
    8633. 

  8633.           soap->version = 1;
    8634. 

  8634.         else
    8635. 

  8635.           soap->version = 2;
    8636. 

  8636.       }
    8637. 

  8637.       soap->local_namespaces = ns2;
    8638. 

  8638.     }
    8639. 

  8639.   }
    8640. 

  8640. }
    8641. 

  8641. #endif
    8642. 

  8642. 

  8643. /******************************************************************************/
    8644. 

  8644. #ifndef WITH_LEAN
    8645. 

  8645. #ifndef PALM_1
    8646. 

  8646. SOAP_FMAC1
    8647. 

  8647. const char *
    8648. 

  8648. SOAP_FMAC2
    8649. 

  8649. soap_tagsearch(const char *big, const char *little)
    8650. 

  8650. { if (little)
    8651. 

  8651.   { register size_t n = strlen(little);
    8652. 

  8652.     register const char *s = big;
    8653. 

  8653.     while (s) 
    8654. 

  8654.     { register const char *t = s;
    8655. 

  8655.       register size_t i;
    8656. 

  8656.       for (i = 0; i < n; i++, t++)
    8657. 

  8657.       { if (*t != little[i])
    8658. 

  8658.           break;
    8659. 

  8659.       }
    8660. 

  8660.       if (*t == '\0' || *t == ' ')
    8661. 

  8661.       { if (i == n || (i && little[i-1] == ':'))
    8662. 

  8662.           return s;
    8663. 

  8663.       }
    8664. 

  8664.       s = strchr(t, ' ');
    8665. 

  8665.       if (s)
    8666. 

  8666.         s++;
    8667. 

  8667.     }
    8668. 

  8668.   }
    8669. 

  8669.   return NULL;
    8670. 

  8670. }
    8671. 

  8671. #endif
    8672. 

  8672. #endif
    8673. 

  8673. 

  8674. /******************************************************************************/
    8675. 

  8675. #ifndef WITH_LEAN
    8676. 

  8676. #ifndef PALM_1
    8677. 

  8677. SOAP_FMAC1
    8678. 

  8678. struct soap_nlist *
    8679. 

  8679. SOAP_FMAC2
    8680. 

  8680. soap_lookup_ns(struct soap *soap, const char *tag, size_t n)
    8681. 

  8681. { register struct soap_nlist *np;
    8682. 

  8682.   for (np = soap->nlist; np; np = np->next)
    8683. 

  8683.   { if (!strncmp(np->id, tag, n) && !np->id[n])
    8684. 

  8684.       return np;
    8685. 

  8685.   }
    8686. 

  8686.   return NULL;
    8687. 

  8687. }
    8688. 

  8688. #endif
    8689. 

  8689. #endif
    8690. 

  8690. 

  8691. /******************************************************************************/
    8692. 

  8692. #ifndef WITH_LEAN
    8693. 

  8693. static struct soap_nlist *
    8694. 

  8694. soap_push_ns(struct soap *soap, const char *id, const char *ns, short utilized)
    8695. 

  8695. { register struct soap_nlist *np;
    8696. 

  8696.   size_t n, k;
    8697. 

  8697.   if (soap_tagsearch(soap->c14nexclude, id))
    8698. 

  8698.     return NULL;
    8699. 

  8699.   if (!utilized)
    8700. 

  8700.   { for (np = soap->nlist; np; np = np->next)
    8701. 

  8701.     { if (!strcmp(np->id, id) && (!np->ns || !strcmp(np->ns, ns)))
    8702. 

  8702.         break;
    8703. 

  8703.     }
    8704. 

  8704.     if (np)
    8705. 

  8705.     { if ((np->level < soap->level || !np->ns) && np->index == 1)
    8706. 

  8706.         utilized = 1;
    8707. 

  8707.       else
    8708. 

  8708.         return NULL;
    8709. 

  8709.     }
    8710. 

  8710.   }
    8711. 

  8711.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Adding namespace binding (level=%u) '%s' '%s' utilized=%d\n", soap->level, id, ns?ns:"(null)", utilized));
    8712. 

  8712.   n = strlen(id);
    8713. 

  8713.   if (ns)
    8714. 

  8714.     k = strlen(ns);
    8715. 

  8715.   else
    8716. 

  8716.     k = 0;
    8717. 

  8717.   np = (struct soap_nlist*)SOAP_MALLOC(soap, sizeof(struct soap_nlist) + n + k + 1);
    8718. 

  8718.   if (!np)
    8719. 

  8719.   { soap->error = SOAP_EOM;
    8720. 

  8720.     return NULL;
    8721. 

  8721.   }
    8722. 

  8722.   np->next = soap->nlist;
    8723. 

  8723.   soap->nlist = np;
    8724. 

  8724.   strcpy(np->id, id);
    8725. 

  8725.   if (ns)
    8726. 

  8726.     np->ns = strcpy(np->id + n + 1, ns);
    8727. 

  8727.   else
    8728. 

  8728.     np->ns = NULL;
    8729. 

  8729.   np->level = soap->level;
    8730. 

  8730.   np->index = utilized;
    8731. 

  8731.   return np;
    8732. 

  8732. }
    8733. 

  8733. #endif
    8734. 

  8734. 

  8735. /******************************************************************************/
    8736. 

  8736. #ifndef WITH_LEAN
    8737. 

  8737. static void
    8738. 

  8738. soap_utilize_ns(struct soap *soap, const char *tag, size_t n)
    8739. 

  8739. { register struct soap_nlist *np = soap_lookup_ns(soap, tag, n);
    8740. 

  8740.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Utilizing namespace of '%s'\n", tag));
    8741. 

  8741.   if (np)
    8742. 

  8742.   { if (np->index == 0)
    8743. 

  8743.       soap_push_ns(soap, np->id, np->ns, 1);
    8744. 

  8744.   }
    8745. 

  8745.   else if (strncmp(tag, "xml", 3))
    8746. 

  8746.   { strncpy(soap->tmpbuf, tag, n);
    8747. 

  8747.     soap->tmpbuf[n] = '\0';
    8748. 

  8748.     soap_push_ns(soap, soap->tmpbuf, NULL, 1);
    8749. 

  8749.   }
    8750. 

  8750. }
    8751. 

  8751. #endif
    8752. 

  8752. 

  8753. /******************************************************************************/
    8754. 

  8754. #ifndef PALM_2
    8755. 

  8755. SOAP_FMAC1
    8756. 

  8756. int
    8757. 

  8757. SOAP_FMAC2
    8758. 

  8758. soap_element(struct soap *soap, const char *tag, int id, const char *type)
    8759. 

  8759. {
    8760. 

  8760. #ifndef WITH_LEAN
    8761. 

  8761.   register const char *s;
    8762. 

  8762. #endif
    8763. 

  8763.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Element begin tag='%s' id='%d' type='%s'\n", tag, id, type?type:SOAP_STR_EOS));
    8764. 

  8764. #ifdef WITH_DOM
    8765. 

  8765. #ifndef WITH_LEAN
    8766. 

  8766.   if (soap->wsuid && soap_tagsearch(soap->wsuid, tag))
    8767. 

  8767.   { int i;
    8768. 

  8768.     for (s = tag, i = 0; *s && i < sizeof(soap->tag); s++, i++)
    8769. 

  8769.       soap->tag[i] = *s == ':' ? '-' : *s;
    8770. 

  8770.     soap->tag[sizeof(soap->tag) - 1] = '\0';
    8771. 

  8771.     if (soap_set_attr(soap, "wsu:Id", soap->tag, 1))
    8772. 

  8772.       return soap->error;
    8773. 

  8773.   }
    8774. 

  8774. #endif 
    8775. 

  8775.   if (soap->part == SOAP_BEGIN_SECURITY && (soap->mode & SOAP_XML_CANONICAL) && !(soap->mode & SOAP_DOM_ASIS))
    8776. 

  8776.   { register struct soap_nlist *np;
    8777. 

  8777.     /* wsu:Id found: clear xmlns renderings, so re-emit them for exc-c14n */
    8778. 

  8778.     for (np = soap->nlist; np; np = np->next)
    8779. 

  8779.     { if (np->index == 2)
    8780. 

  8780.         np->index = 0;
    8781. 

  8781.     }
    8782. 

  8782.   }
    8783. 

  8783.   if (soap->mode & SOAP_XML_DOM)
    8784. 

  8784.   { register struct soap_dom_element *elt = (struct soap_dom_element*)soap_malloc(soap, sizeof(struct soap_dom_element));
    8785. 

  8785.     if (!elt)
    8786. 

  8786.       return soap->error;
    8787. 

  8787.     elt->soap = soap;
    8788. 

  8788.     elt->next = NULL;
    8789. 

  8789.     elt->prnt = soap->dom;
    8790. 

  8790.     elt->name = soap_strdup(soap, tag);
    8791. 

  8791.     elt->elts = NULL;
    8792. 

  8792.     elt->atts = NULL;
    8793. 

  8793.     elt->nstr = NULL;
    8794. 

  8794.     elt->data = NULL;
    8795. 

  8795.     elt->wide = NULL;
    8796. 

  8796.     elt->node = NULL;
    8797. 

  8797.     elt->type = 0;
    8798. 

  8798.     elt->head = NULL;
    8799. 

  8799.     elt->tail = NULL;
    8800. 

  8800.     if (soap->dom)
    8801. 

  8801.     { struct soap_dom_element *p = soap->dom->elts;
    8802. 

  8802.       if (p)
    8803. 

  8803.       { while (p->next)
    8804. 

  8804.           p = p->next;
    8805. 

  8805.         p->next = elt;
    8806. 

  8806.       }
    8807. 

  8807.       else
    8808. 

  8808.         soap->dom->elts = elt;
    8809. 

  8809.     }
    8810. 

  8810.     soap->dom = elt;
    8811. 

  8811.   }
    8812. 

  8812.   else
    8813. 

  8813.   {
    8814. 

  8814. #endif
    8815. 

  8815.     soap->level++;
    8816. 

  8816. #ifndef WITH_LEAN
    8817. 

  8817.     if (!soap->ns)
    8818. 

  8818.     { if (!(soap->mode & SOAP_XML_CANONICAL)
    8819. 

  8819.        && soap_send(soap, soap->prolog ? soap->prolog : "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"))
    8820. 

  8820.         return soap->error;
    8821. 

  8821.     }
    8822. 

  8822.     else if (soap->mode & SOAP_XML_INDENT)
    8823. 

  8823.     { if (soap->ns == 1 && soap_send_raw(soap, soap_indent, soap->level < sizeof(soap_indent) ? soap->level : sizeof(soap_indent) - 1))
    8824. 

  8824.         return soap->error;
    8825. 

  8825.       soap->body = 1;
    8826. 

  8826.     }
    8827. 

  8827.     if ((soap->mode & SOAP_XML_DEFAULTNS) && (s = strchr(tag, ':')))
    8828. 

  8828.     { struct Namespace *ns = soap->local_namespaces;
    8829. 

  8829.       size_t n = s - tag;
    8830. 

  8830.       if (soap_send_raw(soap, "<", 1)
    8831. 

  8831.        || soap_send(soap, s + 1))
    8832. 

  8832.         return soap->error;
    8833. 

  8833.       if (soap->nlist && !strncmp(soap->nlist->id, tag, n) && !soap->nlist->id[n])
    8834. 

  8834.         ns = NULL;
    8835. 

  8835.       for (; ns && ns->id; ns++)
    8836. 

  8836.       { if (*ns->id && (ns->out || ns->ns) && !strncmp(ns->id, tag, n) && !ns->id[n])
    8837. 

  8837.         { soap_push_ns(soap, ns->id, ns->out ? ns->out : ns->ns, 0);
    8838. 

  8838.           if (soap_attribute(soap, "xmlns", ns->out ? ns->out : ns->ns))
    8839. 

  8839.             return soap->error;
    8840. 

  8840.           break;
    8841. 

  8841.         }
    8842. 

  8842.       }   
    8843. 

  8843.     }
    8844. 

  8844.     else
    8845. 

  8845. #endif
    8846. 

  8846.     if (soap_send_raw(soap, "<", 1)
    8847. 

  8847.      || soap_send(soap, tag))
    8848. 

  8848.       return soap->error;
    8849. 

  8849. #ifdef WITH_DOM
    8850. 

  8850.   }
    8851. 

  8851. #endif
    8852. 

  8852.   if (!soap->ns)
    8853. 

  8853.   { struct Namespace *ns;
    8854. 

  8854.     int k = -1;
    8855. 

  8855. #ifndef WITH_LEAN
    8856. 

  8856.     if ((soap->mode & SOAP_XML_DEFAULTNS))
    8857. 

  8857.       k = 4; /* only produce the first four required entries */
    8858. 

  8858. #endif
    8859. 

  8859.     for (ns = soap->local_namespaces; ns && ns->id && k; ns++, k--)
    8860. 

  8860.     { if (*ns->id && (ns->out || ns->ns))
    8861. 

  8861.       { sprintf(soap->tmpbuf, "xmlns:%s", ns->id);
    8862. 

  8862.         if (soap_attribute(soap, soap->tmpbuf, ns->out ? ns->out : ns->ns))
    8863. 

  8863.           return soap->error;
    8864. 

  8864.       }
    8865. 

  8865.     }   
    8866. 

  8866.   }
    8867. 

  8867.   soap->ns = 1; /* namespace table control: ns = 0 or 2 to start, then 1 to stop dumping the table  */
    8868. 

  8868. #ifndef WITH_LEAN
    8869. 

  8869.   if (soap->mode & SOAP_XML_CANONICAL)
    8870. 

  8870.   { const char *t = strchr(tag, ':');
    8871. 

  8871.     if (t)
    8872. 

  8872.       soap_utilize_ns(soap, tag, t - tag);
    8873. 

  8873.   }
    8874. 

  8874. #endif
    8875. 

  8875.   if (id > 0)
    8876. 

  8876.   { sprintf(soap->tmpbuf, "_%d", id);
    8877. 

  8877.     if (soap_attribute(soap, "id", soap->tmpbuf))
    8878. 

  8878.       return soap->error;
    8879. 

  8879.   }
    8880. 

  8880.   if (type && *type && (!(soap->mode & SOAP_XML_SEC) || soap->part == SOAP_IN_BODY))
    8881. 

  8881.   { if (soap_attribute(soap, "xsi:type", type))
    8882. 

  8882.       return soap->error;
    8883. 

  8883. #ifndef WITH_LEAN
    8884. 

  8884.     if (soap->mode & SOAP_XML_CANONICAL)
    8885. 

  8885.     { const char *t = strchr(type, ':');
    8886. 

  8886.       if (t)
    8887. 

  8887.         soap_utilize_ns(soap, type, t - type);
    8888. 

  8888.     }
    8889. 

  8889. #endif
    8890. 

  8890.   }
    8891. 

  8891.   if (soap->null && soap->position > 0)
    8892. 

  8892.   { register int i;
    8893. 

  8893.     sprintf(soap->tmpbuf, "[%d", soap->positions[0]);
    8894. 

  8894.     for (i = 1; i < soap->position; i++)
    8895. 

  8895.       sprintf(soap->tmpbuf + strlen(soap->tmpbuf), ",%d", soap->positions[i]);
    8896. 

  8896.     strcat(soap->tmpbuf, "]");
    8897. 

  8897.     if (soap_attribute(soap, "SOAP-ENC:position", soap->tmpbuf))
    8898. 

  8898.       return soap->error;
    8899. 

  8899.   }
    8900. 

  8900.   if (soap->mustUnderstand)
    8901. 

  8901.   { if (soap->actor && *soap->actor)
    8902. 

  8902.     { if (soap_attribute(soap, soap->version == 2 ? "SOAP-ENV:role" : "SOAP-ENV:actor", soap->actor))
    8903. 

  8903.         return soap->error;
    8904. 

  8904.     }
    8905. 

  8905.     if (soap_attribute(soap, "SOAP-ENV:mustUnderstand", soap->version == 2 ? "true" : "1"))
    8906. 

  8906.       return soap->error;
    8907. 

  8907.     soap->mustUnderstand = 0;
    8908. 

  8908.   }
    8909. 

  8909.   if (soap->encoding)
    8910. 

  8910.   { if (soap->encodingStyle && soap->local_namespaces)
    8911. 

  8911.     { if (!*soap->encodingStyle)
    8912. 

  8912.       { if (soap->local_namespaces[1].out)
    8913. 

  8913.           soap->encodingStyle = soap->local_namespaces[1].out;
    8914. 

  8914.         else
    8915. 

  8915.           soap->encodingStyle = soap->local_namespaces[1].ns;
    8916. 

  8916.       }
    8917. 

  8917.       if (soap->encodingStyle && soap_attribute(soap, "SOAP-ENV:encodingStyle", soap->encodingStyle))
    8918. 

  8918.         return soap->error;
    8919. 

  8919.     }
    8920. 

  8920.     soap->encoding = 0;
    8921. 

  8921.   }
    8922. 

  8922.   soap->null = 0;
    8923. 

  8923.   soap->position = 0;
    8924. 

  8924.   if (soap->part == SOAP_BEGIN_SECURITY && (soap->mode & SOAP_XML_CANONICAL))
    8925. 

  8925.     soap->part = SOAP_IN_SECURITY;
    8926. 

  8926.   return SOAP_OK;
    8927. 

  8927. }
    8928. 

  8928. #endif
    8929. 

  8929. 

  8930. /******************************************************************************/
    8931. 

  8931. #ifndef PALM_2
    8932. 

  8932. SOAP_FMAC1
    8933. 

  8933. int
    8934. 

  8934. SOAP_FMAC2
    8935. 

  8935. soap_element_begin_out(struct soap *soap, const char *tag, int id, const char *type)
    8936. 

  8936. { if (*tag == '-')
    8937. 

  8937.     return SOAP_OK;
    8938. 

  8938.   if (soap_element(soap, tag, id, type))
    8939. 

  8939.     return soap->error;
    8940. 

  8940.   return soap_element_start_end_out(soap, NULL);
    8941. 

  8941. }
    8942. 

  8942. #endif
    8943. 

  8943. 

  8944. /******************************************************************************/
    8945. 

  8945. #ifndef PALM_2
    8946. 

  8946. #ifndef HAVE_STRRCHR
    8947. 

  8947. SOAP_FMAC1
    8948. 

  8948. char*
    8949. 

  8949. SOAP_FMAC2
    8950. 

  8950. soap_strrchr(const char *s, int t)
    8951. 

  8951. { register char *r = NULL;
    8952. 

  8952.   while (*s)
    8953. 

  8953.     if (*s++ == t)
    8954. 

  8954.       r = (char*)s - 1;
    8955. 

  8955.   return r;
    8956. 

  8956. }
    8957. 

  8957. #endif
    8958. 

  8958. #endif
    8959. 

  8959. 

  8960. /******************************************************************************/
    8961. 

  8961. #ifndef PALM_2
    8962. 

  8962. #ifndef HAVE_STRTOL
    8963. 

  8963. SOAP_FMAC1
    8964. 

  8964. long
    8965. 

  8965. SOAP_FMAC2
    8966. 

  8966. soap_strtol(const char *s, char **t, int b)
    8967. 

  8967. { register long n = 0;
    8968. 

  8968.   register int c;
    8969. 

  8969.   while (*s > 0 && *s <= 32)
    8970. 

  8970.     s++;
    8971. 

  8971.   if (b == 10)
    8972. 

  8972.   { short neg = 0;
    8973. 

  8973.     if (*s == '-')
    8974. 

  8974.     { s++;
    8975. 

  8975.       neg = 1;
    8976. 

  8976.     }
    8977. 

  8977.     else if (*s == '+')
    8978. 

  8978.       s++;
    8979. 

  8979.     while ((c = *s) && c >= '0' && c <= '9')
    8980. 

  8980.     { if (n >= 214748364 && (n > 214748364 || c >= '8'))
    8981. 

  8981.         break;
    8982. 

  8982.       n *= 10;
    8983. 

  8983.       n += c - '0';
    8984. 

  8984.       s++;
    8985. 

  8985.     }
    8986. 

  8986.     if (neg)
    8987. 

  8987.       n = -n;
    8988. 

  8988.   }
    8989. 

  8989.   else /* assume b == 16 and value is always positive */
    8990. 

  8990.   { while ((c = *s))
    8991. 

  8991.     { if (c >= '0' && c <= '9')
    8992. 

  8992.         c -= '0';
    8993. 

  8993.       else if (c >= 'A' && c <= 'F')
    8994. 

  8994.         c -= 'A' - 10;
    8995. 

  8995.       else if (c >= 'a' && c <= 'f')
    8996. 

  8996.         c -= 'a' - 10;
    8997. 

  8997.       if (n > 0x07FFFFFF)
    8998. 

  8998.         break;
    8999. 

  8999.       n <<= 4;
    9000. 

  9000.       n += c;
    9001. 

  9001.       s++;
    9002. 

  9002.     }
    9003. 

  9003.   }
    9004. 

  9004.   if (t)
    9005. 

  9005.     *t = (char*)s;
    9006. 

  9006.   return n;
    9007. 

  9007. }
    9008. 

  9008. #endif
    9009. 

  9009. #endif
    9010. 

  9010. 

  9011. /******************************************************************************/
    9012. 

  9012. #ifndef PALM_2
    9013. 

  9013. #ifndef HAVE_STRTOUL
    9014. 

  9014. SOAP_FMAC1
    9015. 

  9015. unsigned long
    9016. 

  9016. SOAP_FMAC2
    9017. 

  9017. soap_strtoul(const char *s, char **t, int b)
    9018. 

  9018. { unsigned long n = 0;
    9019. 

  9019.   register int c;
    9020. 

  9020.   while (*s > 0 && *s <= 32)
    9021. 

  9021.     s++;
    9022. 

  9022.   if (b == 10)
    9023. 

  9023.   { if (*s == '+')
    9024. 

  9024.       s++;
    9025. 

  9025.     while ((c = *s) && c >= '0' && c <= '9')
    9026. 

  9026.     { if (n >= 429496729 && (n > 429496729 || c >= '6'))
    9027. 

  9027.         break;
    9028. 

  9028.       n *= 10;
    9029. 

  9029.       n += c - '0';
    9030. 

  9030.       s++;
    9031. 

  9031.     }
    9032. 

  9032.   }
    9033. 

  9033.   else /* b == 16 */
    9034. 

  9034.   { while ((c = *s))
    9035. 

  9035.     { if (c >= '0' && c <= '9')
    9036. 

  9036.         c -= '0';
    9037. 

  9037.       else if (c >= 'A' && c <= 'F')
    9038. 

  9038.         c -= 'A' - 10;
    9039. 

  9039.       else if (c >= 'a' && c <= 'f')
    9040. 

  9040.         c -= 'a' - 10;
    9041. 

  9041.       if (n > 0x0FFFFFFF)
    9042. 

  9042.         break;
    9043. 

  9043.       n <<= 4;
    9044. 

  9044.       n += c;
    9045. 

  9045.       s++;
    9046. 

  9046.     }
    9047. 

  9047.   }
    9048. 

  9048.   if (t)
    9049. 

  9049.     *t = (char*)s;
    9050. 

  9050.   return n;
    9051. 

  9051. }
    9052. 

  9052. #endif
    9053. 

  9053. #endif
    9054. 

  9054. 

  9055. /******************************************************************************/
    9056. 

  9056. #ifndef PALM_1
    9057. 

  9057. SOAP_FMAC1
    9058. 

  9058. int
    9059. 

  9059. SOAP_FMAC2
    9060. 

  9060. soap_array_begin_out(struct soap *soap, const char *tag, int id, const char *type, const char *offset)
    9061. 

  9061. { if (!type || !*type)
    9062. 

  9062.     return soap_element_begin_out(soap, tag, id, NULL);
    9063. 

  9063.   if (soap_element(soap, tag, id, "SOAP-ENC:Array"))
    9064. 

  9064.     return soap->error;
    9065. 

  9065.   if (soap->version == 2)
    9066. 

  9066.   { const char *s;
    9067. 

  9067.     s = soap_strrchr(type, '[');
    9068. 

  9068.     if ((size_t)(s - type) < sizeof(soap->tmpbuf))
    9069. 

  9069.     { strncpy(soap->tmpbuf, type, s - type);
    9070. 

  9070.       soap->tmpbuf[s - type] = '\0';
    9071. 

  9071.       if (soap_attribute(soap, "SOAP-ENC:itemType", soap->tmpbuf))
    9072. 

  9072.         return soap->error;
    9073. 

  9073.       if (s && (soap_attribute(soap, "SOAP-ENC:arraySize", s + 1)))
    9074. 

  9074.         return soap->error;
    9075. 

  9075.     }
    9076. 

  9076.   }
    9077. 

  9077.   else
    9078. 

  9078.   { if (offset && soap_attribute(soap, "SOAP-ENC:offset", offset))
    9079. 

  9079.       return soap->error;
    9080. 

  9080.     if (soap_attribute(soap, "SOAP-ENC:arrayType", type))
    9081. 

  9081.       return soap->error;
    9082. 

  9082.   }
    9083. 

  9083. #ifndef WITH_LEAN
    9084. 

  9084.   if ((soap->mode & SOAP_XML_CANONICAL))
    9085. 

  9085.   { const char *s = strchr(type, ':');
    9086. 

  9086.     if (s)
    9087. 

  9087.       soap_utilize_ns(soap, type, s - type);
    9088. 

  9088.   }
    9089. 

  9089. #endif
    9090. 

  9090.   return soap_element_start_end_out(soap, NULL);
    9091. 

  9091. }
    9092. 

  9092. #endif
    9093. 

  9093. 

  9094. /******************************************************************************/
    9095. 

  9095. #ifndef PALM_1
    9096. 

  9096. SOAP_FMAC1
    9097. 

  9097. int
    9098. 

  9098. SOAP_FMAC2
    9099. 

  9099. soap_element_start_end_out(struct soap *soap, const char *tag)
    9100. 

  9100. { register struct soap_attribute *tp;
    9101. 

  9101. #ifndef WITH_LEAN
    9102. 

  9102.   if (soap->mode & SOAP_XML_CANONICAL)
    9103. 

  9103.   { struct soap_nlist *np;
    9104. 

  9104.     for (tp = soap->attributes; tp; tp = tp->next)
    9105. 

  9105.     { if (tp->visible && tp->name)
    9106. 

  9106.       { const char *s = strchr(tp->name, ':');
    9107. 

  9107.         if (s)
    9108. 

  9108.           soap_utilize_ns(soap, tp->name, s - tp->name);
    9109. 

  9109.       }
    9110. 

  9110.     }
    9111. 

  9111.     for (np = soap->nlist; np; np = np->next)
    9112. 

  9112.     { if (np->index == 1 && np->ns)
    9113. 

  9113.       { sprintf(soap->tmpbuf, "xmlns:%s", np->id);
    9114. 

  9114.         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Enabling utilized binding (level=%u) %s='%s'\n", np->level, soap->tmpbuf, np->ns));
    9115. 

  9115.         soap_set_attr(soap, soap->tmpbuf, np->ns, 1);
    9116. 

  9116.         np->index = 2;
    9117. 

  9117.       }
    9118. 

  9118.     }
    9119. 

  9119.   }
    9120. 

  9120. #endif
    9121. 

  9121. #ifdef WITH_DOM
    9122. 

  9122.   if ((soap->mode & SOAP_XML_DOM) && soap->dom)
    9123. 

  9123.   { register struct soap_dom_attribute **att;
    9124. 

  9124.     att = &soap->dom->atts;
    9125. 

  9125.     for (tp = soap->attributes; tp; tp = tp->next)
    9126. 

  9126.     { if (tp->visible)
    9127. 

  9127.       { *att = (struct soap_dom_attribute*)soap_malloc(soap, sizeof(struct soap_dom_attribute));
    9128. 

  9128.         if (!*att)
    9129. 

  9129.           return soap->error;
    9130. 

  9130.         (*att)->next = NULL;
    9131. 

  9131.         (*att)->nstr = NULL;
    9132. 

  9132.         (*att)->name = soap_strdup(soap, tp->name);
    9133. 

  9133.         (*att)->data = soap_strdup(soap, tp->value);
    9134. 

  9134.         (*att)->wide = NULL;
    9135. 

  9135.         (*att)->soap = soap;
    9136. 

  9136.         att = &(*att)->next;
    9137. 

  9137.         tp->visible = 0;
    9138. 

  9138.       }
    9139. 

  9139.     }
    9140. 

  9140.     return SOAP_OK;
    9141. 

  9141.   }
    9142. 

  9142. #endif
    9143. 

  9143.   for (tp = soap->attributes; tp; tp = tp->next)
    9144. 

  9144.   { if (tp->visible)
    9145. 

  9145.     {
    9146. 

  9146. #ifndef WITH_LEAN
    9147. 

  9147.       const char *s;
    9148. 

  9148.       if ((soap->mode & SOAP_XML_DEFAULTNS) && (s = strchr(tp->name, ':')))
    9149. 

  9149.       { size_t n = s - tp->name;
    9150. 

  9150.         if (soap->nlist && !strncmp(soap->nlist->id, tp->name, n) && !soap->nlist->id[n])
    9151. 

  9151.           s++;
    9152. 

  9152.         else
    9153. 

  9153.           s = tp->name;
    9154. 

  9154.         if (soap_send(soap, " ") || soap_send(soap, s))
    9155. 

  9155.           return soap->error;
    9156. 

  9156.       }
    9157. 

  9157.       else
    9158. 

  9158. #endif
    9159. 

  9159.       if (soap_send(soap, " ") || soap_send(soap, tp->name))
    9160. 

  9160.         return soap->error;
    9161. 

  9161.       if (tp->visible == 2 && tp->value)
    9162. 

  9162.         if (soap_send_raw(soap, "=\"", 2)
    9163. 

  9163.          || soap_string_out(soap, tp->value, tp->flag)
    9164. 

  9164.          || soap_send_raw(soap, "\"", 1))
    9165. 

  9165.           return soap->error;
    9166. 

  9166.       tp->visible = 0;
    9167. 

  9167.     }
    9168. 

  9168.   }
    9169. 

  9169.   if (tag)
    9170. 

  9170.   { 
    9171. 

  9171. #ifndef WITH_LEAN
    9172. 

  9172.     if (soap->mode & SOAP_XML_CANONICAL)
    9173. 

  9173.     { if (soap_send_raw(soap, ">", 1)
    9174. 

  9174.        || soap_element_end_out(soap, tag))
    9175. 

  9175.         return soap->error;
    9176. 

  9176.       return SOAP_OK;
    9177. 

  9177.     }
    9178. 

  9178. #endif
    9179. 

  9179.     soap->level--;	/* decrement level just before /> */
    9180. 

  9180.     if (soap_send_raw(soap, "/>", 2))
    9181. 

  9181.       return soap->error;
    9182. 

  9182.     return SOAP_OK;
    9183. 

  9183.   }
    9184. 

  9184.   return soap_send_raw(soap, ">", 1);
    9185. 

  9185. }
    9186. 

  9186. #endif
    9187. 

  9187. 

  9188. /******************************************************************************/
    9189. 

  9189. #ifndef PALM_1
    9190. 

  9190. SOAP_FMAC1
    9191. 

  9191. int
    9192. 

  9192. SOAP_FMAC2
    9193. 

  9193. soap_element_end_out(struct soap *soap, const char *tag)
    9194. 

  9194. {
    9195. 

  9195. #ifndef WITH_LEAN
    9196. 

  9196.   const char *s;
    9197. 

  9197. #endif
    9198. 

  9198.   if (*tag == '-')
    9199. 

  9199.     return SOAP_OK;
    9200. 

  9200.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Element ending tag='%s'\n", tag));
    9201. 

  9201. #ifdef WITH_DOM
    9202. 

  9202.   if ((soap->mode & SOAP_XML_DOM) && soap->dom)
    9203. 

  9203.   { if (soap->dom->prnt)
    9204. 

  9204.       soap->dom = soap->dom->prnt;
    9205. 

  9205.     return SOAP_OK;
    9206. 

  9206.   }
    9207. 

  9207. #endif
    9208. 

  9208. #ifndef WITH_LEAN
    9209. 

  9209.   if (soap->mode & SOAP_XML_CANONICAL)
    9210. 

  9210.     soap_pop_namespace(soap);
    9211. 

  9211.   if (soap->mode & SOAP_XML_INDENT)
    9212. 

  9212.   { if (!soap->body)
    9213. 

  9213.     { if (soap_send_raw(soap, soap_indent, soap->level < sizeof(soap_indent) ? soap->level : sizeof(soap_indent) - 1))
    9214. 

  9214.         return soap->error;
    9215. 

  9215.     }
    9216. 

  9216.     soap->body = 0;
    9217. 

  9217.   }
    9218. 

  9218.   if ((soap->mode & SOAP_XML_DEFAULTNS) && (s = strchr(tag, ':')))
    9219. 

  9219.   { soap_pop_namespace(soap);
    9220. 

  9220.     tag = s + 1;
    9221. 

  9221.   }
    9222. 

  9222. #endif
    9223. 

  9223.   if (soap_send_raw(soap, "</", 2)
    9224. 

  9224.    || soap_send(soap, tag))
    9225. 

  9225.     return soap->error;
    9226. 

  9226.   soap->level--;	/* decrement level just before > */
    9227. 

  9227.   return soap_send_raw(soap, ">", 1);
    9228. 

  9228. }
    9229. 

  9229. #endif
    9230. 

  9230. 

  9231. /******************************************************************************/
    9232. 

  9232. #ifndef PALM_1
    9233. 

  9233. SOAP_FMAC1
    9234. 

  9234. int
    9235. 

  9235. SOAP_FMAC2
    9236. 

  9236. soap_element_ref(struct soap *soap, const char *tag, int id, int href)
    9237. 

  9237. { register int n = 0;
    9238. 

  9238.   const char *s = "href";
    9239. 

  9239.   if (soap->version == 2)
    9240. 

  9240.   { s = "SOAP-ENC:ref";
    9241. 

  9241.     n = 1;
    9242. 

  9242.   }
    9243. 

  9243.   sprintf(soap->href, "#_%d", href);
    9244. 

  9244.   return soap_element_href(soap, tag, id, s, soap->href + n);
    9245. 

  9245. }
    9246. 

  9246. #endif
    9247. 

  9247. 

  9248. /******************************************************************************/
    9249. 

  9249. #ifndef PALM_1
    9250. 

  9250. SOAP_FMAC1
    9251. 

  9251. int
    9252. 

  9252. SOAP_FMAC2
    9253. 

  9253. soap_element_href(struct soap *soap, const char *tag, int id, const char *ref, const char *val)
    9254. 

  9254. { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Element '%s' reference %s='%s'\n", tag, ref, val));
    9255. 

  9255.   if (soap_element(soap, tag, id, NULL)
    9256. 

  9256.    || soap_attribute(soap, ref, val)
    9257. 

  9257.    || soap_element_start_end_out(soap, tag))
    9258. 

  9258.     return soap->error;
    9259. 

  9259.   return SOAP_OK;
    9260. 

  9260. }
    9261. 

  9261. #endif
    9262. 

  9262. 

  9263. /******************************************************************************/
    9264. 

  9264. #ifndef PALM_1
    9265. 

  9265. SOAP_FMAC1
    9266. 

  9266. int
    9267. 

  9267. SOAP_FMAC2
    9268. 

  9268. soap_element_null(struct soap *soap, const char *tag, int id, const char *type)
    9269. 

  9269. { struct soap_attribute *tp;
    9270. 

  9270.   for (tp = soap->attributes; tp; tp = tp->next)
    9271. 

  9271.     if (tp->visible)
    9272. 

  9272.       break;
    9273. 

  9273.   if (tp || (soap->version == 2 && soap->position > 0) || id > 0 || (soap->mode & SOAP_XML_NIL))
    9274. 

  9274.   { if (soap_element(soap, tag, id, type))
    9275. 

  9275.       return soap->error;
    9276. 

  9276.     if (!tp && soap_attribute(soap, "xsi:nil", "true"))
    9277. 

  9277.       return soap->error;
    9278. 

  9278.     return soap_element_start_end_out(soap, tag);
    9279. 

  9279.   }
    9280. 

  9280.   soap->null = 1;
    9281. 

  9281.   soap->position = 0;
    9282. 

  9282.   soap->mustUnderstand = 0;
    9283. 

  9283.   return SOAP_OK;
    9284. 

  9284. }
    9285. 

  9285. #endif
    9286. 

  9286. 

  9287. /******************************************************************************/
    9288. 

  9288. #ifndef PALM_1
    9289. 

  9289. SOAP_FMAC1
    9290. 

  9290. int
    9291. 

  9291. SOAP_FMAC2
    9292. 

  9292. 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) 
    9293. 

  9293. { if (!p)
    9294. 

  9294.   { soap_element_null(soap, tag, id, type);
    9295. 

  9295.     return -1;
    9296. 

  9296.   }
    9297. 

  9297. #ifndef WITH_NOIDREF
    9298. 

  9298.   if (soap->mode & SOAP_XML_TREE)
    9299. 

  9299.     return 0;
    9300. 

  9300.   if (id < 0)
    9301. 

  9301.   { struct soap_plist *pp;
    9302. 

  9302.     if (a)
    9303. 

  9303.       id = soap_array_pointer_lookup(soap, p, a, n, t, &pp);
    9304. 

  9304.     else
    9305. 

  9305.       id = soap_pointer_lookup(soap, p, t, &pp);
    9306. 

  9306.     if (id)
    9307. 

  9307.     { if (soap_is_embedded(soap, pp))
    9308. 

  9308.       { soap_element_ref(soap, tag, 0, id);
    9309. 

  9309.         return -1;
    9310. 

  9310.       }
    9311. 

  9311.       if (soap_is_single(soap, pp))
    9312. 

  9312.         return 0;
    9313. 

  9313.       soap_set_embedded(soap, pp);
    9314. 

  9314.     }
    9315. 

  9315.   }
    9316. 

  9316.   return id;
    9317. 

  9317. #else
    9318. 

  9318.   return 0;
    9319. 

  9319. #endif
    9320. 

  9320. }
    9321. 

  9321. #endif
    9322. 

  9322. 

  9323. /******************************************************************************/
    9324. 

  9324. #ifndef PALM_1
    9325. 

  9325. SOAP_FMAC1
    9326. 

  9326. int
    9327. 

  9327. SOAP_FMAC2
    9328. 

  9328. soap_element_result(struct soap *soap, const char *tag)
    9329. 

  9329. { if (soap->version == 2 && soap->encodingStyle)
    9330. 

  9330.   { if (soap_element(soap, "SOAP-RPC:result", 0, NULL)
    9331. 

  9331.      || soap_attribute(soap, "xmlns:SOAP-RPC", soap_rpc)
    9332. 

  9332.      || soap_element_start_end_out(soap, NULL)
    9333. 

  9333.      || soap_string_out(soap, tag, 0)
    9334. 

  9334.      || soap_element_end_out(soap, "SOAP-RPC:result"))
    9335. 

  9335.       return soap->error;
    9336. 

  9336.   }
    9337. 

  9337.   return SOAP_OK;
    9338. 

  9338. }
    9339. 

  9339. #endif
    9340. 

  9340. 

  9341. /******************************************************************************/
    9342. 

  9342. #ifndef PALM_1
    9343. 

  9343. SOAP_FMAC1
    9344. 

  9344. void
    9345. 

  9345. SOAP_FMAC2
    9346. 

  9346. soap_check_result(struct soap *soap, const char *tag)
    9347. 

  9347. { if (soap->version == 2 && soap->encodingStyle)
    9348. 

  9348.   { soap_instring(soap, ":result", NULL, NULL, 0, 2, -1, -1);
    9349. 

  9349.     /* just ignore content for compliance reasons, but should compare tag to element's QName value? */
    9350. 

  9350.   }
    9351. 

  9351. }
    9352. 

  9352. #endif
    9353. 

  9353. 

  9354. /******************************************************************************/
    9355. 

  9355. #ifndef PALM_2
    9356. 

  9356. SOAP_FMAC1
    9357. 

  9357. int
    9358. 

  9358. SOAP_FMAC2
    9359. 

  9359. soap_attribute(struct soap *soap, const char *name, const char *value)
    9360. 

  9360. { 
    9361. 

  9361.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Attribute '%s'='%s'\n", name, value));
    9362. 

  9362. #ifdef WITH_DOM
    9363. 

  9363.   if ((soap->mode & SOAP_XML_DOM) && !(soap->mode & SOAP_XML_CANONICAL) && soap->dom)
    9364. 

  9364.   { register struct soap_dom_attribute *a = (struct soap_dom_attribute*)soap_malloc(soap, sizeof(struct soap_dom_attribute));
    9365. 

  9365.     if (!a)
    9366. 

  9366.       return soap->error;
    9367. 

  9367.     a->next = soap->dom->atts;
    9368. 

  9368.     a->nstr = NULL;
    9369. 

  9369.     a->name = soap_strdup(soap, name);
    9370. 

  9370.     a->data = soap_strdup(soap, value);
    9371. 

  9371.     a->wide = NULL;
    9372. 

  9372.     a->soap = soap;
    9373. 

  9373.     soap->dom->atts = a;
    9374. 

  9374.     return SOAP_OK;
    9375. 

  9375.   }
    9376. 

  9376. #endif
    9377. 

  9377. #ifndef WITH_LEAN
    9378. 

  9378.   if (soap->mode & SOAP_XML_CANONICAL)
    9379. 

  9379.   { /* TODO: consider using this code to handle default namespace bindings
    9380. 

  9380.     if (!strncmp(name, "xmlns", 5) && (name[5] == ':' || name[5] == '\0'))
    9381. 

  9381.     { if (name[5] == ':')
    9382. 

  9382.         soap_push_ns(soap, name + 6, value, 0);
    9383. 

  9383.       else
    9384. 

  9384.         soap_push_ns(soap, "", value, 0);
    9385. 

  9385.     }
    9386. 

  9386.     */
    9387. 

  9387.     if (!strncmp(name, "xmlns:", 6))
    9388. 

  9388.       soap_push_ns(soap, name + 6, value, 0);
    9389. 

  9389.     else if (soap_set_attr(soap, name, value, 1))
    9390. 

  9390.       return soap->error;
    9391. 

  9391.   }
    9392. 

  9392.   else
    9393. 

  9393. #endif
    9394. 

  9394.   { if (soap_send(soap, " ") || soap_send(soap, name))
    9395. 

  9395.       return soap->error;
    9396. 

  9396.     if (value)
    9397. 

  9397.       if (soap_send_raw(soap, "=\"", 2)
    9398. 

  9398.        || soap_string_out(soap, value, 1)
    9399. 

  9399.        || soap_send_raw(soap, "\"", 1))
    9400. 

  9400.         return soap->error;
    9401. 

  9401.   }
    9402. 

  9402.   return SOAP_OK;
    9403. 

  9403. }
    9404. 

  9404. #endif
    9405. 

  9405. 

  9406. /******************************************************************************/
    9407. 

  9407. #ifndef PALM_2
    9408. 

  9408. SOAP_FMAC1
    9409. 

  9409. int
    9410. 

  9410. SOAP_FMAC2
    9411. 

  9411. soap_element_begin_in(struct soap *soap, const char *tag, int nillable, const char *type)
    9412. 

  9412. { if (!soap_peek_element(soap))
    9413. 

  9413.   { if (soap->other)
    9414. 

  9414.       return soap->error = SOAP_TAG_MISMATCH;
    9415. 

  9415.     if (tag && *tag == '-')
    9416. 

  9416.       return SOAP_OK;
    9417. 

  9417.     if (!(soap->error = soap_match_tag(soap, soap->tag, tag)))
    9418. 

  9418.     { soap->peeked = 0;
    9419. 

  9419.       if (type && *soap->type && soap_match_tag(soap, soap->type, type))
    9420. 

  9420.         return soap->error = SOAP_TYPE;
    9421. 

  9421.       if (!nillable && soap->null && (soap->mode & SOAP_XML_STRICT))
    9422. 

  9422.         return soap->error = SOAP_NULL;
    9423. 

  9423.       if (soap->body)
    9424. 

  9424.         soap->level++;
    9425. 

  9425.       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Begin element found (level=%u) '%s'='%s'\n", soap->level, soap->tag, tag?tag:SOAP_STR_EOS ));
    9426. 

  9426.     }
    9427. 

  9427.   }
    9428. 

  9428.   else if (soap->error == SOAP_NO_TAG && tag && *tag == '-')
    9429. 

  9429.     soap->error = SOAP_OK;
    9430. 

  9430.   return soap->error;
    9431. 

  9431. }
    9432. 

  9432. #endif
    9433. 

  9433. 

  9434. /******************************************************************************/
    9435. 

  9435. #ifndef PALM_2
    9436. 

  9436. SOAP_FMAC1
    9437. 

  9437. int
    9438. 

  9438. SOAP_FMAC2
    9439. 

  9439. soap_element_end_in(struct soap *soap, const char *tag)  
    9440. 

  9440. { register soap_wchar c;
    9441. 

  9441.   register char *s;
    9442. 

  9442.   register int n = 0;
    9443. 

  9443.   if (tag && *tag == '-')
    9444. 

  9444.     return SOAP_OK;
    9445. 

  9445.   if (soap->error == SOAP_NO_TAG)
    9446. 

  9446.     soap->error = SOAP_OK;
    9447. 

  9447. #ifdef WITH_DOM
    9448. 

  9448.   /* this whitespace or mixed content is not insignificant for DOM */
    9449. 

  9449.   if ((soap->mode & SOAP_XML_DOM) && soap->dom)
    9450. 

  9450.   { if (!soap->peeked && !soap_string_in(soap, 3, -1, -1))
    9451. 

  9451.       return soap->error;
    9452. 

  9452.     if (soap->dom->prnt)
    9453. 

  9453.       soap->dom = soap->dom->prnt;
    9454. 

  9454.   }
    9455. 

  9455. #endif
    9456. 

  9456.   if (soap->peeked)
    9457. 

  9457.   { if (*soap->tag)
    9458. 

  9458.       n++;
    9459. 

  9459.     soap->peeked = 0;
    9460. 

  9460.   }
    9461. 

  9461.   do
    9462. 

  9462.   { while (((c = soap_get(soap)) != SOAP_TT))
    9463. 

  9463.     { if ((int)c == EOF)
    9464. 

  9464.         return soap->error = SOAP_EOF;
    9465. 

  9465.       if (c == SOAP_LT)
    9466. 

  9466.         n++;
    9467. 

  9467.       else if (c == '/')
    9468. 

  9468.       { c = soap_get(soap);
    9469. 

  9469.         if (c == SOAP_GT)
    9470. 

  9470.           n--;
    9471. 

  9471.         else
    9472. 

  9472.           soap_unget(soap, c);
    9473. 

  9473.       }
    9474. 

  9474.     }
    9475. 

  9475.   } while (n--);
    9476. 

  9476.   s = soap->tag;
    9477. 

  9477.   n = sizeof(soap->tag);
    9478. 

  9478.   while (soap_notblank(c = soap_get(soap)))
    9479. 

  9479.   { if (--n > 0)
    9480. 

  9480.       *s++ = (char)c;
    9481. 

  9481.   }
    9482. 

  9482.   *s = '\0';
    9483. 

  9483.   if ((int)c == EOF)
    9484. 

  9484.     return soap->error = SOAP_EOF;
    9485. 

  9485.   while (soap_blank(c))
    9486. 

  9486.     c = soap_get(soap);
    9487. 

  9487.   if (c != SOAP_GT)
    9488. 

  9488.     return soap->error = SOAP_SYNTAX_ERROR;
    9489. 

  9489.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End element found (level=%u) '%s'='%s'\n", soap->level, soap->tag, tag?tag:SOAP_STR_EOS));
    9490. 

  9490. #ifndef WITH_LEAN
    9491. 

  9491.   if (tag && (soap->mode & SOAP_XML_STRICT))
    9492. 

  9492.   { soap_pop_namespace(soap);
    9493. 

  9493.     if (soap_match_tag(soap, soap->tag, tag))
    9494. 

  9494.     { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End element tag name does not match\n"));
    9495. 

  9495.       return soap->error = SOAP_SYNTAX_ERROR;
    9496. 

  9496.     }
    9497. 

  9497.   }
    9498. 

  9498. #endif
    9499. 

  9499.   soap->level--;
    9500. 

  9500.   return SOAP_OK;
    9501. 

  9501. }
    9502. 

  9502. #endif
    9503. 

  9503. 

  9504. /******************************************************************************/
    9505. 

  9505. #ifndef PALM_2
    9506. 

  9506. SOAP_FMAC1
    9507. 

  9507. const char *
    9508. 

  9508. SOAP_FMAC2
    9509. 

  9509. soap_attr_value(struct soap *soap, const char *name, int flag)
    9510. 

  9510. { register struct soap_attribute *tp;
    9511. 

  9511.   if (*name == '-')
    9512. 

  9512.     return SOAP_STR_EOS;
    9513. 

  9513.   for (tp = soap->attributes; tp; tp = tp->next)
    9514. 

  9514.   { if (tp->visible && !soap_match_tag(soap, tp->name, name))
    9515. 

  9515.       break;
    9516. 

  9516.   }
    9517. 

  9517.   if (tp)
    9518. 

  9518.   { if (flag == 2 && (soap->mode & SOAP_XML_STRICT))
    9519. 

  9519.       soap->error = SOAP_PROHIBITED;
    9520. 

  9520.     else
    9521. 

  9521.       return tp->value;
    9522. 

  9522.   }
    9523. 

  9523.   else if (flag == 1 && (soap->mode & SOAP_XML_STRICT))
    9524. 

  9524.     soap->error = SOAP_REQUIRED;
    9525. 

  9525.   else
    9526. 

  9526.     soap->error = SOAP_OK;
    9527. 

  9527.   return NULL;
    9528. 

  9528. }
    9529. 

  9529. #endif
    9530. 

  9530. 

  9531. /******************************************************************************/
    9532. 

  9532. #ifndef PALM_2
    9533. 

  9533. SOAP_FMAC1
    9534. 

  9534. int
    9535. 

  9535. SOAP_FMAC2
    9536. 

  9536. soap_set_attr(struct soap *soap, const char *name, const char *value, int flag)
    9537. 

  9537. { register struct soap_attribute *tp;
    9538. 

  9538.   if (*name == '-')
    9539. 

  9539.     return SOAP_OK;
    9540. 

  9540.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Set attribute %s='%s'\n", name, value?value:SOAP_STR_EOS));
    9541. 

  9541.   for (tp = soap->attributes; tp; tp = tp->next)
    9542. 

  9542.   { if (!strcmp(tp->name, name))
    9543. 

  9543.       break;
    9544. 

  9544.   }
    9545. 

  9545.   if (!tp)
    9546. 

  9546.   { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Allocate attribute %s\n", name));
    9547. 

  9547.     if (!(tp = (struct soap_attribute*)SOAP_MALLOC(soap, sizeof(struct soap_attribute) + strlen(name))))
    9548. 

  9548.       return soap->error = SOAP_EOM;
    9549. 

  9549.     tp->ns = NULL;
    9550. 

  9550. #ifndef WITH_LEAN
    9551. 

  9551.     if ((soap->mode & SOAP_XML_CANONICAL))
    9552. 

  9552.     { struct soap_attribute **tpp = &soap->attributes;
    9553. 

  9553.       const char *s = strchr(name, ':');
    9554. 

  9554.       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inserting attribute %s for c14n\n", name))
    9555. 

  9555.       if (!strncmp(name, "xmlns", 5))
    9556. 

  9556.       { for (; *tpp; tpp = &(*tpp)->next)
    9557. 

  9557.           if (strncmp((*tpp)->name, "xmlns", 5) || strcmp((*tpp)->name + 5, name + 5) > 0)
    9558. 

  9558.             break;
    9559. 

  9559.       }
    9560. 

  9560.       else if (!s)
    9561. 

  9561.       { for (; *tpp; tpp = &(*tpp)->next)
    9562. 

  9562.           if (strncmp((*tpp)->name, "xmlns", 5) && ((*tpp)->ns || strcmp((*tpp)->name, name) > 0))
    9563. 

  9563.             break;
    9564. 

  9564.       }
    9565. 

  9565.       else
    9566. 

  9566.       { int k;
    9567. 

  9567.         for (; *tpp; tpp = &(*tpp)->next)
    9568. 

  9568.         { if (!strncmp((*tpp)->name, "xmlns:", 6) && !strncmp((*tpp)->name + 6, name, s - name) && !(*tpp)->name[6 + s - name])
    9569. 

  9569.           { if (!tp->ns)
    9570. 

  9570.             { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Canonicalization: prefix %s=%p (%s)\n", name, (*tpp)->ns, (*tpp)->ns));
    9571. 

  9571.               tp->ns = (*tpp)->ns;
    9572. 

  9572.             }
    9573. 

  9573.           }
    9574. 

  9574.           else if (strncmp((*tpp)->name, "xmlns", 5) && (*tpp)->ns && tp->ns && ((k = strcmp((*tpp)->ns, tp->ns)) > 0 || (!k && strcmp((*tpp)->name, name) > 0)))
    9575. 

  9575.             break;
    9576. 

  9576.         }
    9577. 

  9577.       }
    9578. 

  9578.       tp->next = *tpp;
    9579. 

  9579.       *tpp = tp;
    9580. 

  9580.     }
    9581. 

  9581.     else
    9582. 

  9582. #endif
    9583. 

  9583.     { tp->next = soap->attributes;
    9584. 

  9584.       soap->attributes = tp;
    9585. 

  9585.     }
    9586. 

  9586.     strcpy(tp->name, name);
    9587. 

  9587.     tp->value = NULL;
    9588. 

  9588.   }
    9589. 

  9589.   else if (tp->visible)
    9590. 

  9590.   { return SOAP_OK;
    9591. 

  9591.   }
    9592. 

  9592.   else if (value && tp->value && tp->size <= strlen(value))
    9593. 

  9593.   { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free attribute value of %s (free %p)\n", name, tp->value));
    9594. 

  9594.     SOAP_FREE(soap, tp->value);
    9595. 

  9595.     tp->value = NULL;
    9596. 

  9596.     tp->ns = NULL;
    9597. 

  9597.   }
    9598. 

  9598.   if (value)
    9599. 

  9599.   { if (!tp->value)
    9600. 

  9600.     { tp->size = strlen(value) + 1;
    9601. 

  9601.       if (!(tp->value = (char*)SOAP_MALLOC(soap, tp->size)))
    9602. 

  9602.         return soap->error = SOAP_EOM;
    9603. 

  9603.       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Allocate attribute value for %s (%p)\n", tp->name, tp->value));
    9604. 

  9604.     }
    9605. 

  9605.     strcpy(tp->value, value);
    9606. 

  9606.     if (!strncmp(tp->name, "xmlns:", 6))
    9607. 

  9607.       tp->ns = tp->value;
    9608. 

  9608.     tp->visible = 2;
    9609. 

  9609.     tp->flag = flag;
    9610. 

  9610. #ifndef WITH_LEAN
    9611. 

  9611.     if (soap->part != SOAP_IN_SECURITY && !strcmp(name, "wsu:Id"))
    9612. 

  9612.     { soap->part = SOAP_BEGIN_SECURITY;
    9613. 

  9613.       strncpy(soap->id, value, sizeof(soap->id));
    9614. 

  9614.       soap->id[sizeof(soap->id)-1] = '\0';
    9615. 

  9615.     }
    9616. 

  9616. #endif
    9617. 

  9617.   }
    9618. 

  9618.   else
    9619. 

  9619.     tp->visible = 1;
    9620. 

  9620.   return SOAP_OK;
    9621. 

  9621. }
    9622. 

  9622. #endif
    9623. 

  9623. 

  9624. /******************************************************************************/
    9625. 

  9625. #ifndef PALM_2
    9626. 

  9626. SOAP_FMAC1
    9627. 

  9627. void
    9628. 

  9628. SOAP_FMAC2
    9629. 

  9629. soap_clr_attr(struct soap *soap)
    9630. 

  9630. { register struct soap_attribute *tp;
    9631. 

  9631. #ifndef WITH_LEAN
    9632. 

  9632.   if ((soap->mode & SOAP_XML_CANONICAL))
    9633. 

  9633.   { while (soap->attributes)
    9634. 

  9634.     { tp = soap->attributes->next;
    9635. 

  9635.       if (soap->attributes->value)
    9636. 

  9636.         SOAP_FREE(soap, soap->attributes->value);
    9637. 

  9637.       SOAP_FREE(soap, soap->attributes);
    9638. 

  9638.       soap->attributes = tp;
    9639. 

  9639.     }
    9640. 

  9640.   }
    9641. 

  9641.   else
    9642. 

  9642. #endif
    9643. 

  9643.   { for (tp = soap->attributes; tp; tp = tp->next)
    9644. 

  9644.       tp->visible = 0;
    9645. 

  9645.   }
    9646. 

  9646. }
    9647. 

  9647. #endif
    9648. 

  9648. 

  9649. /******************************************************************************/
    9650. 

  9650. #ifndef PALM_2
    9651. 

  9651. static int
    9652. 

  9652. soap_getattrval(struct soap *soap, char *s, size_t n, soap_wchar d)
    9653. 

  9653. { register size_t i;
    9654. 

  9654.   for (i = 0; i < n; i++)
    9655. 

  9655.   { register soap_wchar c = soap_get(soap);
    9656. 

  9656.     switch (c)
    9657. 

  9657.     {
    9658. 

  9658.     case SOAP_TT:
    9659. 

  9659.       *s++ = '<';
    9660. 

  9660.       soap_unget(soap, '/');
    9661. 

  9661.       break;
    9662. 

  9662.     case SOAP_LT:
    9663. 

  9663.       *s++ = '<';
    9664. 

  9664.       break;
    9665. 

  9665.     case SOAP_GT:
    9666. 

  9666.       if (d == ' ')
    9667. 

  9667.       { soap_unget(soap, c);
    9668. 

  9668.         *s = '\0';
    9669. 

  9669.         return SOAP_OK;
    9670. 

  9670.       }
    9671. 

  9671.       *s++ = '>';
    9672. 

  9672.       break;
    9673. 

  9673.     case SOAP_QT:
    9674. 

  9674.       if (c == d)
    9675. 

  9675.       { *s = '\0';
    9676. 

  9676.         return SOAP_OK;
    9677. 

  9677.       }
    9678. 

  9678.       *s++ = '"';
    9679. 

  9679.       break;
    9680. 

  9680.     case SOAP_AP:
    9681. 

  9681.       if (c == d)
    9682. 

  9682.       { *s = '\0';
    9683. 

  9683.         return SOAP_OK;
    9684. 

  9684.       }
    9685. 

  9685.       *s++ = '\'';
    9686. 

  9686.       break;
    9687. 

  9687.     case '\t':
    9688. 

  9688.     case '\n':
    9689. 

  9689.     case '\r':
    9690. 

  9690.     case ' ':
    9691. 

  9691.     case '/':
    9692. 

  9692.       if (d == ' ')
    9693. 

  9693.       { soap_unget(soap, c);
    9694. 

  9694.         *s = '\0';
    9695. 

  9695.         return SOAP_OK;
    9696. 

  9696.       }
    9697. 

  9697.     default:
    9698. 

  9698.       if ((int)c == EOF)
    9699. 

  9699.         return soap->error = SOAP_EOF;
    9700. 

  9700.       *s++ = (char)c;
    9701. 

  9701.     }
    9702. 

  9702.   }
    9703. 

  9703.   return soap->error = SOAP_EOM;
    9704. 

  9704. }
    9705. 

  9705. #endif
    9706. 

  9706. 

  9707. /******************************************************************************/
    9708. 

  9708. #ifdef WITH_FAST
    9709. 

  9709. #ifndef PALM_2
    9710. 

  9710. SOAP_FMAC1
    9711. 

  9711. int
    9712. 

  9712. SOAP_FMAC2
    9713. 

  9713. soap_store_lab(struct soap *soap, const char *s, size_t n)
    9714. 

  9714. { soap->labidx = 0;
    9715. 

  9715.   return soap_append_lab(soap, s, n);
    9716. 

  9716. }
    9717. 

  9717. #endif
    9718. 

  9718. #endif
    9719. 

  9719. 

  9720. /******************************************************************************/
    9721. 

  9721. #ifdef WITH_FAST
    9722. 

  9722. #ifndef PALM_2
    9723. 

  9723. SOAP_FMAC1
    9724. 

  9724. int
    9725. 

  9725. SOAP_FMAC2
    9726. 

  9726. soap_append_lab(struct soap *soap, const char *s, size_t n)
    9727. 

  9727. { if (soap->labidx + n >= soap->lablen)
    9728. 

  9728.   { register char *t = soap->labbuf;
    9729. 

  9729.     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Enlarging look-aside buffer to append data, old size=%lu", (unsigned long)soap->lablen));
    9730. 

  9730.     if (soap->lablen == 0)
    9731. 

  9731.       soap->lablen = SOAP_LABLEN;
    9732. 

  9732.     while (soap->labidx + n >= soap->lablen)
    9733. 

  9733.       soap->lablen <<= 1;
    9734. 

  9734.     DBGLOG(TEST, SOAP_MESSAGE(fdebug, ", new size=%lu\n", (unsigned long)soap->lablen));
    9735. 

  9735.     soap->labbuf = (char*)SOAP_MALLOC(soap, soap->lablen);
    9736. 

  9736.     if (!soap->labbuf)
    9737. 

  9737.     { if (t)
    9738. 

  9738.         SOAP_FREE(soap, t);
    9739. 

  9739.       return soap->error = SOAP_EOM;
    9740. 

  9740.     }
    9741. 

  9741.     if (t)
    9742. 

  9742.     { memcpy(soap->labbuf, t, soap->labidx);
    9743. 

  9743.       SOAP_FREE(soap, t);
    9744. 

  9744.     }
    9745. 

  9745.   }
    9746. 

  9746.   if (s)
    9747. 

  9747.   { memcpy(soap->labbuf + soap->labidx, s, n);
    9748. 

  9748.     soap->labidx += n;
    9749. 

  9749.   }
    9750. 

  9750.   return SOAP_OK;
    9751. 

  9751. }
    9752. 

  9752. #endif
    9753. 

  9753. #endif
    9754. 

  9754. 

  9755. /******************************************************************************/
    9756. 

  9756. #ifndef PALM_2
    9757. 

  9757. SOAP_FMAC1
    9758. 

  9758. int
    9759. 

  9759. SOAP_FMAC2
    9760. 

  9760. soap_peek_element(struct soap *soap)
    9761. 

  9761. {
    9762. 

  9762. #ifdef WITH_DOM
    9763. 

  9763.   register struct soap_dom_attribute **att = NULL;
    9764. 

  9764.   register char *lead = NULL;
    9765. 

  9765. #endif
    9766. 

  9766.   register struct soap_attribute *tp, *tq = NULL;
    9767. 

  9767.   register const char *t;
    9768. 

  9768.   register char *s;
    9769. 

  9769.   register soap_wchar c;
    9770. 

  9770.   register int i;
    9771. 

  9771.   if (soap->peeked)
    9772. 

  9772.   { if (!*soap->tag)
    9773. 

  9773.       return soap->error = SOAP_NO_TAG;
    9774. 

  9774.     return SOAP_OK;
    9775. 

  9775.   }
    9776. 

  9776.   soap->peeked = 1;
    9777. 

  9777.   soap->id[0] = '\0';
    9778. 

  9778.   soap->href[0] = '\0';
    9779. 

  9779.   soap->type[0] = '\0';
    9780. 

  9780.   soap->arrayType[0] = '\0';
    9781. 

  9781.   soap->arraySize[0] = '\0';
    9782. 

  9782.   soap->arrayOffset[0] = '\0';
    9783. 

  9783.   soap->other = 0;
    9784. 

  9784.   soap->root = -1;
    9785. 

  9785.   soap->position = 0;
    9786. 

  9786.   soap->null = 0;
    9787. 

  9787.   soap->mustUnderstand = 0;
    9788. 

  9788.   /* skip BOM */
    9789. 

  9789.   if ((c = soap_getchar(soap)) != 0xEF || (c = soap_get1(soap)) != 0xBB || (c = soap_get1(soap)) != 0xBF)
    9790. 

  9790.     soap_unget(soap, c);
    9791. 

  9791.   c = soap_get(soap);
    9792. 

  9792. #ifdef WITH_DOM
    9793. 

  9793.   /* whitespace leading to start tag is not insignificant for DOM */
    9794. 

  9794.   if (soap_blank(c))
    9795. 

  9795.   { soap->labidx = 0;
    9796. 

  9796.     do
    9797. 

  9797.     { if (soap_append_lab(soap, NULL, 0))
    9798. 

  9798.         return soap->error;
    9799. 

  9799.       s = soap->labbuf + soap->labidx;
    9800. 

  9800.       i = soap->lablen - soap->labidx;
    9801. 

  9801.       soap->labidx = soap->lablen;
    9802. 

  9802.       while (soap_blank(c) && i--)
    9803. 

  9803.       { *s++ = c;
    9804. 

  9804.         c = soap_get(soap);
    9805. 

  9805.       }
    9806. 

  9806.     }
    9807. 

  9807.     while (soap_blank(c));
    9808. 

  9808.     *s = '\0';
    9809. 

  9809.     if (*soap->labbuf)
    9810. 

  9810.       lead = soap->labbuf;
    9811. 

  9811.   }
    9812. 

  9812. #else
    9813. 

  9813.   /* skip space */
    9814. 

  9814.   while (soap_blank(c))
    9815. 

  9815.     c = soap_get(soap);
    9816. 

  9816. #endif
    9817. 

  9817.   if (c != SOAP_LT)
    9818. 

  9818.   { *soap->tag = '\0';
    9819. 

  9819.     if ((int)c == EOF)
    9820. 

  9820.       return soap->error = SOAP_EOF;
    9821. 

  9821.     soap_unget(soap, c);
    9822. 

  9822. #ifdef WITH_DOM
    9823. 

  9823.     /* whitespace leading to end tag is not insignificant for DOM */
    9824. 

  9824.     if ((soap->mode & SOAP_XML_DOM) && soap->dom)
    9825. 

  9825.       soap->dom->tail = soap_strdup(soap, lead);
    9826. 

  9826. #endif
    9827. 

  9827.     return soap->error = SOAP_NO_TAG;
    9828. 

  9828.   }
    9829. 

  9829.   s = soap->tag;
    9830. 

  9830.   do c = soap_get1(soap);
    9831. 

  9831.   while (soap_blank(c));
    9832. 

  9832.   i = sizeof(soap->tag);
    9833. 

  9833.   while (c != '>' && c != '/' && soap_notblank(c) && (int)c != EOF)
    9834. 

  9834.   { if (--i > 0)
    9835. 

  9835.       *s++ = (char)c;
    9836. 

  9836.     c = soap_get1(soap);
    9837. 

  9837.   }
    9838. 

  9838.   while (soap_blank(c))
    9839. 

  9839.     c = soap_get1(soap);
    9840. 

  9840.   *s = '\0';
    9841. 

  9841. #ifdef WITH_DOM
    9842. 

  9842.   if (soap->mode & SOAP_XML_DOM)
    9843. 

  9843.   { register struct soap_dom_element *elt;
    9844. 

  9844.     elt = (struct soap_dom_element*)soap_malloc(soap, sizeof(struct soap_dom_element));
    9845. 

  9845.     if (!elt)
    9846. 

  9846.       return soap->error;
    9847. 

  9847.     elt->next = NULL;
    9848. 

  9848.     elt->nstr = NULL;
    9849. 

  9849.     elt->name = soap_strdup(soap, soap->tag);
    9850. 

  9850.     elt->prnt = soap->dom;
    9851. 

  9851.     elt->elts = NULL;
    9852. 

  9852.     elt->atts = NULL;
    9853. 

  9853.     elt->data = NULL;
    9854. 

  9854.     elt->wide = NULL;
    9855. 

  9855.     elt->type = 0;
    9856. 

  9856.     elt->node = NULL;
    9857. 

  9857.     elt->head = soap_strdup(soap, lead);
    9858. 

  9858.     elt->tail = NULL;
    9859. 

  9859.     elt->soap = soap;
    9860. 

  9860.     if (soap->dom)
    9861. 

  9861.     { struct soap_dom_element *p = soap->dom->elts;
    9862. 

  9862.       if (p)
    9863. 

  9863.       { while (p->next)
    9864. 

  9864.           p = p->next;
    9865. 

  9865.         p->next = elt;
    9866. 

  9866.       }
    9867. 

  9867.       else
    9868. 

  9868.         soap->dom->elts = elt;
    9869. 

  9869.     }
    9870. 

  9870.     soap->dom = elt;
    9871. 

  9871.     att = &elt->atts;
    9872. 

  9872.   }
    9873. 

  9873. #endif
    9874. 

  9874.   soap_pop_namespace(soap);
    9875. 

  9875.   for (tp = soap->attributes; tp; tp = tp->next)
    9876. 

  9876.     tp->visible = 0;
    9877. 

  9877.   while ((int)c != EOF && c != '>' && c != '/')
    9878. 

  9878.   { s = soap->tmpbuf;
    9879. 

  9879.     i = sizeof(soap->tmpbuf);
    9880. 

  9880.     while (c != '=' && c != '>' && c != '/' && soap_notblank(c) && (int)c != EOF)
    9881. 

  9881.     { if (--i > 0)
    9882. 

  9882.         *s++ = (char)c;
    9883. 

  9883.       c = soap_get1(soap);
    9884. 

  9884.     }
    9885. 

  9885.     *s = '\0';
    9886. 

  9886.     if (i == sizeof(soap->tmpbuf))
    9887. 

  9887.       return soap->error = SOAP_SYNTAX_ERROR;
    9888. 

  9888. #ifdef WITH_DOM
    9889. 

  9889.     /* add attribute name to dom */
    9890. 

  9890.     if (att)
    9891. 

  9891.     { *att = (struct soap_dom_attribute*)soap_malloc(soap, sizeof(struct soap_dom_attribute));
    9892. 

  9892.        if (!*att)
    9893. 

  9893.          return soap->error;
    9894. 

  9894.        (*att)->next = NULL;
    9895. 

  9895.        (*att)->nstr = NULL;
    9896. 

  9896.        (*att)->name = soap_strdup(soap, soap->tmpbuf);
    9897. 

  9897.        (*att)->data = NULL;
    9898. 

  9898.        (*att)->wide = NULL;
    9899. 

  9899.        (*att)->soap = soap;
    9900. 

  9900.     }
    9901. 

  9901. #endif
    9902. 

  9902.     if (!strncmp(soap->tmpbuf, "xmlns", 5))
    9903. 

  9903.     { if (soap->tmpbuf[5] == ':')
    9904. 

  9904.         t = soap->tmpbuf + 6;
    9905. 

  9905.       else if (soap->tmpbuf[5])
    9906. 

  9906.         t = NULL;
    9907. 

  9907.       else
    9908. 

  9908.         t = SOAP_STR_EOS;
    9909. 

  9909.     }
    9910. 

  9910.     else
    9911. 

  9911.       t = NULL;
    9912. 

  9912.     tq = NULL;
    9913. 

  9913.     for (tp = soap->attributes; tp; tq = tp, tp = tp->next)
    9914. 

  9914.     { if (!SOAP_STRCMP(tp->name, soap->tmpbuf))
    9915. 

  9915.         break;
    9916. 

  9916.     }
    9917. 

  9917.     if (!tp)
    9918. 

  9918.     { tp = (struct soap_attribute*)SOAP_MALLOC(soap, sizeof(struct soap_attribute) + strlen(soap->tmpbuf));
    9919. 

  9919.       if (!tp)
    9920. 

  9920.         return soap->error = SOAP_EOM;
    9921. 

  9921.       strcpy(tp->name, soap->tmpbuf);
    9922. 

  9922.       tp->value = NULL;
    9923. 

  9923.       tp->size = 0;
    9924. 

  9924.       /* if attribute name is qualified, append it to the end of the list */
    9925. 

  9925.       if (tq && strchr(soap->tmpbuf, ':'))
    9926. 

  9926.       { tq->next = tp;
    9927. 

  9927.         tp->next = NULL;
    9928. 

  9928.       }
    9929. 

  9929.       else
    9930. 

  9930.       { tp->next = soap->attributes;
    9931. 

  9931.         soap->attributes = tp;
    9932. 

  9932.       }
    9933. 

  9933.     }
    9934. 

  9934.     while (soap_blank(c))
    9935. 

  9935.       c = soap_get1(soap);
    9936. 

  9936.     if (c == '=')
    9937. 

  9937.     { do c = soap_getutf8(soap);
    9938. 

  9938.       while (soap_blank(c));
    9939. 

  9939.       if (c != SOAP_QT && c != SOAP_AP)
    9940. 

  9940.       { soap_unget(soap, c);
    9941. 

  9941.         c = ' '; /* blank delimiter */
    9942. 

  9942.       }
    9943. 

  9943.       if (soap_getattrval(soap, tp->value, tp->size, c))
    9944. 

  9944.       {
    9945. 

  9945. #ifdef WITH_FAST
    9946. 

  9946.         if (soap->error != SOAP_EOM)
    9947. 

  9947.           return soap->error;
    9948. 

  9948.         soap->error = SOAP_OK;
    9949. 

  9949.         if (soap_store_lab(soap, tp->value, tp->size))
    9950. 

  9950.           return soap->error;
    9951. 

  9951.         if (tp->value)
    9952. 

  9952.           SOAP_FREE(soap, tp->value);
    9953. 

  9953.         for (;;)
    9954. 

  9954.         { if (soap_getattrval(soap, soap->labbuf + soap->labidx, soap->lablen - soap->labidx, c))
    9955. 

  9955.           { if (soap->error != SOAP_EOM)
    9956. 

  9956.               return soap->error;
    9957. 

  9957.             soap->error = SOAP_OK;
    9958. 

  9958.             soap->labidx = soap->lablen;
    9959. 

  9959.             if (soap_append_lab(soap, NULL, 0))
    9960. 

  9960.               return soap->error;
    9961. 

  9961.           }
    9962. 

  9962.           else
    9963. 

  9963.             break;
    9964. 

  9964.         }
    9965. 

  9965.         if (soap->labidx)
    9966. 

  9966.           tp->size = soap->lablen;
    9967. 

  9967.         else
    9968. 

  9968.         { tp->size = strlen(soap->labbuf) + 1;
    9969. 

  9969.           if (tp->size < SOAP_LABLEN)
    9970. 

  9970.             tp->size = SOAP_LABLEN;
    9971. 

  9971.         }
    9972. 

  9972.         if (!(tp->value = (char*)SOAP_MALLOC(soap, tp->size)))
    9973. 

  9973.           return soap->error = SOAP_EOM;
    9974. 

  9974.         strcpy(tp->value, soap->labbuf);
    9975. 

  9975. #else
    9976. 

  9976.         size_t n;
    9977. 

  9977.         if (soap->error != SOAP_EOM)
    9978. 

  9978.           return soap->error;
    9979. 

  9979.         soap->error = SOAP_OK;
    9980. 

  9980.         if (soap_new_block(soap) == NULL)
    9981. 

  9981.           return soap->error;
    9982. 

  9982.         for (;;)
    9983. 

  9983.         { if (!(s = (char*)soap_push_block(soap, NULL, SOAP_BLKLEN)))
    9984. 

  9984.             return soap->error;
    9985. 

  9985.           if (soap_getattrval(soap, s, SOAP_BLKLEN, c))
    9986. 

  9986.           { if (soap->error != SOAP_EOM)
    9987. 

  9987.               return soap->error;
    9988. 

  9988.             soap->error = SOAP_OK;
    9989. 

  9989.           }
    9990. 

  9990.           else
    9991. 

  9991.             break;
    9992. 

  9992.         }
    9993. 

  9993.         n = tp->size + soap->blist->size;
    9994. 

  9994.         if (!(s = (char*)SOAP_MALLOC(soap, n)))
    9995. 

  9995.           return soap->error = SOAP_EOM;
    9996. 

  9996.         if (tp->value)
    9997. 

  9997.         { memcpy(s, tp->value, tp->size);
    9998. 

  9998.           SOAP_FREE(soap, tp->value);
    9999. 

  9999.         }
    10000. 

  10000.         soap_save_block(soap, NULL, s + tp->size, 0);
    10001. 

  10001.         tp->value = s;
    10002. 

  10002.         tp->size = n;
    10003. 

  10003. #endif
    10004. 

  10004.       }
    10005. 

  10005.       do c = soap_get1(soap);
    10006. 

  10006.       while (soap_blank(c));
    10007. 

  10007.       tp->visible = 2; /* seen this attribute w/ value */
    10008. 

  10008. #ifdef WITH_DOM
    10009. 

  10009.       if (att)
    10010. 

  10010.         (*att)->data = soap_strdup(soap, tp->value);
    10011. 

  10011. #endif
    10012. 

  10012.     }
    10013. 

  10013.     else
    10014. 

  10014.       tp->visible = 1; /* seen this attribute w/o value */
    10015. 

  10015. #ifdef WITH_DOM
    10016. 

  10016.     if (att)
    10017. 

  10017.       att = &(*att)->next;
    10018. 

  10018. #endif
    10019. 

  10019.     if (t && tp->value)
    10020. 

  10020.     { if (soap_push_namespace(soap, t, tp->value) == NULL)
    10021. 

  10021.         return soap->error;
    10022. 

  10022.     }
    10023. 

  10023.   }
    10024. 

  10024. #ifdef WITH_DOM
    10025. 

  10025.   if (att)
    10026. 

  10026.   { soap->dom->nstr = soap_current_namespace(soap, soap->tag);
    10027. 

  10027.     for (att = &soap->dom->atts; *att; att = &(*att)->next)
    10028. 

  10028.       (*att)->nstr = soap_current_namespace(soap, (*att)->name);
    10029. 

  10029.   }
    10030. 

  10030. #endif
    10031. 

  10031.   if ((int)c == EOF)
    10032. 

  10032.     return soap->error = SOAP_EOF;
    10033. 

  10033.   if (!(soap->body = (c != '/')))
    10034. 

  10034.     do c = soap_get1(soap);
    10035. 

  10035.     while (soap_blank(c));
    10036. 

  10036. #ifdef WITH_DOM
    10037. 

  10037.   if (soap->mode & SOAP_XML_DOM)
    10038. 

  10038.   { if (!soap->body && soap->dom->prnt)
    10039. 

  10039.       soap->dom = soap->dom->prnt;
    10040. 

  10040.   }
    10041. 

  10041. #endif
    10042. 

  10042.   for (tp = soap->attributes; tp; tp = tp->next)
    10043. 

  10043.   { if (tp->visible && tp->value)
    10044. 

  10044.     { 
    10045. 

  10045. #ifndef WITH_NOIDREF
    10046. 

  10046.       if (!strcmp(tp->name, "id"))
    10047. 

  10047.       { if ((soap->version > 0 && !(soap->mode & SOAP_XML_TREE))
    10048. 

  10048.          || (soap->mode & SOAP_XML_GRAPH))
    10049. 

  10049.         { *soap->id = '#';
    10050. 

  10050.           strncpy(soap->id + 1, tp->value, sizeof(soap->id) - 2);
    10051. 

  10051.           soap->id[sizeof(soap->id)-1] = '\0';
    10052. 

  10052.         }
    10053. 

  10053.       }
    10054. 

  10054.       else if (!strcmp(tp->name, "href"))
    10055. 

  10055.       { if (soap->version == 1
    10056. 

  10056.          || (soap->mode & SOAP_XML_GRAPH)
    10057. 

  10057.          || (soap->mode & SOAP_ENC_MTOM)
    10058. 

  10058.          || (soap->mode & SOAP_ENC_DIME))
    10059. 

  10059.         { strncpy(soap->href, tp->value, sizeof(soap->href) - 1);
    10060. 

  10060.           soap->href[sizeof(soap->href)-1] = '\0';
    10061. 

  10061.         }
    10062. 

  10062.       }
    10063. 

  10063.       else
    10064. 

  10064. #endif
    10065. 

  10065.       if (!soap_match_tag(soap, tp->name, "xsi:type"))
    10066. 

  10066.       { strncpy(soap->type, tp->value, sizeof(soap->type) - 1);
    10067. 

  10067.         soap->type[sizeof(soap->type)-1] = '\0';
    10068. 

  10068.       }
    10069. 

  10069.       else if ((!soap_match_tag(soap, tp->name, "xsi:null")
    10070. 

  10070.              || !soap_match_tag(soap, tp->name, "xsi:nil"))
    10071. 

  10071.             && (!strcmp(tp->value, "1")
    10072. 

  10072.              || !strcmp(tp->value, "true")))
    10073. 

  10073.       { soap->null = 1;
    10074. 

  10074.       }
    10075. 

  10075.       else if (soap->version == 1)
    10076. 

  10076.       { if (!soap_match_tag(soap, tp->name, "SOAP-ENC:arrayType"))
    10077. 

  10077.         { s = soap_strrchr(tp->value, '[');
    10078. 

  10078.           if (s && (size_t)(s - tp->value) < sizeof(soap->arrayType))
    10079. 

  10079.           { strncpy(soap->arrayType, tp->value, s - tp->value);
    10080. 

  10080.             soap->arrayType[s - tp->value] = '\0';
    10081. 

  10081.             strncpy(soap->arraySize, s, sizeof(soap->arraySize) - 1);
    10082. 

  10082.           }
    10083. 

  10083.           else
    10084. 

  10084.             strncpy(soap->arrayType, tp->value, sizeof(soap->arrayType) - 1);
    10085. 

  10085.           soap->arraySize[sizeof(soap->arrayType)-1] = '\0';
    10086. 

  10086.           soap->arrayType[sizeof(soap->arrayType)-1] = '\0';
    10087. 

  10087.         }
    10088. 

  10088.         else if (!soap_match_tag(soap, tp->name, "SOAP-ENC:offset"))
    10089. 

  10089.           strncpy(soap->arrayOffset, tp->value, sizeof(soap->arrayOffset));
    10090. 

  10090.         else if (!soap_match_tag(soap, tp->name, "SOAP-ENC:position"))
    10091. 

  10091.           soap->position = soap_getposition(tp->value, soap->positions);
    10092. 

  10092.         else if (!soap_match_tag(soap, tp->name, "SOAP-ENC:root"))
    10093. 

  10093.           soap->root = ((!strcmp(tp->value, "1") || !strcmp(tp->value, "true")));
    10094. 

  10094.         else if (!soap_match_tag(soap, tp->name, "SOAP-ENV:mustUnderstand")
    10095. 

  10095.               && (!strcmp(tp->value, "1") || !strcmp(tp->value, "true")))
    10096. 

  10096.           soap->mustUnderstand = 1;
    10097. 

  10097.         else if (!soap_match_tag(soap, tp->name, "SOAP-ENV:actor"))
    10098. 

  10098.         { if ((!soap->actor || strcmp(soap->actor, tp->value))
    10099. 

  10099.            && strcmp(tp->value, "http://schemas.xmlsoap.org/soap/actor/next"))
    10100. 

  10100.             soap->other = 1;
    10101. 

  10101.         }
    10102. 

  10102.       }
    10103. 

  10103.       else if (soap->version == 2)
    10104. 

  10104.       {
    10105. 

  10105. #ifndef WITH_NOIDREF
    10106. 

  10106.         if (!strcmp(tp->name, "ref")
    10107. 

  10107.          || !soap_match_tag(soap, tp->name, "SOAP-ENC:ref"))
    10108. 

  10108.         { *soap->href = '#';
    10109. 

  10109.           strncpy(soap->href + 1, tp->value, sizeof(soap->href) - 2);
    10110. 

  10110.           soap->href[sizeof(soap->href)-1] = '\0';
    10111. 

  10111.         }
    10112. 

  10112.         else
    10113. 

  10113. #endif
    10114. 

  10114. 	if (!soap_match_tag(soap, tp->name, "SOAP-ENC:itemType"))
    10115. 

  10115.           strncpy(soap->arrayType, tp->value, sizeof(soap->arrayType) - 1);
    10116. 

  10116.         else if (!soap_match_tag(soap, tp->name, "SOAP-ENC:arraySize"))
    10117. 

  10117.           strncpy(soap->arraySize, tp->value, sizeof(soap->arraySize) - 1);
    10118. 

  10118.         else if (!soap_match_tag(soap, tp->name, "SOAP-ENV:mustUnderstand")
    10119. 

  10119.               && (!strcmp(tp->value, "1") || !strcmp(tp->value, "true")))
    10120. 

  10120.           soap->mustUnderstand = 1;
    10121. 

  10121.         else if (!soap_match_tag(soap, tp->name, "SOAP-ENV:role"))
    10122. 

  10122.         { if ((!soap->actor || strcmp(soap->actor, tp->value))
    10123. 

  10123.            && strcmp(tp->value, "http://www.w3.org/2003/05/soap-envelope/role/next"))
    10124. 

  10124.             soap->other = 1;
    10125. 

  10125.         }
    10126. 

  10126.       }
    10127. 

  10127.       else
    10128. 

  10128.       { if (!soap_match_tag(soap, tp->name, "wsdl:required") && !strcmp(tp->value, "true"))
    10129. 

  10129.           soap->mustUnderstand = 1;
    10130. 

  10130.       }
    10131. 

  10131.     }
    10132. 

  10132.   }
    10133. 

  10133.   return soap->error = SOAP_OK;
    10134. 

  10134. }
    10135. 

  10135. #endif
    10136. 

  10136. 

  10137. /******************************************************************************/
    10138. 

  10138. #ifndef PALM_2
    10139. 

  10139. SOAP_FMAC1
    10140. 

  10140. void
    10141. 

  10141. SOAP_FMAC2
    10142. 

  10142. soap_retry(struct soap *soap)
    10143. 

  10143. { soap->error = SOAP_OK;
    10144. 

  10144.   soap_revert(soap);
    10145. 

  10145. }
    10146. 

  10146. #endif
    10147. 

  10147. 

  10148. /******************************************************************************/
    10149. 

  10149. #ifndef PALM_2
    10150. 

  10150. SOAP_FMAC1
    10151. 

  10151. void
    10152. 

  10152. SOAP_FMAC2
    10153. 

  10153. soap_revert(struct soap *soap)
    10154. 

  10154. { if (!soap->peeked)
    10155. 

  10155.   { soap->peeked = 1;
    10156. 

  10156.     if (soap->body)
    10157. 

  10157.       soap->level--;
    10158. 

  10158.   }
    10159. 

  10159.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Reverting last element (level=%u)\n", soap->level));
    10160. 

  10160. }
    10161. 

  10161. #endif
    10162. 

  10162. 

  10163. /******************************************************************************/
    10164. 

  10164. #ifndef PALM_2
    10165. 

  10165. SOAP_FMAC1
    10166. 

  10166. int
    10167. 

  10167. SOAP_FMAC2
    10168. 

  10168. soap_string_out(struct soap *soap, const char *s, int flag)
    10169. 

  10169. { register const char *t;
    10170. 

  10170.   register soap_wchar c;
    10171. 

  10171.   register soap_wchar mask = (soap_wchar)0xFFFFFF80UL;
    10172. 

  10172. #ifdef WITH_DOM
    10173. 

  10173.   if ((soap->mode & SOAP_XML_DOM) && soap->dom)
    10174. 

  10174.   { soap->dom->data = soap_strdup(soap, s);
    10175. 

  10175.     return SOAP_OK;
    10176. 

  10176.   }
    10177. 

  10177. #endif
    10178. 

  10178.   if (flag == 2 || soap->mode & SOAP_C_UTFSTRING)
    10179. 

  10179.     mask = 0;
    10180. 

  10180.   t = s;
    10181. 

  10181.   while ((c = *t++))
    10182. 

  10182.   { switch (c)
    10183. 

  10183.     { 
    10184. 

  10184.     case 0x09:
    10185. 

  10185.       if (flag)
    10186. 

  10186.       { if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, "&#x9;", 5))
    10187. 

  10187.           return soap->error;
    10188. 

  10188.         s = t;
    10189. 

  10189.       }
    10190. 

  10190.       break;
    10191. 

  10191.     case 0x0A:
    10192. 

  10192.       if (flag || !(soap->mode & SOAP_XML_CANONICAL))
    10193. 

  10193.       { if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, "&#xA;", 5))
    10194. 

  10194.           return soap->error;
    10195. 

  10195.         s = t;
    10196. 

  10196.       }
    10197. 

  10197.       break;
    10198. 

  10198.     case 0x0D:
    10199. 

  10199.       if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, "&#xD;", 5))
    10200. 

  10200.         return soap->error;
    10201. 

  10201.       s = t;
    10202. 

  10202.       break;
    10203. 

  10203.     case '&':
    10204. 

  10204.       if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, "&amp;", 5))
    10205. 

  10205.         return soap->error;
    10206. 

  10206.       s = t;
    10207. 

  10207.       break;
    10208. 

  10208.     case '<':
    10209. 

  10209.       if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, "&lt;", 4))
    10210. 

  10210.         return soap->error;
    10211. 

  10211.       s = t;
    10212. 

  10212.       break;
    10213. 

  10213.     case '>':
    10214. 

  10214.       if (!flag)
    10215. 

  10215.       { if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, "&gt;", 4))
    10216. 

  10216.           return soap->error;
    10217. 

  10217.         s = t;
    10218. 

  10218.       }
    10219. 

  10219.       break;
    10220. 

  10220.     case '"':
    10221. 

  10221.       if (flag)
    10222. 

  10222.       { if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, "&quot;", 6))
    10223. 

  10223.           return soap->error;
    10224. 

  10224.         s = t;
    10225. 

  10225.       }
    10226. 

  10226.       break;
    10227. 

  10227.     default:
    10228. 

  10228. #ifndef WITH_LEANER
    10229. 

  10229. #ifdef HAVE_MBTOWC
    10230. 

  10230.       if (soap->mode & SOAP_C_MBSTRING)
    10231. 

  10231.       { wchar_t wc;
    10232. 

  10232.         register int m = mbtowc(&wc, t - 1, MB_CUR_MAX);
    10233. 

  10233.         if (m > 0 && wc != c)
    10234. 

  10234.         { if (soap_send_raw(soap, s, t - s - 1) || soap_pututf8(soap, wc))
    10235. 

  10235.             return soap->error;
    10236. 

  10236.           s = t += m - 1;
    10237. 

  10237.           continue;
    10238. 

  10238.         }
    10239. 

  10239.       }
    10240. 

  10240. #endif
    10241. 

  10241. #endif
    10242. 

  10242. #ifndef WITH_NOSTRINGTOUTF8
    10243. 

  10243.       if ((c & mask) || !(c & 0xFFFFFFE0UL))
    10244. 

  10244.       { if (soap_send_raw(soap, s, t - s - 1) || soap_pututf8(soap, (unsigned char)c))
    10245. 

  10245.           return soap->error;
    10246. 

  10246.         s = t;
    10247. 

  10247.       }
    10248. 

  10248. #endif
    10249. 

  10249.     }
    10250. 

  10250.   }
    10251. 

  10251.   return soap_send_raw(soap, s, t - s - 1);
    10252. 

  10252. }
    10253. 

  10253. #endif
    10254. 

  10254. 

  10255. /******************************************************************************/
    10256. 

  10256. #ifndef PALM_2
    10257. 

  10257. SOAP_FMAC1
    10258. 

  10258. char *
    10259. 

  10259. SOAP_FMAC2
    10260. 

  10260. soap_string_in(struct soap *soap, int flag, long minlen, long maxlen)
    10261. 

  10261. { register char *s;
    10262. 

  10262.   char *t = NULL;
    10263. 

  10263.   register size_t i;
    10264. 

  10264.   register long l = 0;
    10265. 

  10265.   register int n = 0, f = 0, m = 0;
    10266. 

  10266.   register soap_wchar c;
    10267. 

  10267. #if !defined(WITH_LEANER) && defined(HAVE_WCTOMB)
    10268. 

  10268.   char buf[MB_LEN_MAX > 8 ? MB_LEN_MAX : 8];
    10269. 

  10269. #else
    10270. 

  10270.   char buf[8];
    10271. 

  10271. #endif
    10272. 

  10272.   DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Reading string content, flag=%d\n", flag));
    10273. 

  10273.   if (soap->peeked && *soap->tag)
    10274. 

  10274.   {
    10275. 

  10275. #ifndef WITH_LEAN
    10276. 

  10276.     struct soap_attribute *tp;
    10277. 

  10277.     DBGLOG(TEST,SOAP_MESSAGE(fdebug, "String content includes tag '%s' and attributes\n", soap->tag));
    10278. 

  10278.     t = soap->tmpbuf;
    10279. 

  10279.     *t = '<';
    10280. 

  10280.     t[sizeof(soap->tmpbuf)-1] = '\0';
    10281. 

  10281.     strncpy(t + 1, soap->tag, sizeof(soap->tmpbuf) - 2);
    10282. 

  10282.     t += strlen(t);
    10283. 

  10283.     for (tp = soap->attributes; tp; tp = tp->next)
    10284. 

  10284.     { if (tp->visible)
    10285. 

  10285.       { if (t >= soap->tmpbuf + sizeof(soap->tmpbuf) - 2)
    10286. 

  10286.           break;
    10287. 

  10287.         *t++ = ' ';
    10288. 

  10288.         strcpy(t, tp->name);
    10289. 

  10289.         t += strlen(t);
    10290. 

  10290.         if (t >= soap->tmpbuf + sizeof(soap->tmpbuf) - 2)
    10291. 

  10291.           break; /* too many or large attribute values */
    10292. 

  10292.         if (tp->value)
    10293. 

  10293.         { *t++ = '=';
    10294. 

  10294.           *t++ = '"';
    10295. 

  10295.           strcpy(t, tp->value);
    10296. 

  10296.           t += strlen(t);
    10297. 

  10297.           *t++ = '"';
    10298. 

  10298.         }
    10299. 

  10299.       }
    10300. 

  10300.     }
    10301. 

  10301.     if (!soap->body)
    10302. 

  10302.       *t++ = '/';
    10303. 

  10303.     *t++ = '>';
    10304. 

  10304.     *t = '\0';
    10305. 

  10305.     t = soap->tmpbuf;
    10306. 

  10306.     m = (int)strlen(soap->tmpbuf);
    10307. 

  10307. #endif
    10308. 

  10308.     if (soap->body)
    10309. 

  10309.       n = 1;
    10310. 

  10310.     f = 1;
    10311. 

  10311.     soap->peeked = 0;
    10312. 

  10312.   }
    10313. 

  10313. #ifdef WITH_CDATA
    10314. 

  10314.   if (!flag)
    10315. 

  10315.   { register int state = 0;
    10316. 

  10316. #ifdef WITH_FAST
    10317. 

  10317.     soap->labidx = 0;			/* use look-aside buffer */
    10318. 

  10318. #else
    10319. 

  10319.     if (soap_new_block(soap) == NULL)
    10320. 

  10320.       return NULL;
    10321. 

  10321. #endif
    10322. 

  10322.     for (;;)
    10323. 

  10323.     { 
    10324. 

  10324. #ifdef WITH_FAST
    10325. 

  10325.       register size_t k;
    10326. 

  10326.       if (soap_append_lab(soap, NULL, 0))	/* allocate more space in look-aside buffer if necessary */
    10327. 

  10327.         return NULL;
    10328. 

  10328.       s = soap->labbuf + soap->labidx;	/* space to populate */
    10329. 

  10329.       k = soap->lablen - soap->labidx;	/* number of bytes available */
    10330. 

  10330.       soap->labidx = soap->lablen;	/* claim this space */
    10331. 

  10331. #else
    10332. 

  10332.       register size_t k = SOAP_BLKLEN;
    10333. 

  10333.       if (!(s = (char*)soap_push_block(soap, NULL, k)))
    10334. 

  10334.         return NULL;
    10335. 

  10335. #endif
    10336. 

  10336.       for (i = 0; i < k; i++)
    10337. 

  10337.       { if (m > 0)
    10338. 

  10338.         { *s++ = *t++;	/* copy multibyte characters */
    10339. 

  10339.           m--;
    10340. 

  10340.           continue;
    10341. 

  10341.         }
    10342. 

  10342.         c = soap_getchar(soap);
    10343. 

  10343.         if ((int)c == EOF)
    10344. 

  10344.           goto end;
    10345. 

  10345.         if (c >= 0x80 && state != 1 && !(soap->mode & SOAP_ENC_LATIN))
    10346. 

  10346.         { soap_unget(soap, c);
    10347. 

  10347.           c = soap_getutf8(soap);
    10348. 

  10348.           if (soap->mode & SOAP_C_UTFSTRING)
    10349. 

  10349.           { c &= 0x7FFFFFFF;
    10350. 

  10350.             t = buf;
    10351. 

  10351.             if (c < 0x0800)
    10352. 

  10352.               *t++ = (char)(0xC0 | ((c >> 6) & 0x1F));
    10353. 

  10353.             else
    10354. 

  10354.             { if (c < 0x010000)
    10355. 

  10355.                 *t++ = (char)(0xE0 | ((c >> 12) & 0x0F));
    10356. 

  10356.               else
    10357. 

  10357.               { if (c < 0x200000)
    10358. 

  10358.                   *t++ = (char)(0xF0 | ((c >> 18) & 0x07));
    10359. 

  10359.                 else
    10360. 

  10360.                 { if (c < 0x04000000)
    10361. 

  10361.                     *t++ = (char)(0xF8 | ((c >> 24) & 0x03));
    10362. 

  10362.                   else
    10363. 

  10363.                   { *t++ = (char)(0xFC | ((c >> 30) & 0x01));
    10364. 

  10364.                     *t++ = (char)(0x80 | ((c >> 24) & 0x3F));
    10365. 

  10365.                   }
    10366. 

  10366.                   *t++ = (char)(0x80 | ((c >> 18) & 0x3F));
    10367. 

  10367.                 }     
    10368. 

  10368.                 *t++ = (char)(0x80 | ((c >> 12) & 0x3F));
    10369. 

  10369.               }
    10370. 

  10370.               *t++ = (char)(0x80 | ((c >> 6) & 0x3F));
    10371. 

  10371.             }
    10372. 

  10372.             *t++ = (char)(0x80 | (c & 0x3F));
    10373. 

  10373.             m = (int)(t - buf) - 1;
    10374. 

  10374.             t = buf;
    10375. 

  10375.             *s++ = *t++;
    10376. 

  10376.             continue;
    10377. 

  10377.           }
    10378. 

  10378.         }
    10379. 

  10379.         switch (state)
    10380. 

  10380.         { case 1:
    10381. 

  10381.             if (c == ']')
    10382. 

  10382.               state = 4;
    10383. 

  10383.             *s++ = c;
    10384. 

  10384.             continue;
    10385. 

  10385.           case 2:
    10386. 

  10386.             if (c == '-')
    10387. 

  10387.               state = 6;
    10388. 

  10388.             *s++ = c;
    10389. 

  10389.             continue;
    10390. 

  10390.           case 3:
    10391. 

  10391.             if (c == '?')
    10392. 

  10392.               state = 8;
    10393. 

  10393.             *s++ = c;
    10394. 

  10394.             continue;
    10395. 

  10395.           /* CDATA */
    10396. 

  10396.           case 4:
    10397. 

  10397.             if (c == ']')
    10398. 

  10398.               state = 5;
    10399. 

  10399.             else
    10400. 

  10400.               state = 1;
    10401. 

  10401.             *s++ = c;
    10402. 

  10402.             continue;
    10403. 

  10403.           case 5:
    10404. 

  10404.             if (c == '>')
    10405. 

  10405.               state = 0;
    10406. 

  10406.             else
    10407. 

  10407.               state = 1;
    10408. 

  10408.             *s++ = c;
    10409. 

  10409.             continue;
    10410. 

  10410.           /* comment */
    10411. 

  10411.           case 6:
    10412. 

  10412.             if (c == '-')
    10413. 

  10413.               state = 7;
    10414. 

  10414.             else
    10415. 

  10415.               state = 2;
    10416. 

  10416.             *s++ = c;
    10417. 

  10417.             continue;
    10418. 

  10418.           case 7:
    10419. 

  10419.             if (c == '>')
    10420. 

  10420.               state = 0;
    10421. 

  10421.             else
    10422. 

  10422.               state = 2;
    10423. 

  10423.             *s++ = c;
    10424. 

  10424.             continue;
    10425. 

  10425.           /* PI */
    10426. 

  10426.           case 8:
    10427. 

  10427.             if (c == '>')
    10428. 

  10428.               state = 0;
    10429. 

  10429.             else
    10430. 

  10430.               state = 3;
    10431. 

  10431.             *s++ = c;
    10432. 

  10432.             continue;
    10433. 

  10433.         }
    10434. 

  10434.         switch (c)
    10435. 

  10435.         {
    10436. 

  10436.         case SOAP_TT:
    10437. 

  10437.           if (n == 0)
    10438. 

  10438.             goto end;
    10439. 

  10439.           n--;
    10440. 

  10440.           *s++ = '<';
    10441. 

  10441.           t = (char*)"/";
    10442. 

  10442.           m = 1;
    10443. 

  10443.           break;
    10444. 

  10444.         case SOAP_LT:
    10445. 

  10445. 	  if (f && n == 0)
    10446. 

  10446. 	    goto end;
    10447. 

  10447.           n++;
    10448. 

  10448.           *s++ = '<';
    10449. 

  10449.           break;
    10450. 

  10450.         case '/':
    10451. 

  10451.           if (n > 0)
    10452. 

  10452.           { c = soap_getchar(soap);
    10453. 

  10453.             if (c == '>')
    10454. 

  10454.               n--;
    10455. 

  10455.             soap_unget(soap, c);
    10456. 

  10456.           }
    10457. 

  10457.           *s++ = '/';
    10458. 

  10458.           break;
    10459. 

  10459.         case '<':
    10460. 

  10460.           c = soap_getchar(soap);
    10461. 

  10461.           if (c == '/')
    10462. 

  10462.           { if (n == 0)
    10463. 

  10463.             { c = SOAP_TT;
    10464. 

  10464.               goto end;
    10465. 

  10465.             }
    10466. 

  10466.             n--;
    10467. 

  10467.           }
    10468. 

  10468.           else if (c == '!')
    10469. 

  10469.           { c = soap_getchar(soap);
    10470. 

  10470.             if (c == '[')
    10471. 

  10471.             { do c = soap_getchar(soap);
    10472. 

  10472.               while ((int)c != EOF && c != '[');
    10473. 

  10473.               if ((int)c == EOF)
    10474. 

  10474.                  goto end;
    10475. 

  10475.               t = (char*)"![CDATA[";
    10476. 

  10476.               m = 8;
    10477. 

  10477.               state = 1;
    10478. 

  10478.             }
    10479. 

  10479.             else if (c == '-')
    10480. 

  10480.             { if ((c = soap_getchar(soap)) == '-')
    10481. 

  10481.                 state = 2;
    10482. 

  10482.               t = (char*)"!-";
    10483. 

  10483.               m = 2;
    10484. 

  10484.               soap_unget(soap, c);
    10485. 

  10485.             }
    10486. 

  10486.             else
    10487. 

  10487.             { t = (char*)"!";
    10488. 

  10488.               m = 1;
    10489. 

  10489.               soap_unget(soap, c);
    10490. 

  10490.             }
    10491. 

  10491.             *s++ = '<';
    10492. 

  10492.             break;
    10493. 

  10493.           }
    10494. 

  10494.           else if (c == '?')
    10495. 

  10495.             state = 3;
    10496. 

  10496.           else if (f && n == 0)
    10497. 

  10497. 	  { soap_revget1(soap);
    10498. 

  10498. 	    c = '<';
    10499. 

  10499. 	    goto end;
    10500. 

  10500. 	  }
    10501. 

  10501. 	  else
    10502. 

  10502.             n++;
    10503. 

  10503.           soap_unget(soap, c);
    10504. 

  10504.           *s++ = '<';
    10505. 

  10505.           break;
    10506. 

  10506.         case '>':
    10507. 

  10507.           *s++ = '>';
    10508. 

  10508.           break;
    10509. 

  10509.         case '"':
    10510. 

  10510.           *s++ = '"';
    10511. 

  10511.           break;
    10512. 

  10512.         default:
    10513. 

  10513. #ifndef WITH_LEANER
    10514. 

  10514. #ifdef HAVE_WCTOMB
    10515. 

  10515.           if (soap->mode & SOAP_C_MBSTRING)
    10516. 

  10516.           { m = wctomb(buf, c & 0x7FFFFFFF);
    10517. 

  10517.             if (m >= 1 && m <= (int)MB_CUR_MAX)
    10518. 

  10518.             { t = buf;
    10519. 

  10519.               *s++ = *t++;
    10520. 

  10520.               m--;
    10521. 

  10521.             }
    10522. 

  10522.             else
    10523. 

  10523.             { *s++ = SOAP_UNKNOWN_CHAR;
    10524. 

  10524.               m = 0;
    10525. 

  10525.             }
    10526. 

  10526.           }
    10527. 

  10527.           else
    10528. 

  10528. #endif
    10529. 

  10529. #endif
    10530. 

  10530.             *s++ = (char)(c & 0xFF);
    10531. 

  10531.         }
    10532. 

  10532.         l++;
    10533. 

  10533.         if (maxlen >= 0 && l > maxlen)
    10534. 

  10534.         { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "String too long: maxlen=%ld\n", maxlen));
    10535. 

  10535.           soap->error = SOAP_LENGTH;
    10536. 

  10536.           return NULL;
    10537. 

  10537.         }
    10538. 

  10538.       }
    10539. 

  10539.     }
    10540. 

  10540.   }
    10541. 

  10541. #endif
    10542. 

  10542. #ifdef WITH_FAST
    10543. 

  10543.   soap->labidx = 0;			/* use look-aside buffer */
    10544. 

  10544. #else
    10545. 

  10545.   if (soap_new_block(soap) == NULL)
    10546. 

  10546.     return NULL;
    10547. 

  10547. #endif
    10548. 

  10548.   for (;;)
    10549. 

  10549.   { 
    10550. 

  10550. #ifdef WITH_FAST
    10551. 

  10551.     register size_t k;
    10552. 

  10552.     if (soap_append_lab(soap, NULL, 0))	/* allocate more space in look-aside buffer if necessary */
    10553. 

  10553.       return NULL;
    10554. 

  10554.     s = soap->labbuf + soap->labidx;	/* space to populate */
    10555. 

  10555.     k = soap->lablen - soap->labidx;	/* number of bytes available */
    10556. 

  10556.     soap->labidx = soap->lablen;	/* claim this space */
    10557. 

  10557. #else
    10558. 

  10558.     register size_t k = SOAP_BLKLEN;
    10559. 

  10559.     if (!(s = (char*)soap_push_block(soap, NULL, k)))
    10560. 

  10560.       return NULL;
    10561. 

  10561. #endif
    10562. 

  10562.     for (i = 0; i < k; i++)
    10563. 

  10563.     { if (m > 0)
    10564. 

  10564.       { *s++ = *t++;	/* copy multibyte characters */
    10565. 

  10565.         m--;
    10566. 

  10566.         continue;
    10567. 

  10567.       }
    10568. 

  10568.       if (soap->mode & SOAP_C_UTFSTRING)
    10569. 

  10569.       { if (((c = soap_get(soap)) & 0x80000000) && c >= -0x7FFFFF80 && c < SOAP_AP)
    10570. 

  10570.         { c &= 0x7FFFFFFF;
    10571. 

  10571.           t = buf;
    10572. 

  10572.           if (c < 0x0800)
    10573. 

  10573.             *t++ = (char)(0xC0 | ((c >> 6) & 0x1F));
    10574. 

  10574.           else
    10575. 

  10575.           { if (c < 0x010000)
    10576. 

  10576.               *t++ = (char)(0xE0 | ((c >> 12) & 0x0F));
    10577. 

  10577.             else
    10578. 

  10578.             { if (c < 0x200000)
    10579. 

  10579.                 *t++ = (char)(0xF0 | ((c >> 18) & 0x07));
    10580. 

  10580.               else
    10581. 

  10581.               { if (c < 0x04000000)
    10582. 

  10582.                   *t++ = (char)(0xF8 | ((c >> 24) & 0x03));
    10583. 

  10583.                 else
    10584. 

  10584.                 { *t++ = (char)(0xFC | ((c >> 30) & 0x01));
    10585. 

  10585.                   *t++ = (char)(0x80 | ((c >> 24) & 0x3F));
    10586. 

  10586.                 }
    10587. 

  10587.                 *t++ = (char)(0x80 | ((c >> 18) & 0x3F));
    10588. 

  10588.               }     
    10589. 

  10589.               *t++ = (char)(0x80 | ((c >> 12) & 0x3F));
    10590. 

  10590.             }
    10591. 

  10591.             *t++ = (char)(0x80 | ((c >> 6) & 0x3F));
    10592. 

  10592.           }
    10593. 

  10593.           *t++ = (char)(0x80 | (c & 0x3F));
    10594. 

  10594.           m = (int)(t - buf) - 1;
    10595. 

  10595.           t = buf;
    10596. 

  10596.           *s++ = *t++;
    10597. 

  10597.           continue;
    10598. 

  10598.         }
    10599. 

  10599.       }
    10600. 

  10600.       else
    10601. 

  10601.         c = soap_getutf8(soap);
    10602. 

  10602.       switch (c)
    10603. 

  10603.       {
    10604. 

  10604.       case SOAP_TT:
    10605. 

  10605.         if (n == 0)
    10606. 

  10606.           goto end;
    10607. 

  10607.         n--;
    10608. 

  10608.         *s++ = '<';
    10609. 

  10609.         t = (char*)"/";
    10610. 

  10610.         m = 1;
    10611. 

  10611.         break;
    10612. 

  10612.       case SOAP_LT:
    10613. 

  10613. 	if (f && n == 0)
    10614. 

  10614. 	  goto end;
    10615. 

  10615.         n++;
    10616. 

  10616.         *s++ = '<';
    10617. 

  10617.         break;
    10618. 

  10618.       case SOAP_GT:
    10619. 

  10619.         *s++ = '>';
    10620. 

  10620.         break;
    10621. 

  10621.       case SOAP_QT:
    10622. 

  10622.         *s++ = '"';
    10623. 

  10623.         break;
    10624. 

  10624.       case SOAP_AP:
    10625. 

  10625.         *s++ = '\'';
    10626. 

  10626.         break;
    10627. 

  10627.       case '/':
    10628. 

  10628.         if (n > 0)
    10629. 

  10629.         { c = soap_get(soap);
    10630. 

  10630.           if (c == SOAP_GT)
    10631. 

  10631.             n--;
    10632. 

  10632.           soap_unget(soap, c);
    10633. 

  10633.         }
    10634. 

  10634.         *s++ = '/';
    10635. 

  10635.         break;
    10636. 

  10636.       case (soap_wchar)('<' | 0x80000000):
    10637. 

  10637.         if (flag)
    10638. 

  10638.           *s++ = '<';
    10639. 

  10639.         else
    10640. 

  10640.         { *s++ = '&';
    10641. 

  10641.           t = (char*)"lt;";
    10642. 

  10642.           m = 3;
    10643. 

  10643.         }
    10644. 

  10644.         break;
    10645. 

  10645.       case (soap_wchar)('>' | 0x80000000):
    10646. 

  10646.         if (flag)
    10647. 

  10647.           *s++ = '>';
    10648. 

  10648.         else
    10649. 

  10649.         { *s++ = '&';
    10650. 

  10650.           t = (char*)"gt;";
    10651. 

  10651.           m = 3;
    10652. 

  10652.         }
    10653. 

  10653.         break;
    10654. 

  10654.       case (soap_wchar)('&' | 0x80000000):
    10655. 

  10655.         if (flag)
    10656. 

  10656.           *s++ = '&';
    10657. 

  10657.         else
    10658. 

  10658.         { *s++ = '&';
    10659. 

  10659.           t = (char*)"amp;";
    10660. 

  10660.           m = 4;
    10661. 

  10661.         }
    10662. 

  10662.         break;
    10663. 

  10663.       case (soap_wchar)('"' | 0x80000000):
    10664. 

  10664.         if (flag)
    10665. 

  10665.           *s++ = '"';
    10666. 

  10666.         else
    10667. 

  10667.         { *s++ = '&';
    10668. 

  10668.           t = (char*)"quot;";
    10669. 

  10669.           m = 5;
    10670. 

  10670.         }
    10671. 

  10671.         break;
    10672. 

  10672.       case (soap_wchar)('\'' | 0x80000000):
    10673. 

  10673.         if (flag)
    10674. 

  10674.           *s++ = '\'';
    10675. 

  10675.         else
    10676. 

  10676.         { *s++ = '&';
    10677. 

  10677.           t = (char*)"apos;";
    10678. 

  10678.           m = 5;
    10679. 

  10679.         }
    10680. 

  10680.         break;
    10681. 

  10681.       default:
    10682. 

  10682.         if ((int)c == EOF)
    10683. 

  10683.           goto end;
    10684. 

  10684. #ifndef WITH_LEANER
    10685. 

  10685. #ifdef HAVE_WCTOMB
    10686. 

  10686.         if (soap->mode & SOAP_C_MBSTRING)
    10687. 

  10687.         { m = wctomb(buf, c & 0x7FFFFFFF);
    10688. 

  10688.           if (m >= 1 && m <= (int)MB_CUR_MAX)
    10689. 

  10689.           { t = buf;
    10690. 

  10690.             *s++ = *t++;
    10691. 

  10691.             m--;
    10692. 

  10692.           }
    10693. 

  10693.           else
    10694. 

  10694.           { *s++ = SOAP_UNKNOWN_CHAR;
    10695. 

  10695.             m = 0;
    10696. 

  10696.           }
    10697. 

  10697.         }
    10698. 

  10698.         else
    10699. 

  10699. #endif
    10700. 

  10700. #endif
    10701. 

  10701.           *s++ = (char)(c & 0xFF);
    10702. 

  10702.       }
    10703. 

  10703.       l++;
    10704. 

  10704.       if (maxlen >= 0 && l > maxlen)
    10705. 

  10705.       { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "String too long: maxlen=%ld\n", maxlen));
    10706. 

  10706.         soap->error = SOAP_LENGTH;
    10707. 

  10707.         return NULL;
    10708. 

  10708.       }
    10709. 

  10709.     }
    10710. 

  10710.   }
    10711. 

  10711. end:
    10712. 

  10712.   soap_unget(soap, c);
    10713. 

  10713.   *s = '\0';
    10714. 

  10714. #ifdef WITH_FAST
    10715. 

  10715.   t = soap_strdup(soap, soap->labbuf);
    10716. 

  10716. #else
    10717. 

  10717.   soap_size_block(soap, NULL, i+1);
    10718. 

  10718.   t = soap_save_block(soap, NULL, 0);
    10719. 

  10719. #endif
    10720. 

  10720.   if (l < minlen)
    10721. 

  10721.   { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "String too short: %ld chars, minlen=%ld\n", l, minlen));
    10722. 

  10722.     soap->error = SOAP_LENGTH;
    10723. 

  10723.     return NULL;
    10724. 

  10724.   }
    10725. 

  10725. #ifdef WITH_DOM
    10726. 

  10726.   if ((soap->mode & SOAP_XML_DOM) && soap->dom)
    10727. 

  10727.   { if (flag == 3)
    10728. 

  10728.       soap->dom->tail = t;
    10729. 

  10729.     else
    10730. 

  10730.       soap->dom->data = t;
    10731. 

  10731.   }
    10732. 

  10732. #endif
    10733. 

  10733.   if (flag == 2)
    10734. 

  10734.     if (soap_s2QName(soap, t, &t, minlen, maxlen))
    10735. 

  10735.       return NULL;
    10736. 

  10736.   return t;
    10737. 

  10737. }
    10738. 

  10738. #endif
    10739. 

  10739. 

  10740. /******************************************************************************/
    10741. 

  10741. #ifndef WITH_LEANER
    10742. 

  10742. #ifndef PALM_2
    10743. 

  10743. SOAP_FMAC1
    10744. 

  10744. int
    10745. 

  10745. SOAP_FMAC2
    10746. 

  10746. soap_wstring_out(struct soap *soap, const wchar_t *s, int flag)
    10747. 

  10747. { const char *t;
    10748. 

  10748.   char tmp;
    10749. 

  10749.   register soap_wchar c;
    10750. 

  10750. #ifdef WITH_DOM
    10751. 

  10751.   if ((soap->mode & SOAP_XML_DOM) && soap->dom)
    10752. 

  10752.   { wchar_t *r = (wchar_t*)s;
    10753. 

  10753.     int n = 1;
    10754. 

  10754.     while (*r++)
    10755. 

  10755.       n++;
    10756. 

  10756.     soap->dom->wide = r = (wchar_t*)soap_malloc(soap, n * sizeof(wchar_t));
    10757. 

  10757.     while (n--)
    10758. 

  10758.       *r++ = *s++;
    10759. 

  10759.     return SOAP_OK;
    10760. 

  10760.   }
    10761. 

  10761. #endif
    10762. 

  10762.   while ((c = *s++))
    10763. 

  10763.   { switch (c)
    10764. 

  10764.     { 
    10765. 

  10765.     case 0x09:
    10766. 

  10766.       if (flag)
    10767. 

  10767.         t = "&#x9;";
    10768. 

  10768.       else
    10769. 

  10769.         t = "\t";
    10770. 

  10770.       break;
    10771. 

  10771.     case 0x0A:
    10772. 

  10772.       if (flag || !(soap->mode & SOAP_XML_CANONICAL))
    10773. 

  10773.         t = "&#xA;";
    10774. 

  10774.       else
    10775. 

  10775.         t = "\n";
    10776. 

  10776.       break;
    10777. 

  10777.     case 0x0D:
    10778. 

  10778.       t = "&#xD;";
    10779. 

  10779.       break;
    10780. 

  10780.     case '&':
    10781. 

  10781.       t = "&amp;";
    10782. 

  10782.       break;
    10783. 

  10783.     case '<':
    10784. 

  10784.       t = "&lt;";
    10785. 

  10785.       break;
    10786. 

  10786.     case '>':
    10787. 

  10787.       if (flag)
    10788. 

  10788.         t = ">";
    10789. 

  10789.       else
    10790. 

  10790.         t = "&gt;";
    10791. 

  10791.       break;
    10792. 

  10792.     case '"':
    10793. 

  10793.       if (flag)
    10794. 

  10794.         t = "&quot;";
    10795. 

  10795.       else
    10796. 

  10796.         t = "\"";
    10797. 

  10797.       break;
    10798. 

  10798.     default:
    10799. 

  10799.       if (c >= 0x20 && c < 0x80)
    10800. 

  10800.       { tmp = (char)c;
    10801. 

  10801.         if (soap_send_raw(soap, &tmp, 1))
    10802. 

  10802.           return soap->error;
    10803. 

  10803.       }
    10804. 

  10804.       else if (soap_pututf8(soap, (unsigned long)c))
    10805. 

  10805.         return soap->error;
    10806. 

  10806.       continue;
    10807. 

  10807.     }
    10808. 

  10808.     if (soap_send(soap, t))
    10809. 

  10809.       return soap->error;
    10810. 

  10810.   }
    10811. 

  10811.   return SOAP_OK;
    10812. 

  10812. }
    10813. 

  10813. #endif
    10814. 

  10814. #endif
    10815. 

  10815. 

  10816. /******************************************************************************/
    10817. 

  10817. #ifndef WITH_LEANER
    10818. 

  10818. #ifndef PALM_2
    10819. 

  10819. SOAP_FMAC1
    10820. 

  10820. wchar_t *
    10821. 

  10821. SOAP_FMAC2
    10822. 

  10822. soap_wstring_in(struct soap *soap, int flag, long minlen, long maxlen)
    10823. 

  10823. { wchar_t *s;
    10824. 

  10824.   register int i, n = 0, f = 0;
    10825. 

  10825.   register long l = 0;
    10826. 

  10826.   register soap_wchar c;
    10827. 

  10827.   char *t = NULL;
    10828. 

  10828.   DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Reading wide string content\n"));
    10829. 

  10829.   if (soap->peeked)
    10830. 

  10830.   { if (*soap->tag)
    10831. 

  10831.     {
    10832. 

  10832. #ifndef WITH_LEAN
    10833. 

  10833.       struct soap_attribute *tp;
    10834. 

  10834.       t = soap->tmpbuf;
    10835. 

  10835.       *t = '<';
    10836. 

  10836.       t[sizeof(soap->tmpbuf)-1] = '\0';
    10837. 

  10837.       strncpy(t + 1, soap->tag, sizeof(soap->tmpbuf) - 2);
    10838. 

  10838.       t += strlen(t);
    10839. 

  10839.       for (tp = soap->attributes; tp; tp = tp->next)
    10840. 

  10840.       { if (tp->visible)
    10841. 

  10841.         { if (t >= soap->tmpbuf + sizeof(soap->tmpbuf) - 2)
    10842. 

  10842.             break;
    10843. 

  10843.           *t++ = ' ';
    10844. 

  10844.           strcpy(t, tp->name);
    10845. 

  10845.           t += strlen(t);
    10846. 

  10846.           if (t >= soap->tmpbuf + sizeof(soap->tmpbuf) - 2)
    10847. 

  10847.             break;
    10848. 

  10848.           if (tp->value)
    10849. 

  10849.           { *t++ = '=';
    10850. 

  10850.             *t++ = '"';
    10851. 

  10851.             strcpy(t, tp->value);
    10852. 

  10852.             t += strlen(t);
    10853. 

  10853.             *t++ = '"';
    10854. 

  10854.           }
    10855. 

  10855.         }
    10856. 

  10856.       }
    10857. 

  10857.       if (!soap->body)
    10858. 

  10858.         *t++ = '/';
    10859. 

  10859.       *t++ = '>';
    10860. 

  10860.       *t = '\0';
    10861. 

  10861.       t = soap->tmpbuf;
    10862. 

  10862. #endif
    10863. 

  10863.       if (soap->body)
    10864. 

  10864.         n = 1;
    10865. 

  10865.       f = 1;
    10866. 

  10866.       soap->peeked = 0;
    10867. 

  10867.     }
    10868. 

  10868.   }
    10869. 

  10869.   if (soap_new_block(soap) == NULL)
    10870. 

  10870.     return NULL;
    10871. 

  10871.   for (;;)
    10872. 

  10872.   { if (!(s = (wchar_t*)soap_push_block(soap, NULL, sizeof(wchar_t)*SOAP_BLKLEN)))
    10873. 

  10873.       return NULL;
    10874. 

  10874.     for (i = 0; i < SOAP_BLKLEN; i++)
    10875. 

  10875.     { if (t)
    10876. 

  10876.       { *s++ = (wchar_t)*t++;
    10877. 

  10877.         if (!*t)
    10878. 

  10878.           t = NULL;
    10879. 

  10879.         continue;
    10880. 

  10880.       }
    10881. 

  10881.       c = soap_getutf8(soap);
    10882. 

  10882.       switch (c)
    10883. 

  10883.       {
    10884. 

  10884.       case SOAP_TT:
    10885. 

  10885.         if (n == 0)
    10886. 

  10886.           goto end;
    10887. 

  10887.         n--;
    10888. 

  10888.         *s++ = '<';
    10889. 

  10889.         soap_unget(soap, '/');
    10890. 

  10890.         break;
    10891. 

  10891.       case SOAP_LT:
    10892. 

  10892.         if (f && n == 0)
    10893. 

  10893. 	  goto end;
    10894. 

  10894.         n++;
    10895. 

  10895.         *s++ = '<';
    10896. 

  10896.         break;
    10897. 

  10897.       case SOAP_GT:
    10898. 

  10898.         *s++ = '>';
    10899. 

  10899.         break;
    10900. 

  10900.       case SOAP_QT:
    10901. 

  10901.         *s++ = '"';
    10902. 

  10902.         break;
    10903. 

  10903.       case SOAP_AP:
    10904. 

  10904.         *s++ = '\'';
    10905. 

  10905.         break;
    10906. 

  10906.       case '/':
    10907. 

  10907.         if (n > 0)
    10908. 

  10908.         { c = soap_getutf8(soap);
    10909. 

  10909.           if (c == SOAP_GT)
    10910. 

  10910.             n--;
    10911. 

  10911.           soap_unget(soap, c);
    10912. 

  10912.         }
    10913. 

  10913.         *s++ = '/';
    10914. 

  10914.         break;
    10915. 

  10915.       case '<':
    10916. 

  10916.         if (flag)
    10917. 

  10917.           *s++ = (soap_wchar)'<';
    10918. 

  10918.         else
    10919. 

  10919.         { *s++ = (soap_wchar)'&';
    10920. 

  10920.           t = (char*)"lt;";
    10921. 

  10921.         }
    10922. 

  10922.         break;
    10923. 

  10923.       case '>':
    10924. 

  10924.         if (flag)
    10925. 

  10925.           *s++ = (soap_wchar)'>';
    10926. 

  10926.         else
    10927. 

  10927.         { *s++ = (soap_wchar)'&';
    10928. 

  10928.           t = (char*)"gt;";
    10929. 

  10929.         }
    10930. 

  10930.         break;
    10931. 

  10931.       case '"':
    10932. 

  10932.         if (flag)
    10933. 

  10933.           *s++ = (soap_wchar)'"';
    10934. 

  10934.         else
    10935. 

  10935.         { *s++ = (soap_wchar)'&';
    10936. 

  10936.           t = (char*)"quot;";
    10937. 

  10937.         }
    10938. 

  10938.         break;
    10939. 

  10939.       default:
    10940. 

  10940.         if ((int)c == EOF)
    10941. 

  10941.           goto end;
    10942. 

  10942.         *s++ = (wchar_t)c & 0x7FFFFFFF;
    10943. 

  10943.       }
    10944. 

  10944.       l++;
    10945. 

  10945.       if (maxlen >= 0 && l > maxlen)
    10946. 

  10946.       { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "String too long: maxlen=%ld\n", maxlen));
    10947. 

  10947.         soap->error = SOAP_LENGTH;
    10948. 

  10948.         return NULL;
    10949. 

  10949.       }
    10950. 

  10950.     }
    10951. 

  10951.   }
    10952. 

  10952. end:
    10953. 

  10953.   soap_unget(soap, c);
    10954. 

  10954.   *s = '\0';
    10955. 

  10955.   soap_size_block(soap, NULL, sizeof(wchar_t) * (i + 1));
    10956. 

  10956.   if (l < minlen)
    10957. 

  10957.   { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "String too short: %ld chars, minlen=%ld\n", l, minlen));
    10958. 

  10958.     soap->error = SOAP_LENGTH;
    10959. 

  10959.     return NULL;
    10960. 

  10960.   }
    10961. 

  10961.   s = (wchar_t*)soap_save_block(soap, NULL, NULL, 0);
    10962. 

  10962. #ifdef WITH_DOM
    10963. 

  10963.   if ((soap->mode & SOAP_XML_DOM) && soap->dom)
    10964. 

  10964.     soap->dom->wide = s;
    10965. 

  10965. #endif
    10966. 

  10966.   return s;
    10967. 

  10967. }
    10968. 

  10968. #endif
    10969. 

  10969. #endif
    10970. 

  10970. 

  10971. /******************************************************************************/
    10972. 

  10972. #ifndef PALM_2
    10973. 

  10973. SOAP_FMAC1
    10974. 

  10974. const char*
    10975. 

  10975. SOAP_FMAC2
    10976. 

  10976. soap_int2s(struct soap *soap, int n)
    10977. 

  10977. { return soap_long2s(soap, (long)n);
    10978. 

  10978. }
    10979. 

  10979. #endif
    10980. 

  10980. 

  10981. /******************************************************************************/
    10982. 

  10982. #ifndef PALM_2
    10983. 

  10983. SOAP_FMAC1
    10984. 

  10984. int
    10985. 

  10985. SOAP_FMAC2
    10986. 

  10986. soap_outint(struct soap *soap, const char *tag, int id, const int *p, const char *type, int n)
    10987. 

  10987. { if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
    10988. 

  10988.    || soap_string_out(soap, soap_long2s(soap, (long)*p), 0))
    10989. 

  10989.     return soap->error;
    10990. 

  10990.   return soap_element_end_out(soap, tag);
    10991. 

  10991. }
    10992. 

  10992. #endif
    10993. 

  10993. 

  10994. /******************************************************************************/
    10995. 

  10995. #ifndef PALM_2
    10996. 

  10996. SOAP_FMAC1
    10997. 

  10997. int
    10998. 

  10998. SOAP_FMAC2
    10999. 

  10999. soap_s2int(struct soap *soap, const char *s, int *p)
    11000. 

  11000. { if (s)
    11001. 

  11001.   { char *r;
    11002. 

  11002. #ifndef WITH_NOIO
    11003. 

  11003. #ifndef WITH_LEAN
    11004. 

  11004.     soap_reset_errno;
    11005. 

  11005. #endif
    11006. 

  11006. #endif
    11007. 

  11007.     *p = (int)soap_strtol(s, &r, 10);
    11008. 

  11008.     if ((s == r && (soap->mode & SOAP_XML_STRICT)) || *r
    11009. 

  11009. #ifndef WITH_NOIO
    11010. 

  11010. #ifndef WITH_LEAN
    11011. 

  11011.      || soap_errno == SOAP_ERANGE
    11012. 

  11012. #endif
    11013. 

  11013. #endif
    11014. 

  11014.     )
    11015. 

  11015.       soap->error = SOAP_TYPE;
    11016. 

  11016.   }
    11017. 

  11017.   return soap->error;
    11018. 

  11018. }
    11019. 

  11019. #endif
    11020. 

  11020. 

  11021. /******************************************************************************/
    11022. 

  11022. #ifndef PALM_2
    11023. 

  11023. SOAP_FMAC1
    11024. 

  11024. int *
    11025. 

  11025. SOAP_FMAC2
    11026. 

  11026. soap_inint(struct soap *soap, const char *tag, int *p, const char *type, int t)
    11027. 

  11027. { if (soap_element_begin_in(soap, tag, 0, NULL))
    11028. 

  11028.     return NULL;
    11029. 

  11029. #ifndef WITH_LEAN
    11030. 

  11030.   if (*soap->type
    11031. 

  11031.    && soap_match_tag(soap, soap->type, type)
    11032. 

  11032.    && soap_match_tag(soap, soap->type, ":int")
    11033. 

  11033.    && soap_match_tag(soap, soap->type, ":short")
    11034. 

  11034.    && soap_match_tag(soap, soap->type, ":byte"))
    11035. 

  11035.   { soap->error = SOAP_TYPE;
    11036. 

  11036.     soap_revert(soap);
    11037. 

  11037.     return NULL;
    11038. 

  11038.   }
    11039. 

  11039. #endif
    11040. 

  11040.   p = (int*)soap_id_enter(soap, soap->id, p, t, sizeof(int), 0, NULL, NULL, NULL);
    11041. 

  11041.   if (*soap->href)
    11042. 

  11042.     p = (int*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(int), 0, NULL);
    11043. 

  11043.   else if (p)
    11044. 

  11044.   { if (soap_s2int(soap, soap_value(soap), p))
    11045. 

  11045.       return NULL;
    11046. 

  11046.   }
    11047. 

  11047.   if (soap->body && soap_element_end_in(soap, tag))
    11048. 

  11048.     return NULL;
    11049. 

  11049.   return p;
    11050. 

  11050. }
    11051. 

  11051. #endif
    11052. 

  11052. 

  11053. /******************************************************************************/
    11054. 

  11054. #ifndef PALM_2
    11055. 

  11055. SOAP_FMAC1
    11056. 

  11056. const char*
    11057. 

  11057. SOAP_FMAC2
    11058. 

  11058. soap_long2s(struct soap *soap, long n)
    11059. 

  11059. { sprintf(soap->tmpbuf, "%ld", n);
    11060. 

  11060.   return soap->tmpbuf;
    11061. 

  11061. }
    11062. 

  11062. #endif
    11063. 

  11063. 

  11064. /******************************************************************************/
    11065. 

  11065. #ifndef PALM_2
    11066. 

  11066. SOAP_FMAC1
    11067. 

  11067. int
    11068. 

  11068. SOAP_FMAC2
    11069. 

  11069. soap_outlong(struct soap *soap, const char *tag, int id, const long *p, const char *type, int n)
    11070. 

  11070. { if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
    11071. 

  11071.    || soap_string_out(soap, soap_long2s(soap, *p), 0))
    11072. 

  11072.     return soap->error;
    11073. 

  11073.   return soap_element_end_out(soap, tag);
    11074. 

  11074. }
    11075. 

  11075. #endif
    11076. 

  11076. 

  11077. /******************************************************************************/
    11078. 

  11078. #ifndef PALM_2
    11079. 

  11079. SOAP_FMAC1
    11080. 

  11080. int
    11081. 

  11081. SOAP_FMAC2
    11082. 

  11082. soap_s2long(struct soap *soap, const char *s, long *p)
    11083. 

  11083. { if (s)
    11084. 

  11084.   { char *r;
    11085. 

  11085. #ifndef WITH_NOIO
    11086. 

  11086. #ifndef WITH_LEAN
    11087. 

  11087.     soap_reset_errno;
    11088. 

  11088. #endif
    11089. 

  11089. #endif
    11090. 

  11090.     *p = soap_strtol(s, &r, 10);
    11091. 

  11091.     if ((s == r && (soap->mode & SOAP_XML_STRICT)) || *r
    11092. 

  11092. #ifndef WITH_NOIO
    11093. 

  11093. #ifndef WITH_LEAN
    11094. 

  11094.      || soap_errno == SOAP_ERANGE
    11095. 

  11095. #endif
    11096. 

  11096. #endif
    11097. 

  11097.     )
    11098. 

  11098.       soap->error = SOAP_TYPE;
    11099. 

  11099.   }
    11100. 

  11100.   return soap->error;
    11101. 

  11101. }
    11102. 

  11102. #endif
    11103. 

  11103. 

  11104. /******************************************************************************/
    11105. 

  11105. #ifndef PALM_2
    11106. 

  11106. SOAP_FMAC1
    11107. 

  11107. long *
    11108. 

  11108. SOAP_FMAC2
    11109. 

  11109. soap_inlong(struct soap *soap, const char *tag, long *p, const char *type, int t)
    11110. 

  11110. { if (soap_element_begin_in(soap, tag, 0, NULL))
    11111. 

  11111.     return NULL;
    11112. 

  11112. #ifndef WITH_LEAN
    11113. 

  11113.   if (*soap->type
    11114. 

  11114.    && soap_match_tag(soap, soap->type, type)
    11115. 

  11115.    && soap_match_tag(soap, soap->type, ":int")
    11116. 

  11116.    && soap_match_tag(soap, soap->type, ":short")
    11117. 

  11117.    && soap_match_tag(soap, soap->type, ":byte"))
    11118. 

  11118.   { soap->error = SOAP_TYPE;
    11119. 

  11119.     soap_revert(soap);
    11120. 

  11120.     return NULL;
    11121. 

  11121.   }
    11122. 

  11122. #endif
    11123. 

  11123.   p = (long*)soap_id_enter(soap, soap->id, p, t, sizeof(long), 0, NULL, NULL, NULL);
    11124. 

  11124.   if (*soap->href)
    11125. 

  11125.     p = (long*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(long), 0, NULL);
    11126. 

  11126.   else if (p)
    11127. 

  11127.   { if (soap_s2long(soap, soap_value(soap), p))
    11128. 

  11128.       return NULL;
    11129. 

  11129.   }
    11130. 

  11130.   if (soap->body && soap_element_end_in(soap, tag))
    11131. 

  11131.     return NULL;
    11132. 

  11132.   return p;
    11133. 

  11133. }
    11134. 

  11134. #endif
    11135. 

  11135. 

  11136. /******************************************************************************/
    11137. 

  11137. #ifndef WITH_LEAN
    11138. 

  11138. SOAP_FMAC1
    11139. 

  11139. const char*
    11140. 

  11140. SOAP_FMAC2
    11141. 

  11141. soap_LONG642s(struct soap *soap, LONG64 n)
    11142. 

  11142. { sprintf(soap->tmpbuf, SOAP_LONG_FORMAT, n);
    11143. 

  11143.   return soap->tmpbuf;
    11144. 

  11144. }
    11145. 

  11145. #endif
    11146. 

  11146. 

  11147. /******************************************************************************/
    11148. 

  11148. #ifndef WITH_LEAN
    11149. 

  11149. SOAP_FMAC1
    11150. 

  11150. int
    11151. 

  11151. SOAP_FMAC2
    11152. 

  11152. soap_outLONG64(struct soap *soap, const char *tag, int id, const LONG64 *p, const char *type, int n)
    11153. 

  11153. { if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
    11154. 

  11154.    || soap_string_out(soap, soap_LONG642s(soap, *p), 0))
    11155. 

  11155.     return soap->error;
    11156. 

  11156.   return soap_element_end_out(soap, tag);
    11157. 

  11157. }
    11158. 

  11158. #endif
    11159. 

  11159. 

  11160. /******************************************************************************/
    11161. 

  11161. #ifndef WITH_LEAN
    11162. 

  11162. SOAP_FMAC1
    11163. 

  11163. int
    11164. 

  11164. SOAP_FMAC2
    11165. 

  11165. soap_s2LONG64(struct soap *soap, const char *s, LONG64 *p)
    11166. 

  11166. { if (s)
    11167. 

  11167.   {
    11168. 

  11168. #ifdef HAVE_STRTOLL
    11169. 

  11169.     char *r;
    11170. 

  11170. #ifndef WITH_NOIO
    11171. 

  11171. #ifndef WITH_LEAN
    11172. 

  11172.     soap_reset_errno;
    11173. 

  11173. #endif
    11174. 

  11174. #endif
    11175. 

  11175.     *p = strtoll(s, &r, 10);
    11176. 

  11176.     if ((s == r && (soap->mode & SOAP_XML_STRICT)) || *r
    11177. 

  11177. #ifndef WITH_NOIO
    11178. 

  11178. #ifndef WITH_LEAN
    11179. 

  11179.        || soap_errno == SOAP_ERANGE
    11180. 

  11180. #endif
    11181. 

  11181. #endif
    11182. 

  11182.       )
    11183. 

  11183. #else
    11184. 

  11184. # ifdef HAVE_SSCANF
    11185. 

  11185.     if (sscanf(s, SOAP_LONG_FORMAT, p) != 1)
    11186. 

  11186. # endif
    11187. 

  11187. #endif
    11188. 

  11188.       soap->error = SOAP_TYPE;
    11189. 

  11189.   }
    11190. 

  11190.   return soap->error;
    11191. 

  11191. }
    11192. 

  11192. #endif
    11193. 

  11193. 

  11194. /******************************************************************************/
    11195. 

  11195. #ifndef WITH_LEAN
    11196. 

  11196. SOAP_FMAC1
    11197. 

  11197. LONG64 *
    11198. 

  11198. SOAP_FMAC2
    11199. 

  11199. soap_inLONG64(struct soap *soap, const char *tag, LONG64 *p, const char *type, int t)
    11200. 

  11200. { if (soap_element_begin_in(soap, tag, 0, NULL))
    11201. 

  11201.     return NULL;
    11202. 

  11202. #ifndef WITH_LEAN
    11203. 

  11203.   if (*soap->type
    11204. 

  11204.    && soap_match_tag(soap, soap->type, type)
    11205. 

  11205.    && soap_match_tag(soap, soap->type, ":integer")
    11206. 

  11206.    && soap_match_tag(soap, soap->type, ":positiveInteger")
    11207. 

  11207.    && soap_match_tag(soap, soap->type, ":negativeInteger")
    11208. 

  11208.    && soap_match_tag(soap, soap->type, ":nonPositiveInteger")
    11209. 

  11209.    && soap_match_tag(soap, soap->type, ":nonNegativeInteger")
    11210. 

  11210.    && soap_match_tag(soap, soap->type, ":long")
    11211. 

  11211.    && soap_match_tag(soap, soap->type, ":int")
    11212. 

  11212.    && soap_match_tag(soap, soap->type, ":short")
    11213. 

  11213.    && soap_match_tag(soap, soap->type, ":byte"))
    11214. 

  11214.   { soap->error = SOAP_TYPE;
    11215. 

  11215.     soap_revert(soap);
    11216. 

  11216.     return NULL;
    11217. 

  11217.   }
    11218. 

  11218. #endif
    11219. 

  11219.   p = (LONG64*)soap_id_enter(soap, soap->id, p, t, sizeof(LONG64), 0, NULL, NULL, NULL);
    11220. 

  11220.   if (*soap->href)
    11221. 

  11221.     p = (LONG64*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(LONG64), 0, NULL);
    11222. 

  11222.   else if (p)
    11223. 

  11223.   { if (soap_s2LONG64(soap, soap_value(soap), p))
    11224. 

  11224.       return NULL;
    11225. 

  11225.   }
    11226. 

  11226.   if (soap->body && soap_element_end_in(soap, tag))
    11227. 

  11227.     return NULL;
    11228. 

  11228.   return p;
    11229. 

  11229. }
    11230. 

  11230. #endif
    11231. 

  11231. 

  11232. /******************************************************************************/
    11233. 

  11233. #ifndef PALM_2
    11234. 

  11234. SOAP_FMAC1
    11235. 

  11235. const char*
    11236. 

  11236. SOAP_FMAC2
    11237. 

  11237. soap_byte2s(struct soap *soap, char n)
    11238. 

  11238. { return soap_long2s(soap, (long)n);
    11239. 

  11239. }
    11240. 

  11240. #endif
    11241. 

  11241. 

  11242. /******************************************************************************/
    11243. 

  11243. #ifndef PALM_2
    11244. 

  11244. SOAP_FMAC1
    11245. 

  11245. int
    11246. 

  11246. SOAP_FMAC2
    11247. 

  11247. soap_outbyte(struct soap *soap, const char *tag, int id, const char *p, const char *type, int n)
    11248. 

  11248. { if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
    11249. 

  11249.    || soap_string_out(soap, soap_long2s(soap, (long)*p), 0))
    11250. 

  11250.     return soap->error;
    11251. 

  11251.   return soap_element_end_out(soap, tag);
    11252. 

  11252. }
    11253. 

  11253. #endif
    11254. 

  11254. 

  11255. /******************************************************************************/
    11256. 

  11256. #ifndef PALM_2
    11257. 

  11257. SOAP_FMAC1
    11258. 

  11258. int
    11259. 

  11259. SOAP_FMAC2
    11260. 

  11260. soap_s2byte(struct soap *soap, const char *s, char *p)
    11261. 

  11261. { if (s)
    11262. 

  11262.   { long n;
    11263. 

  11263.     char *r;
    11264. 

  11264.     n = soap_strtol(s, &r, 10);
    11265. 

  11265.     if (s == r || *r || n < -128 || n > 127)
    11266. 

  11266.       soap->error = SOAP_TYPE;
    11267. 

  11267.     *p = (char)n;
    11268. 

  11268.   }
    11269. 

  11269.   return soap->error;
    11270. 

  11270. }
    11271. 

  11271. #endif
    11272. 

  11272. 

  11273. /******************************************************************************/
    11274. 

  11274. #ifndef PALM_2
    11275. 

  11275. SOAP_FMAC1
    11276. 

  11276. char *
    11277. 

  11277. SOAP_FMAC2
    11278. 

  11278. soap_inbyte(struct soap *soap, const char *tag, char *p, const char *type, int t)
    11279. 

  11279. { if (soap_element_begin_in(soap, tag, 0, NULL))
    11280. 

  11280.     return NULL;
    11281. 

  11281. #ifndef WITH_LEAN
    11282. 

  11282.   if (*soap->type
    11283. 

  11283.    && soap_match_tag(soap, soap->type, type)
    11284. 

  11284.    && soap_match_tag(soap, soap->type, ":byte"))
    11285. 

  11285.   { soap->error = SOAP_TYPE;
    11286. 

  11286.     soap_revert(soap);
    11287. 

  11287.     return NULL;
    11288. 

  11288.   }
    11289. 

  11289. #endif
    11290. 

  11290.   p = (char*)soap_id_enter(soap, soap->id, p, t, sizeof(char), 0, NULL, NULL, NULL);
    11291. 

  11291.   if (*soap->href)
    11292. 

  11292.     p = (char*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(char), 0, NULL);
    11293. 

  11293.   else if (p)
    11294. 

  11294.   { if (soap_s2byte(soap, soap_value(soap), p))
    11295. 

  11295.       return NULL;
    11296. 

  11296.   }
    11297. 

  11297.   if (soap->body && soap_element_end_in(soap, tag))
    11298. 

  11298.     return NULL;
    11299. 

  11299.   return p;
    11300. 

  11300. }
    11301. 

  11301. #endif
    11302. 

  11302. 

  11303. /******************************************************************************/
    11304. 

  11304. #ifndef PALM_2
    11305. 

  11305. SOAP_FMAC1
    11306. 

  11306. const char*
    11307. 

  11307. SOAP_FMAC2
    11308. 

  11308. soap_short2s(struct soap *soap, short n)
    11309. 

  11309. { return soap_long2s(soap, (long)n);
    11310. 

  11310. }
    11311. 

  11311. #endif
    11312. 

  11312. 

  11313. /******************************************************************************/
    11314. 

  11314. #ifndef PALM_2
    11315. 

  11315. SOAP_FMAC1
    11316. 

  11316. int
    11317. 

  11317. SOAP_FMAC2
    11318. 

  11318. soap_outshort(struct soap *soap, const char *tag, int id, const short *p, const char *type, int n)
    11319. 

  11319. { if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
    11320. 

  11320.    || soap_string_out(soap, soap_long2s(soap, (long)*p), 0))
    11321. 

  11321.     return soap->error;
    11322. 

  11322.   return soap_element_end_out(soap, tag);
    11323. 

  11323. }
    11324. 

  11324. #endif
    11325. 

  11325. 

  11326. /******************************************************************************/
    11327. 

  11327. #ifndef PALM_2
    11328. 

  11328. SOAP_FMAC1
    11329. 

  11329. int
    11330. 

  11330. SOAP_FMAC2
    11331. 

  11331. soap_s2short(struct soap *soap, const char *s, short *p)
    11332. 

  11332. { if (s)
    11333. 

  11333.   { long n;
    11334. 

  11334.     char *r;
    11335. 

  11335.     n = soap_strtol(s, &r, 10);
    11336. 

  11336.     if (s == r || *r || n < -32768 || n > 32767)
    11337. 

  11337.       soap->error = SOAP_TYPE;
    11338. 

  11338.     *p = (short)n;
    11339. 

  11339.   }
    11340. 

  11340.   return soap->error;
    11341. 

  11341. }
    11342. 

  11342. #endif
    11343. 

  11343. 

  11344. /******************************************************************************/
    11345. 

  11345. #ifndef PALM_2
    11346. 

  11346. SOAP_FMAC1
    11347. 

  11347. short *
    11348. 

  11348. SOAP_FMAC2
    11349. 

  11349. soap_inshort(struct soap *soap, const char *tag, short *p, const char *type, int t)
    11350. 

  11350. { if (soap_element_begin_in(soap, tag, 0, NULL))
    11351. 

  11351.     return NULL;
    11352. 

  11352. #ifndef WITH_LEAN
    11353. 

  11353.   if (*soap->type
    11354. 

  11354.    && soap_match_tag(soap, soap->type, type)
    11355. 

  11355.    && soap_match_tag(soap, soap->type, ":short")
    11356. 

  11356.    && soap_match_tag(soap, soap->type, ":byte"))
    11357. 

  11357.   { soap->error = SOAP_TYPE;
    11358. 

  11358.     soap_revert(soap);
    11359. 

  11359.     return NULL;
    11360. 

  11360.   }
    11361. 

  11361. #endif
    11362. 

  11362.   p = (short*)soap_id_enter(soap, soap->id, p, t, sizeof(short), 0, NULL, NULL, NULL);
    11363. 

  11363.   if (*soap->href)
    11364. 

  11364.     p = (short*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(short), 0, NULL);
    11365. 

  11365.   else if (p)
    11366. 

  11366.   { if (soap_s2short(soap, soap_value(soap), p))
    11367. 

  11367.       return NULL;
    11368. 

  11368.   }
    11369. 

  11369.   if (soap->body && soap_element_end_in(soap, tag))
    11370. 

  11370.     return NULL;
    11371. 

  11371.   return p;
    11372. 

  11372. }
    11373. 

  11373. #endif
    11374. 

  11374. 

  11375. /******************************************************************************/
    11376. 

  11376. #ifndef PALM_2
    11377. 

  11377. SOAP_FMAC1
    11378. 

  11378. const char*
    11379. 

  11379. SOAP_FMAC2
    11380. 

  11380. soap_float2s(struct soap *soap, float n)
    11381. 

  11381. { char *s;
    11382. 

  11382.   if (soap_isnan((double)n))
    11383. 

  11383.     return "NaN";
    11384. 

  11384.   if (soap_ispinff(n))
    11385. 

  11385.     return "INF";
    11386. 

  11386.   if (soap_isninff(n))
    11387. 

  11387.     return "-INF";
    11388. 

  11388.   s = soap->tmpbuf;
    11389. 

  11389. #if defined(HAVE_SPRINTF_L)
    11390. 

  11390.   sprintf_l(s, soap->c_locale, soap->float_format, n);
    11391. 

  11391. #else
    11392. 

  11392.   sprintf(s, soap->float_format, n);
    11393. 

  11393.   s = strchr(s, ',');	/* convert decimal comma to DP */
    11394. 

  11394.   if (s)
    11395. 

  11395.     *s = '.';
    11396. 

  11396. #endif
    11397. 

  11397.   return soap->tmpbuf;
    11398. 

  11398. }
    11399. 

  11399. #endif
    11400. 

  11400. 

  11401. /******************************************************************************/
    11402. 

  11402. #ifndef PALM_2
    11403. 

  11403. SOAP_FMAC1
    11404. 

  11404. int
    11405. 

  11405. SOAP_FMAC2
    11406. 

  11406. soap_outfloat(struct soap *soap, const char *tag, int id, const float *p, const char *type, int n)
    11407. 

  11407. { if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
    11408. 

  11408.    || soap_string_out(soap, soap_float2s(soap, *p), 0))
    11409. 

  11409.     return soap->error;
    11410. 

  11410.   return soap_element_end_out(soap, tag);
    11411. 

  11411. }
    11412. 

  11412. #endif
    11413. 

  11413. 

  11414. /******************************************************************************/
    11415. 

  11415. #ifndef PALM_2
    11416. 

  11416. SOAP_FMAC1
    11417. 

  11417. int
    11418. 

  11418. SOAP_FMAC2
    11419. 

  11419. soap_s2float(struct soap *soap, const char *s, float *p)
    11420. 

  11420. { if (s)
    11421. 

  11421.   { if (!*s)
    11422. 

  11422.       return soap->error = SOAP_TYPE;
    11423. 

  11423.     if (!soap_tag_cmp(s, "INF"))
    11424. 

  11424.       *p = FLT_PINFTY;
    11425. 

  11425.     else if (!soap_tag_cmp(s, "+INF"))
    11426. 

  11426.       *p = FLT_PINFTY;
    11427. 

  11427.     else if (!soap_tag_cmp(s, "-INF"))
    11428. 

  11428.       *p = FLT_NINFTY;
    11429. 

  11429.     else if (!soap_tag_cmp(s, "NaN"))
    11430. 

  11430.       *p = FLT_NAN;
    11431. 

  11431.     else
    11432. 

  11432.     {
    11433. 

  11433. /* On some systems strtof requires -std=c99 or does not even link: so we try to use strtod first */
    11434. 

  11434. #if defined(HAVE_STRTOD_L)
    11435. 

  11435.       char *r;
    11436. 

  11436.       *p = (float)strtod_l(s, &r, soap->c_locale);
    11437. 

  11437.       if (*r)
    11438. 

  11438. #elif defined(HAVE_STRTOD)
    11439. 

  11439.       char *r;
    11440. 

  11440.       *p = (float)strtod(s, &r);
    11441. 

  11441.       if (*r)
    11442. 

  11442. #elif defined(HAVE_STRTOF_L)
    11443. 

  11443.       char *r;
    11444. 

  11444.       *p = strtof_l((char*)s, &r, soap->c_locale);
    11445. 

  11445.       if (*r)
    11446. 

  11446. #elif defined(HAVE_STRTOF)
    11447. 

  11447.       char *r;
    11448. 

  11448.       *p = strtof((char*)s, &r);
    11449. 

  11449.       if (*r)
    11450. 

  11450. #endif
    11451. 

  11451.       {
    11452. 

  11452. #if defined(HAVE_SSCANF_L) && !defined(HAVE_STRTOF_L) && !defined(HAVE_STRTOD_L)
    11453. 

  11453.         if (sscanf_l(s, soap->c_locale, "%g", p) != 1)
    11454. 

  11454.           soap->error = SOAP_TYPE;
    11455. 

  11455. #elif defined(HAVE_SSCANF)
    11456. 

  11456.         if (sscanf(s, "%g", p) != 1)
    11457. 

  11457.           soap->error = SOAP_TYPE;
    11458. 

  11458. #else
    11459. 

  11459.         soap->error = SOAP_TYPE;
    11460. 

  11460. #endif
    11461. 

  11461.       }
    11462. 

  11462.     }
    11463. 

  11463.   }
    11464. 

  11464.   return soap->error;
    11465. 

  11465. }
    11466. 

  11466. #endif
    11467. 

  11467. 

  11468. /******************************************************************************/
    11469. 

  11469. #ifndef WITH_LEAN
    11470. 

  11470. static int soap_isnumeric(struct soap *soap, const char *type)
    11471. 

  11471. { if (soap_match_tag(soap, soap->type, type)
    11472. 

  11472.    && soap_match_tag(soap, soap->type, ":float")
    11473. 

  11473.    && soap_match_tag(soap, soap->type, ":double")
    11474. 

  11474.    && soap_match_tag(soap, soap->type, ":decimal")
    11475. 

  11475.    && soap_match_tag(soap, soap->type, ":integer")
    11476. 

  11476.    && soap_match_tag(soap, soap->type, ":positiveInteger")
    11477. 

  11477.    && soap_match_tag(soap, soap->type, ":negativeInteger")
    11478. 

  11478.    && soap_match_tag(soap, soap->type, ":nonPositiveInteger")
    11479. 

  11479.    && soap_match_tag(soap, soap->type, ":nonNegativeInteger")
    11480. 

  11480.    && soap_match_tag(soap, soap->type, ":long")
    11481. 

  11481.    && soap_match_tag(soap, soap->type, ":int")
    11482. 

  11482.    && soap_match_tag(soap, soap->type, ":short")
    11483. 

  11483.    && soap_match_tag(soap, soap->type, ":byte")
    11484. 

  11484.    && soap_match_tag(soap, soap->type, ":unsignedLong")
    11485. 

  11485.    && soap_match_tag(soap, soap->type, ":unsignedInt")
    11486. 

  11486.    && soap_match_tag(soap, soap->type, ":unsignedShort")
    11487. 

  11487.    && soap_match_tag(soap, soap->type, ":unsignedByte"))
    11488. 

  11488.   { soap->error = SOAP_TYPE;
    11489. 

  11489.     soap_revert(soap);
    11490. 

  11490.     return SOAP_ERR;
    11491. 

  11491.   }
    11492. 

  11492.   return SOAP_OK;
    11493. 

  11493. }
    11494. 

  11494. #endif
    11495. 

  11495. 

  11496. /******************************************************************************/
    11497. 

  11497. #ifndef PALM_2
    11498. 

  11498. SOAP_FMAC1
    11499. 

  11499. float *
    11500. 

  11500. SOAP_FMAC2
    11501. 

  11501. soap_infloat(struct soap *soap, const char *tag, float *p, const char *type, int t)
    11502. 

  11502. { if (soap_element_begin_in(soap, tag, 0, NULL))
    11503. 

  11503.     return NULL;
    11504. 

  11504. #ifndef WITH_LEAN
    11505. 

  11505.   if (*soap->type != '\0' && soap_isnumeric(soap, type))
    11506. 

  11506.     return NULL;
    11507. 

  11507. #endif
    11508. 

  11508.   p = (float*)soap_id_enter(soap, soap->id, p, t, sizeof(float), 0, NULL, NULL, NULL);
    11509. 

  11509.   if (*soap->href)
    11510. 

  11510.     p = (float*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(float), 0, NULL);
    11511. 

  11511.   else if (p)
    11512. 

  11512.   { if (soap_s2float(soap, soap_value(soap), p))
    11513. 

  11513.       return NULL;
    11514. 

  11514.   }
    11515. 

  11515.   if (soap->body && soap_element_end_in(soap, tag))
    11516. 

  11516.     return NULL;
    11517. 

  11517.   return p;
    11518. 

  11518. }
    11519. 

  11519. #endif
    11520. 

  11520. 

  11521. /******************************************************************************/
    11522. 

  11522. #ifndef PALM_2
    11523. 

  11523. SOAP_FMAC1
    11524. 

  11524. const char*
    11525. 

  11525. SOAP_FMAC2
    11526. 

  11526. soap_double2s(struct soap *soap, double n)
    11527. 

  11527. { char *s;
    11528. 

  11528.   if (soap_isnan(n))
    11529. 

  11529.     return "NaN";
    11530. 

  11530.   if (soap_ispinfd(n))
    11531. 

  11531.     return "INF";
    11532. 

  11532.   if (soap_isninfd(n))
    11533. 

  11533.     return "-INF";
    11534. 

  11534.   s = soap->tmpbuf;
    11535. 

  11535. #if defined(HAVE_SPRINTF_L)
    11536. 

  11536.   sprintf_l(s, soap->c_locale, soap->double_format, n);
    11537. 

  11537. #else
    11538. 

  11538.   sprintf(s, soap->double_format, n);
    11539. 

  11539.   s = strchr(s, ',');	/* convert decimal comma to DP */
    11540. 

  11540.   if (s)
    11541. 

  11541.     *s = '.';
    11542. 

  11542. #endif
    11543. 

  11543.   return soap->tmpbuf;
    11544. 

  11544. }
    11545. 

  11545. #endif
    11546. 

  11546. 

  11547. /******************************************************************************/
    11548. 

  11548. #ifndef PALM_2
    11549. 

  11549. SOAP_FMAC1
    11550. 

  11550. int
    11551. 

  11551. SOAP_FMAC2
    11552. 

  11552. soap_outdouble(struct soap *soap, const char *tag, int id, const double *p, const char *type, int n)
    11553. 

  11553. { if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
    11554. 

  11554.    || soap_string_out(soap, soap_double2s(soap, *p), 0))
    11555. 

  11555.     return soap->error;
    11556. 

  11556.   return soap_element_end_out(soap, tag);
    11557. 

  11557. }
    11558. 

  11558. #endif
    11559. 

  11559. 

  11560. /******************************************************************************/
    11561. 

  11561. #ifndef PALM_2
    11562. 

  11562. SOAP_FMAC1
    11563. 

  11563. int
    11564. 

  11564. SOAP_FMAC2
    11565. 

  11565. soap_s2double(struct soap *soap, const char *s, double *p)
    11566. 

  11566. { if (s)
    11567. 

  11567.   { if (!*s)
    11568. 

  11568.       return soap->error = SOAP_TYPE;
    11569. 

  11569.     if (!soap_tag_cmp(s, "INF"))
    11570. 

  11570.       *p = DBL_PINFTY;
    11571. 

  11571.     else if (!soap_tag_cmp(s, "+INF"))
    11572. 

  11572.       *p = DBL_PINFTY;
    11573. 

  11573.     else if (!soap_tag_cmp(s, "-INF"))
    11574. 

  11574.       *p = DBL_NINFTY;
    11575. 

  11575.     else if (!soap_tag_cmp(s, "NaN"))
    11576. 

  11576.       *p = DBL_NAN;
    11577. 

  11577.     else
    11578. 

  11578.     {
    11579. 

  11579. #if defined(HAVE_STRTOD_L)
    11580. 

  11580.       char *r;
    11581. 

  11581.       *p = strtod_l(s, &r, soap->c_locale);
    11582. 

  11582.       if (*r)
    11583. 

  11583. #elif defined(HAVE_STRTOD)
    11584. 

  11584.       char *r;
    11585. 

  11585.       *p = strtod(s, &r);
    11586. 

  11586.       if (*r)
    11587. 

  11587. #endif
    11588. 

  11588.       {
    11589. 

  11589. #if defined(HAVE_SSCANF_L) && !defined(HAVE_STRTOF_L) && !defined(HAVE_STRTOD_L)
    11590. 

  11590.         if (sscanf_l(s, soap->c_locale, "%lg", p) != 1)
    11591. 

  11591.           soap->error = SOAP_TYPE;
    11592. 

  11592. #elif defined(HAVE_SSCANF)
    11593. 

  11593.         if (sscanf(s, "%lg", p) != 1)
    11594. 

  11594.           soap->error = SOAP_TYPE;
    11595. 

  11595. #else
    11596. 

  11596.         soap->error = SOAP_TYPE;
    11597. 

  11597. #endif
    11598. 

  11598.       }
    11599. 

  11599.     }
    11600. 

  11600.   }
    11601. 

  11601.   return soap->error;
    11602. 

  11602. }
    11603. 

  11603. #endif
    11604. 

  11604. 

  11605. /******************************************************************************/
    11606. 

  11606. #ifndef PALM_2
    11607. 

  11607. SOAP_FMAC1
    11608. 

  11608. double *
    11609. 

  11609. SOAP_FMAC2
    11610. 

  11610. soap_indouble(struct soap *soap, const char *tag, double *p, const char *type, int t)
    11611. 

  11611. { if (soap_element_begin_in(soap, tag, 0, NULL))
    11612. 

  11612.     return NULL;
    11613. 

  11613. #ifndef WITH_LEAN
    11614. 

  11614.   if (*soap->type != '\0' && soap_isnumeric(soap, type))
    11615. 

  11615.     return NULL;
    11616. 

  11616. #endif
    11617. 

  11617.   p = (double*)soap_id_enter(soap, soap->id, p, t, sizeof(double), 0, NULL, NULL, NULL);
    11618. 

  11618.   if (*soap->href)
    11619. 

  11619.     p = (double*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(double), 0, NULL);
    11620. 

  11620.   else if (p)
    11621. 

  11621.   { if (soap_s2double(soap, soap_value(soap), p))
    11622. 

  11622.       return NULL;
    11623. 

  11623.   }
    11624. 

  11624.   if (soap->body && soap_element_end_in(soap, tag))
    11625. 

  11625.     return NULL;
    11626. 

  11626.   return p;
    11627. 

  11627. }
    11628. 

  11628. #endif
    11629. 

  11629. 

  11630. /******************************************************************************/
    11631. 

  11631. #ifndef PALM_2
    11632. 

  11632. SOAP_FMAC1
    11633. 

  11633. const char*
    11634. 

  11634. SOAP_FMAC2
    11635. 

  11635. soap_unsignedByte2s(struct soap *soap, unsigned char n)
    11636. 

  11636. { return soap_unsignedLong2s(soap, (unsigned long)n);
    11637. 

  11637. }
    11638. 

  11638. #endif
    11639. 

  11639. 

  11640. /******************************************************************************/
    11641. 

  11641. #ifndef PALM_2
    11642. 

  11642. SOAP_FMAC1
    11643. 

  11643. int
    11644. 

  11644. SOAP_FMAC2
    11645. 

  11645. soap_outunsignedByte(struct soap *soap, const char *tag, int id, const unsigned char *p, const char *type, int n)
    11646. 

  11646. { if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
    11647. 

  11647.    || soap_string_out(soap, soap_unsignedLong2s(soap, (unsigned long)*p), 0))
    11648. 

  11648.     return soap->error;
    11649. 

  11649.   return soap_element_end_out(soap, tag);
    11650. 

  11650. }
    11651. 

  11651. #endif
    11652. 

  11652. 

  11653. /******************************************************************************/
    11654. 

  11654. #ifndef PALM_2
    11655. 

  11655. SOAP_FMAC1
    11656. 

  11656. int
    11657. 

  11657. SOAP_FMAC2
    11658. 

  11658. soap_s2unsignedByte(struct soap *soap, const char *s, unsigned char *p)
    11659. 

  11659. { if (s)
    11660. 

  11660.   { unsigned long n;
    11661. 

  11661.     char *r;
    11662. 

  11662.     n = soap_strtoul(s, &r, 10);
    11663. 

  11663.     if (s == r || *r || n > 255)
    11664. 

  11664.       soap->error = SOAP_TYPE;
    11665. 

  11665.     *p = (unsigned char)n;
    11666. 

  11666.   }
    11667. 

  11667.   return soap->error;
    11668. 

  11668. }
    11669. 

  11669. #endif
    11670. 

  11670. 

  11671. /******************************************************************************/
    11672. 

  11672. #ifndef PALM_2
    11673. 

  11673. SOAP_FMAC1
    11674. 

  11674. unsigned char *
    11675. 

  11675. SOAP_FMAC2
    11676. 

  11676. soap_inunsignedByte(struct soap *soap, const char *tag, unsigned char *p, const char *type, int t)
    11677. 

  11677. { if (soap_element_begin_in(soap, tag, 0, NULL))
    11678. 

  11678.     return NULL;
    11679. 

  11679. #ifndef WITH_LEAN
    11680. 

  11680.   if (*soap->type
    11681. 

  11681.    && soap_match_tag(soap, soap->type, type)
    11682. 

  11682.    && soap_match_tag(soap, soap->type, ":unsignedByte"))
    11683. 

  11683.   { soap->error = SOAP_TYPE;
    11684. 

  11684.     soap_revert(soap);
    11685. 

  11685.     return NULL;
    11686. 

  11686.   }
    11687. 

  11687. #endif
    11688. 

  11688.   p = (unsigned char*)soap_id_enter(soap, soap->id, p, t, sizeof(unsigned char), 0, NULL, NULL, NULL);
    11689. 

  11689.   if (*soap->href)
    11690. 

  11690.     p = (unsigned char*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(unsigned char), 0, NULL);
    11691. 

  11691.   else if (p)
    11692. 

  11692.   { if (soap_s2unsignedByte(soap, soap_value(soap), p))
    11693. 

  11693.       return NULL;
    11694. 

  11694.   }
    11695. 

  11695.   if (soap->body && soap_element_end_in(soap, tag))
    11696. 

  11696.     return NULL;
    11697. 

  11697.   return p;
    11698. 

  11698. }
    11699. 

  11699. #endif
    11700. 

  11700. 

  11701. /******************************************************************************/
    11702. 

  11702. #ifndef PALM_2
    11703. 

  11703. SOAP_FMAC1
    11704. 

  11704. const char*
    11705. 

  11705. SOAP_FMAC2
    11706. 

  11706. soap_unsignedShort2s(struct soap *soap, unsigned short n)
    11707. 

  11707. { return soap_unsignedLong2s(soap, (unsigned long)n);
    11708. 

  11708. }
    11709. 

  11709. #endif
    11710. 

  11710. 

  11711. /******************************************************************************/
    11712. 

  11712. #ifndef PALM_2
    11713. 

  11713. SOAP_FMAC1
    11714. 

  11714. int
    11715. 

  11715. SOAP_FMAC2
    11716. 

  11716. soap_outunsignedShort(struct soap *soap, const char *tag, int id, const unsigned short *p, const char *type, int n)
    11717. 

  11717. { if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
    11718. 

  11718.    || soap_string_out(soap, soap_unsignedLong2s(soap, (unsigned long)*p), 0))
    11719. 

  11719.     return soap->error;
    11720. 

  11720.   return soap_element_end_out(soap, tag);
    11721. 

  11721. }
    11722. 

  11722. #endif
    11723. 

  11723. 

  11724. /******************************************************************************/
    11725. 

  11725. #ifndef PALM_2
    11726. 

  11726. SOAP_FMAC1
    11727. 

  11727. int
    11728. 

  11728. SOAP_FMAC2
    11729. 

  11729. soap_s2unsignedShort(struct soap *soap, const char *s, unsigned short *p)
    11730. 

  11730. { if (s)
    11731. 

  11731.   { unsigned long n;
    11732. 

  11732.     char *r;
    11733. 

  11733.     n = soap_strtoul(s, &r, 10);
    11734. 

  11734.     if (s == r || *r || n > 65535)
    11735. 

  11735.       soap->error = SOAP_TYPE;
    11736. 

  11736.     *p = (unsigned short)n;
    11737. 

  11737.   }
    11738. 

  11738.   return soap->error;
    11739. 

  11739. }
    11740. 

  11740. #endif
    11741. 

  11741. 

  11742. /******************************************************************************/
    11743. 

  11743. #ifndef PALM_2
    11744. 

  11744. SOAP_FMAC1
    11745. 

  11745. unsigned short *
    11746. 

  11746. SOAP_FMAC2
    11747. 

  11747. soap_inunsignedShort(struct soap *soap, const char *tag, unsigned short *p, const char *type, int t)
    11748. 

  11748. { if (soap_element_begin_in(soap, tag, 0, NULL))
    11749. 

  11749.     return NULL;
    11750. 

  11750. #ifndef WITH_LEAN
    11751. 

  11751.   if (*soap->type
    11752. 

  11752.    && soap_match_tag(soap, soap->type, type)
    11753. 

  11753.    && soap_match_tag(soap, soap->type, ":unsignedShort")
    11754. 

  11754.    && soap_match_tag(soap, soap->type, ":unsignedByte"))
    11755. 

  11755.   { soap->error = SOAP_TYPE;
    11756. 

  11756.     soap_revert(soap);
    11757. 

  11757.     return NULL;
    11758. 

  11758.   }
    11759. 

  11759. #endif
    11760. 

  11760.   p = (unsigned short*)soap_id_enter(soap, soap->id, p, t, sizeof(unsigned short), 0, NULL, NULL, NULL);
    11761. 

  11761.   if (*soap->href)
    11762. 

  11762.     p = (unsigned short*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(unsigned short), 0, NULL);
    11763. 

  11763.   else if (p)
    11764. 

  11764.   { if (soap_s2unsignedShort(soap, soap_value(soap), p))
    11765. 

  11765.       return NULL;
    11766. 

  11766.   }
    11767. 

  11767.   if (soap->body && soap_element_end_in(soap, tag))
    11768. 

  11768.     return NULL;
    11769. 

  11769.   return p;
    11770. 

  11770. }
    11771. 

  11771. #endif
    11772. 

  11772. 

  11773. /******************************************************************************/
    11774. 

  11774. #ifndef PALM_2
    11775. 

  11775. SOAP_FMAC1
    11776. 

  11776. const char*
    11777. 

  11777. SOAP_FMAC2
    11778. 

  11778. soap_unsignedInt2s(struct soap *soap, unsigned int n)
    11779. 

  11779. { return soap_unsignedLong2s(soap, (unsigned long)n);
    11780. 

  11780. }
    11781. 

  11781. #endif
    11782. 

  11782. 

  11783. /******************************************************************************/
    11784. 

  11784. #ifndef PALM_2
    11785. 

  11785. SOAP_FMAC1
    11786. 

  11786. int
    11787. 

  11787. SOAP_FMAC2
    11788. 

  11788. soap_outunsignedInt(struct soap *soap, const char *tag, int id, const unsigned int *p, const char *type, int n)
    11789. 

  11789. { if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
    11790. 

  11790.    || soap_string_out(soap, soap_unsignedLong2s(soap, (unsigned long)*p), 0))
    11791. 

  11791.     return soap->error;
    11792. 

  11792.   return soap_element_end_out(soap, tag);
    11793. 

  11793. }
    11794. 

  11794. #endif
    11795. 

  11795. 

  11796. /******************************************************************************/
    11797. 

  11797. #ifndef PALM_2
    11798. 

  11798. SOAP_FMAC1
    11799. 

  11799. int
    11800. 

  11800. SOAP_FMAC2
    11801. 

  11801. soap_s2unsignedInt(struct soap *soap, const char *s, unsigned int *p)
    11802. 

  11802. { if (s)
    11803. 

  11803.   { char *r;
    11804. 

  11804. #ifndef WITH_NOIO
    11805. 

  11805. #ifndef WITH_LEAN
    11806. 

  11806.     soap_reset_errno;
    11807. 

  11807. #endif
    11808. 

  11808. #endif
    11809. 

  11809.     *p = (unsigned int)soap_strtoul(s, &r, 10);
    11810. 

  11810.     if ((s == r && (soap->mode & SOAP_XML_STRICT)) || *r
    11811. 

  11811. #ifndef WITH_NOIO
    11812. 

  11812. #ifndef WITH_LEAN
    11813. 

  11813.      || soap_errno == SOAP_ERANGE
    11814. 

  11814. #endif
    11815. 

  11815. #endif
    11816. 

  11816.     )
    11817. 

  11817.       soap->error = SOAP_TYPE;
    11818. 

  11818.   }
    11819. 

  11819.   return soap->error;
    11820. 

  11820. }
    11821. 

  11821. #endif
    11822. 

  11822. 

  11823. /******************************************************************************/
    11824. 

  11824. #ifndef PALM_2
    11825. 

  11825. SOAP_FMAC1
    11826. 

  11826. unsigned int *
    11827. 

  11827. SOAP_FMAC2
    11828. 

  11828. soap_inunsignedInt(struct soap *soap, const char *tag, unsigned int *p, const char *type, int t)
    11829. 

  11829. { if (soap_element_begin_in(soap, tag, 0, NULL))
    11830. 

  11830.     return NULL;
    11831. 

  11831. #ifndef WITH_LEAN
    11832. 

  11832.   if (*soap->type
    11833. 

  11833.    && soap_match_tag(soap, soap->type, type)
    11834. 

  11834.    && soap_match_tag(soap, soap->type, ":unsignedInt")
    11835. 

  11835.    && soap_match_tag(soap, soap->type, ":unsignedShort")
    11836. 

  11836.    && soap_match_tag(soap, soap->type, ":unsignedByte"))
    11837. 

  11837.   { soap->error = SOAP_TYPE;
    11838. 

  11838.     soap_revert(soap);
    11839. 

  11839.     return NULL;
    11840. 

  11840.   }
    11841. 

  11841. #endif
    11842. 

  11842.   p = (unsigned int*)soap_id_enter(soap, soap->id, p, t, sizeof(unsigned int), 0, NULL, NULL, NULL);
    11843. 

  11843.   if (*soap->href)
    11844. 

  11844.     p = (unsigned int*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(unsigned int), 0, NULL);
    11845. 

  11845.   else if (p)
    11846. 

  11846.   { if (soap_s2unsignedInt(soap, soap_value(soap), p))
    11847. 

  11847.       return NULL;
    11848. 

  11848.   }
    11849. 

  11849.   if (soap->body && soap_element_end_in(soap, tag))
    11850. 

  11850.     return NULL;
    11851. 

  11851.   return p;
    11852. 

  11852. }
    11853. 

  11853. #endif
    11854. 

  11854. 

  11855. /******************************************************************************/
    11856. 

  11856. #ifndef PALM_2
    11857. 

  11857. SOAP_FMAC1
    11858. 

  11858. const char*
    11859. 

  11859. SOAP_FMAC2
    11860. 

  11860. soap_unsignedLong2s(struct soap *soap, unsigned long n)
    11861. 

  11861. { sprintf(soap->tmpbuf, "%lu", n);
    11862. 

  11862.   return soap->tmpbuf;
    11863. 

  11863. }
    11864. 

  11864. #endif
    11865. 

  11865. 

  11866. /******************************************************************************/
    11867. 

  11867. #ifndef PALM_2
    11868. 

  11868. SOAP_FMAC1
    11869. 

  11869. int
    11870. 

  11870. SOAP_FMAC2
    11871. 

  11871. soap_outunsignedLong(struct soap *soap, const char *tag, int id, const unsigned long *p, const char *type, int n)
    11872. 

  11872. { if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
    11873. 

  11873.    || soap_string_out(soap, soap_unsignedLong2s(soap, *p), 0))
    11874. 

  11874.     return soap->error;
    11875. 

  11875.   return soap_element_end_out(soap, tag);
    11876. 

  11876. }
    11877. 

  11877. #endif
    11878. 

  11878. 

  11879. /******************************************************************************/
    11880. 

  11880. #ifndef PALM_2
    11881. 

  11881. SOAP_FMAC1
    11882. 

  11882. int
    11883. 

  11883. SOAP_FMAC2
    11884. 

  11884. soap_s2unsignedLong(struct soap *soap, const char *s, unsigned long *p)
    11885. 

  11885. { if (s)
    11886. 

  11886.   { char *r;
    11887. 

  11887. #ifndef WITH_NOIO
    11888. 

  11888. #ifndef WITH_LEAN
    11889. 

  11889.     soap_reset_errno;
    11890. 

  11890. #endif
    11891. 

  11891. #endif
    11892. 

  11892.     *p = soap_strtoul(s, &r, 10);
    11893. 

  11893.     if ((s == r && (soap->mode & SOAP_XML_STRICT)) || *r
    11894. 

  11894. #ifndef WITH_NOIO
    11895. 

  11895. #ifndef WITH_LEAN
    11896. 

  11896.      || soap_errno == SOAP_ERANGE
    11897. 

  11897. #endif
    11898. 

  11898. #endif
    11899. 

  11899.     )
    11900. 

  11900.       soap->error = SOAP_TYPE;
    11901. 

  11901.   }
    11902. 

  11902.   return soap->error;
    11903. 

  11903. }
    11904. 

  11904. #endif
    11905. 

  11905. 

  11906. /******************************************************************************/
    11907. 

  11907. #ifndef PALM_2
    11908. 

  11908. SOAP_FMAC1
    11909. 

  11909. unsigned long *
    11910. 

  11910. SOAP_FMAC2
    11911. 

  11911. soap_inunsignedLong(struct soap *soap, const char *tag, unsigned long *p, const char *type, int t)
    11912. 

  11912. { if (soap_element_begin_in(soap, tag, 0, NULL))
    11913. 

  11913.     return NULL;
    11914. 

  11914. #ifndef WITH_LEAN
    11915. 

  11915.   if (*soap->type
    11916. 

  11916.    && soap_match_tag(soap, soap->type, type)
    11917. 

  11917.    && soap_match_tag(soap, soap->type, ":unsignedInt")
    11918. 

  11918.    && soap_match_tag(soap, soap->type, ":unsignedShort")
    11919. 

  11919.    && soap_match_tag(soap, soap->type, ":unsignedByte"))
    11920. 

  11920.   { soap->error = SOAP_TYPE;
    11921. 

  11921.     soap_revert(soap);
    11922. 

  11922.     return NULL;
    11923. 

  11923.   }
    11924. 

  11924. #endif
    11925. 

  11925.   p = (unsigned long*)soap_id_enter(soap, soap->id, p, t, sizeof(unsigned long), 0, NULL, NULL, NULL);
    11926. 

  11926.   if (*soap->href)
    11927. 

  11927.     p = (unsigned long*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(unsigned long), 0, NULL);
    11928. 

  11928.   else if (p)
    11929. 

  11929.   { if (soap_s2unsignedLong(soap, soap_value(soap), p))
    11930. 

  11930.       return NULL;
    11931. 

  11931.   }
    11932. 

  11932.   if (soap->body && soap_element_end_in(soap, tag))
    11933. 

  11933.     return NULL;
    11934. 

  11934.   return p;
    11935. 

  11935. }
    11936. 

  11936. #endif
    11937. 

  11937. 

  11938. /******************************************************************************/
    11939. 

  11939. #ifndef WITH_LEAN
    11940. 

  11940. SOAP_FMAC1
    11941. 

  11941. const char*
    11942. 

  11942. SOAP_FMAC2
    11943. 

  11943. soap_ULONG642s(struct soap *soap, ULONG64 n)
    11944. 

  11944. { sprintf(soap->tmpbuf, SOAP_ULONG_FORMAT, n);
    11945. 

  11945.   return soap->tmpbuf;
    11946. 

  11946. }
    11947. 

  11947. #endif
    11948. 

  11948. 

  11949. /******************************************************************************/
    11950. 

  11950. #ifndef WITH_LEAN
    11951. 

  11951. SOAP_FMAC1
    11952. 

  11952. int
    11953. 

  11953. SOAP_FMAC2
    11954. 

  11954. soap_outULONG64(struct soap *soap, const char *tag, int id, const ULONG64 *p, const char *type, int n)
    11955. 

  11955. { if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
    11956. 

  11956.    || soap_string_out(soap, soap_ULONG642s(soap, *p), 0))
    11957. 

  11957.     return soap->error;
    11958. 

  11958.   return soap_element_end_out(soap, tag);
    11959. 

  11959. }
    11960. 

  11960. #endif
    11961. 

  11961. 

  11962. /******************************************************************************/
    11963. 

  11963. #ifndef WITH_LEAN
    11964. 

  11964. SOAP_FMAC1
    11965. 

  11965. int
    11966. 

  11966. SOAP_FMAC2
    11967. 

  11967. soap_s2ULONG64(struct soap *soap, const char *s, ULONG64 *p)
    11968. 

  11968. { if (s)
    11969. 

  11969.   {
    11970. 

  11970. #ifdef HAVE_STRTOULL
    11971. 

  11971.     char *r;
    11972. 

  11972. #ifndef WITH_NOIO
    11973. 

  11973. #ifndef WITH_LEAN
    11974. 

  11974.     soap_reset_errno;
    11975. 

  11975. #endif
    11976. 

  11976. #endif
    11977. 

  11977.     *p = strtoull(s, &r, 10);
    11978. 

  11978.     if ((s == r && (soap->mode & SOAP_XML_STRICT)) || *r
    11979. 

  11979. #ifndef WITH_NOIO
    11980. 

  11980. #ifndef WITH_LEAN
    11981. 

  11981.        || soap_errno == SOAP_ERANGE
    11982. 

  11982. #endif
    11983. 

  11983. #endif
    11984. 

  11984.       )
    11985. 

  11985. #else
    11986. 

  11986. #ifdef HAVE_SSCANF
    11987. 

  11987.     if (sscanf(s, SOAP_ULONG_FORMAT, p) != 1)
    11988. 

  11988. #endif
    11989. 

  11989. #endif
    11990. 

  11990.       soap->error = SOAP_TYPE;
    11991. 

  11991.   }
    11992. 

  11992.   return soap->error;
    11993. 

  11993. }
    11994. 

  11994. #endif
    11995. 

  11995. 

  11996. /******************************************************************************/
    11997. 

  11997. #ifndef WITH_LEAN
    11998. 

  11998. SOAP_FMAC1
    11999. 

  11999. ULONG64 *
    12000. 

  12000. SOAP_FMAC2
    12001. 

  12001. soap_inULONG64(struct soap *soap, const char *tag, ULONG64 *p, const char *type, int t)
    12002. 

  12002. { if (soap_element_begin_in(soap, tag, 0, NULL))
    12003. 

  12003.     return NULL;
    12004. 

  12004.   if (*soap->type
    12005. 

  12005.    && soap_match_tag(soap, soap->type, type)
    12006. 

  12006.    && soap_match_tag(soap, soap->type, ":positiveInteger")
    12007. 

  12007.    && soap_match_tag(soap, soap->type, ":nonNegativeInteger")
    12008. 

  12008.    && soap_match_tag(soap, soap->type, ":unsignedLong")
    12009. 

  12009.    && soap_match_tag(soap, soap->type, ":unsignedInt")
    12010. 

  12010.    && soap_match_tag(soap, soap->type, ":unsignedShort")
    12011. 

  12011.    && soap_match_tag(soap, soap->type, ":unsignedByte"))
    12012. 

  12012.   { soap->error = SOAP_TYPE;
    12013. 

  12013.     soap_revert(soap);
    12014. 

  12014.     return NULL;
    12015. 

  12015.   }
    12016. 

  12016.   p = (ULONG64*)soap_id_enter(soap, soap->id, p, t, sizeof(ULONG64), 0, NULL, NULL, NULL);
    12017. 

  12017.   if (*soap->href)
    12018. 

  12018.     p = (ULONG64*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(ULONG64), 0, NULL);
    12019. 

  12019.   else if (p)
    12020. 

  12020.   { if (soap_s2ULONG64(soap, soap_value(soap), p))
    12021. 

  12021.       return NULL;
    12022. 

  12022.   }
    12023. 

  12023.   if (soap->body && soap_element_end_in(soap, tag))
    12024. 

  12024.     return NULL;
    12025. 

  12025.   return p;
    12026. 

  12026. }
    12027. 

  12027. #endif
    12028. 

  12028. 

  12029. /******************************************************************************/
    12030. 

  12030. #ifndef PALM_2
    12031. 

  12031. SOAP_FMAC1
    12032. 

  12032. int
    12033. 

  12033. SOAP_FMAC2
    12034. 

  12034. soap_s2string(struct soap *soap, const char *s, char **t, long minlen, long maxlen)
    12035. 

  12035. { if (s)
    12036. 

  12036.   { long l = (long)strlen(s);
    12037. 

  12037.     if ((maxlen >= 0 && l > maxlen) || l < minlen)
    12038. 

  12038.       return soap->error = SOAP_LENGTH;
    12039. 

  12039.     if (!(*t = soap_strdup(soap, s)))
    12040. 

  12040.       return soap->error = SOAP_EOM;
    12041. 

  12041.     if (!(soap->mode & (SOAP_ENC_LATIN | SOAP_C_UTFSTRING)))
    12042. 

  12042.     { char *r = *t;
    12043. 

  12043.       /* remove non-ASCII chars */
    12044. 

  12044.       for (s = *t; *s; s++)
    12045. 

  12045.         if (!(*s & 0x80))
    12046. 

  12046. 	  *r++ = *s;
    12047. 

  12047.       *r = '\0';
    12048. 

  12048.     }
    12049. 

  12049.   }
    12050. 

  12050.   return soap->error;
    12051. 

  12051. }
    12052. 

  12052. #endif
    12053. 

  12053. 

  12054. /******************************************************************************/
    12055. 

  12055. #ifndef PALM_2
    12056. 

  12056. SOAP_FMAC1
    12057. 

  12057. int
    12058. 

  12058. SOAP_FMAC2
    12059. 

  12059. soap_s2QName(struct soap *soap, const char *s, char **t, long minlen, long maxlen)
    12060. 

  12060. { if (s)
    12061. 

  12061.   { long l = (long)strlen(s);
    12062. 

  12062.     if ((maxlen >= 0 && l > maxlen) || l < minlen)
    12063. 

  12063.       return soap->error = SOAP_LENGTH;
    12064. 

  12064.     soap->labidx = 0;
    12065. 

  12065.     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Normalized namespace(s) of QNames '%s'", s));
    12066. 

  12066.     /* convert (by prefix normalize prefix) all QNames in s */
    12067. 

  12067.     for (;;)
    12068. 

  12068.     { size_t n;
    12069. 

  12069.       struct soap_nlist *np;
    12070. 

  12070.       register const char *p;
    12071. 

  12071.       /* skip blanks */
    12072. 

  12072.       while (*s && soap_blank(*s))
    12073. 

  12073.         s++;
    12074. 

  12074.       if (!*s)
    12075. 

  12075.         break;
    12076. 

  12076.       /* find next QName */
    12077. 

  12077.       n = 1;
    12078. 

  12078.       while (s[n] && !soap_blank(s[n]))
    12079. 

  12079.         n++;
    12080. 

  12080.       np = soap->nlist;
    12081. 

  12081.       /* if there is no namespace stack, or prefix is "xml" then copy string */
    12082. 

  12082.       if (!np || !strncmp(s, "xml:", 4))
    12083. 

  12083.       { soap_append_lab(soap, s, n);
    12084. 

  12084.       }
    12085. 

  12085.       else /* we normalize the QName by replacing its prefix */
    12086. 

  12086.       { for (p = s; *p && p < s + n; p++)
    12087. 

  12087.           if (*p == ':')
    12088. 

  12088. 	    break;
    12089. 

  12089.         if (*p == ':')
    12090. 

  12090.         { size_t k = p - s;
    12091. 

  12091.           while (np && (strncmp(np->id, s, k) || np->id[k]))
    12092. 

  12092.             np = np->next;
    12093. 

  12093.           p++;
    12094. 

  12094.         }
    12095. 

  12095.         else
    12096. 

  12096.         { while (np && *np->id)
    12097. 

  12097.             np = np->next;
    12098. 

  12098.           p = s;
    12099. 

  12099.         }
    12100. 

  12100.         /* replace prefix */
    12101. 

  12101.         if (np)
    12102. 

  12102.         { if (np->index >= 0 && soap->local_namespaces)
    12103. 

  12103.           { const char *q = soap->local_namespaces[np->index].id;
    12104. 

  12104.             if (q)
    12105. 

  12105.               soap_append_lab(soap, q, strlen(q));
    12106. 

  12106.           }
    12107. 

  12107.           else if (np->ns)
    12108. 

  12108.           { soap_append_lab(soap, "\"", 1);
    12109. 

  12109.             soap_append_lab(soap, np->ns, strlen(np->ns));
    12110. 

  12110.             soap_append_lab(soap, "\"", 1);
    12111. 

  12111.           }
    12112. 

  12112.           else
    12113. 

  12113.           { 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));
    12114. 

  12114.             return soap->error = SOAP_NAMESPACE; 
    12115. 

  12115.           }
    12116. 

  12116.         }
    12117. 

  12117.         else if (s[n]) /* no namespace, part of string */
    12118. 

  12118.         { soap_append_lab(soap, s, n);
    12119. 

  12119.         } 
    12120. 

  12120. 	else /* no namespace: assume "" namespace */
    12121. 

  12121.         { soap_append_lab(soap, "\"\"", 2);
    12122. 

  12122. 	}
    12123. 

  12123.         soap_append_lab(soap, ":", 1);
    12124. 

  12124.         soap_append_lab(soap, p, n - (p-s));
    12125. 

  12125.       }
    12126. 

  12126.       /* advance to next and add spacing */
    12127. 

  12127.       s += n;
    12128. 

  12128.       if (*s)
    12129. 

  12129.         soap_append_lab(soap, " ", 1);
    12130. 

  12130.     }
    12131. 

  12131.     soap_append_lab(soap, SOAP_STR_EOS, 1);
    12132. 

  12132.     *t = soap_strdup(soap, soap->labbuf);
    12133. 

  12133.     DBGLOG(TEST, SOAP_MESSAGE(fdebug, " into '%s'\n", *t));
    12134. 

  12134.   }
    12135. 

  12135.   return soap->error;
    12136. 

  12136. }
    12137. 

  12137. #endif
    12138. 

  12138. 

  12139. /******************************************************************************/
    12140. 

  12140. #ifndef PALM_2
    12141. 

  12141. SOAP_FMAC1
    12142. 

  12142. const char*
    12143. 

  12143. SOAP_FMAC2
    12144. 

  12144. soap_QName2s(struct soap *soap, const char *s)
    12145. 

  12145. { const char *t = NULL;
    12146. 

  12146.   if (s)
    12147. 

  12147.   { soap->labidx = 0;
    12148. 

  12148.     for (;;)
    12149. 

  12149.     { size_t n;
    12150. 

  12150.       /* skip blanks */
    12151. 

  12151.       while (*s && soap_blank(*s))
    12152. 

  12152.         s++;
    12153. 

  12153.       if (!*s)
    12154. 

  12154.         break;
    12155. 

  12155.       /* find next QName */
    12156. 

  12156.       n = 1;
    12157. 

  12157.       while (s[n] && !soap_blank(s[n]))
    12158. 

  12158.         n++;
    12159. 

  12159.       /* normal prefix: pass string as is */
    12160. 

  12160.       if (*s != '"')
    12161. 

  12161.       { soap_append_lab(soap, s, n);
    12162. 

  12162. #ifndef WITH_LEAN
    12163. 

  12163.         if ((soap->mode & SOAP_XML_CANONICAL))
    12164. 

  12164.         { const char *r = strchr(s, ':');
    12165. 

  12165.           if (r)
    12166. 

  12166.             soap_utilize_ns(soap, s, r - s);
    12167. 

  12167.         }
    12168. 

  12168. #endif
    12169. 

  12169.       }
    12170. 

  12170.       else /* URL-based string prefix */
    12171. 

  12171.       { const char *q;
    12172. 

  12172.         s++;
    12173. 

  12173.         q = strchr(s, '"');
    12174. 

  12174.         if (q)
    12175. 

  12175.         { struct Namespace *p = soap->local_namespaces;
    12176. 

  12176.           if (p)
    12177. 

  12177.           { for (; p->id; p++)
    12178. 

  12178.             { if (p->ns)
    12179. 

  12179.                 if (!soap_tag_cmp(s, p->ns))
    12180. 

  12180.                   break;
    12181. 

  12181.               if (p->in)
    12182. 

  12182.                 if (!soap_tag_cmp(s, p->in))
    12183. 

  12183.                   break;
    12184. 

  12184.             }
    12185. 

  12185.           }
    12186. 

  12186.           /* URL is in the namespace table? */
    12187. 

  12187.           if (p && p->id)
    12188. 

  12188.           { soap_append_lab(soap, p->id, strlen(p->id));
    12189. 

  12189.           }
    12190. 

  12190.           else /* not in namespace table: create xmlns binding */
    12191. 

  12191.           { char *r = soap_strdup(soap, s);
    12192. 

  12192.             r[q-s] = '\0';
    12193. 

  12193.             sprintf(soap->tmpbuf, "xmlns:_%d", soap->idnum++);
    12194. 

  12194.             soap_set_attr(soap, soap->tmpbuf, r, 1);
    12195. 

  12195.             soap_append_lab(soap, soap->tmpbuf + 6, strlen(soap->tmpbuf + 6));
    12196. 

  12196.           }
    12197. 

  12197.           soap_append_lab(soap, q + 1, n - (q-s) - 1);
    12198. 

  12198.         }
    12199. 

  12199.       }
    12200. 

  12200.       /* advance to next and add spacing */
    12201. 

  12201.       s += n;
    12202. 

  12202.       if (*s)
    12203. 

  12203.         soap_append_lab(soap, " ", 1);
    12204. 

  12204.     }
    12205. 

  12205.     soap_append_lab(soap, SOAP_STR_EOS, 1);
    12206. 

  12206.     t = soap_strdup(soap, soap->labbuf);
    12207. 

  12207.   }
    12208. 

  12208.   return t;
    12209. 

  12209. }
    12210. 

  12210. #endif
    12211. 

  12211. 

  12212. /******************************************************************************/
    12213. 

  12213. #ifndef WITH_LEAN
    12214. 

  12214. SOAP_FMAC1
    12215. 

  12215. int
    12216. 

  12216. SOAP_FMAC2
    12217. 

  12217. soap_s2wchar(struct soap *soap, const char *s, wchar_t **t, long minlen, long maxlen)
    12218. 

  12218. { if (s)
    12219. 

  12219.   { long l;
    12220. 

  12220.     wchar_t *r;
    12221. 

  12221.     *t = r = (wchar_t*)soap_malloc(soap, sizeof(wchar_t) * (strlen(s) + 1));
    12222. 

  12222.     if (!r)
    12223. 

  12223.       return soap->error = SOAP_EOM;
    12224. 

  12224.     if (soap->mode & SOAP_ENC_LATIN)
    12225. 

  12225.     { while (*s)
    12226. 

  12226.         *r++ = (wchar_t)*s++;
    12227. 

  12227.     }
    12228. 

  12228.     else
    12229. 

  12229.     { /* Convert UTF8 to wchar */
    12230. 

  12230.       while (*s)
    12231. 

  12231.       { register soap_wchar c, c1, c2, c3, c4;
    12232. 

  12232.         c = (unsigned char)*s++;
    12233. 

  12233.         if (c < 0x80)
    12234. 

  12234.           *r++ = (wchar_t)c;
    12235. 

  12235.         else
    12236. 

  12236.         { c1 = (soap_wchar)*s++ & 0x3F;
    12237. 

  12237.           if (c < 0xE0)
    12238. 

  12238.             *r++ = (wchar_t)(((soap_wchar)(c & 0x1F) << 6) | c1);
    12239. 

  12239.           else
    12240. 

  12240.           { c2 = (soap_wchar)*s++ & 0x3F;
    12241. 

  12241.             if (c < 0xF0)
    12242. 

  12242.               *r++ = (wchar_t)(((soap_wchar)(c & 0x0F) << 12) | (c1 << 6) | c2);
    12243. 

  12243.             else
    12244. 

  12244.             { c3 = (soap_wchar)*s++ & 0x3F;
    12245. 

  12245.               if (c < 0xF8)
    12246. 

  12246.                 *r++ = (wchar_t)(((soap_wchar)(c & 0x07) << 18) | (c1 << 12) | (c2 << 6) | c3);
    12247. 

  12247.               else
    12248. 

  12248.               { c4 = (soap_wchar)*s++ & 0x3F;
    12249. 

  12249.                 if (c < 0xFC)
    12250. 

  12250.                   *r++ = (wchar_t)(((soap_wchar)(c & 0x03) << 24) | (c1 << 18) | (c2 << 12) | (c3 << 6) | c4);
    12251. 

  12251.                 else
    12252. 

  12252.                   *r++ = (wchar_t)(((soap_wchar)(c & 0x01) << 30) | (c1 << 24) | (c2 << 18) | (c3 << 12) | (c4 << 6) | (soap_wchar)(*s++ & 0x3F));
    12253. 

  12253.               }
    12254. 

  12254.             }
    12255. 

  12255.           }
    12256. 

  12256.         }
    12257. 

  12257.       }
    12258. 

  12258.     }
    12259. 

  12259.     *r = L'\0';
    12260. 

  12260.     l = (long)(r - *t);
    12261. 

  12261.     if ((maxlen >= 0 && l > maxlen) || l < minlen)
    12262. 

  12262.       return soap->error = SOAP_LENGTH;
    12263. 

  12263.   }
    12264. 

  12264.   return soap->error;
    12265. 

  12265. }
    12266. 

  12266. #endif
    12267. 

  12267. 

  12268. /******************************************************************************/
    12269. 

  12269. #ifndef WITH_LEAN
    12270. 

  12270. SOAP_FMAC1
    12271. 

  12271. const char*
    12272. 

  12272. SOAP_FMAC2
    12273. 

  12273. soap_wchar2s(struct soap *soap, const wchar_t *s)
    12274. 

  12274. { register soap_wchar c;
    12275. 

  12275.   register char *r, *t;
    12276. 

  12276.   const wchar_t *q = s;
    12277. 

  12277.   size_t n = 0;
    12278. 

  12278.   while ((c = *q++))
    12279. 

  12279.   { if (c > 0 && c < 0x80)
    12280. 

  12280.       n++;
    12281. 

  12281.     else
    12282. 

  12282.       n += 6;
    12283. 

  12283.   }
    12284. 

  12284.   r = t = (char*)soap_malloc(soap, n + 1);
    12285. 

  12285.   if (r)
    12286. 

  12286.   { /* Convert wchar to UTF8 */
    12287. 

  12287.     while ((c = *s++))
    12288. 

  12288.     { if (c > 0 && c < 0x80)
    12289. 

  12289.         *t++ = (char)c;
    12290. 

  12290.       else
    12291. 

  12291.       { if (c < 0x0800)
    12292. 

  12292.           *t++ = (char)(0xC0 | ((c >> 6) & 0x1F));
    12293. 

  12293.         else
    12294. 

  12294.         { if (c < 0x010000)
    12295. 

  12295.             *t++ = (char)(0xE0 | ((c >> 12) & 0x0F));
    12296. 

  12296.           else
    12297. 

  12297.           { if (c < 0x200000)
    12298. 

  12298.               *t++ = (char)(0xF0 | ((c >> 18) & 0x07));
    12299. 

  12299.             else
    12300. 

  12300.             { if (c < 0x04000000)
    12301. 

  12301.                 *t++ = (char)(0xF8 | ((c >> 24) & 0x03));
    12302. 

  12302.               else
    12303. 

  12303.               { *t++ = (char)(0xFC | ((c >> 30) & 0x01));
    12304. 

  12304.                 *t++ = (char)(0x80 | ((c >> 24) & 0x3F));
    12305. 

  12305.               }
    12306. 

  12306.               *t++ = (char)(0x80 | ((c >> 18) & 0x3F));
    12307. 

  12307.             }     
    12308. 

  12308.             *t++ = (char)(0x80 | ((c >> 12) & 0x3F));
    12309. 

  12309.           }
    12310. 

  12310.           *t++ = (char)(0x80 | ((c >> 6) & 0x3F));
    12311. 

  12311.         }
    12312. 

  12312.         *t++ = (char)(0x80 | (c & 0x3F));
    12313. 

  12313.       }
    12314. 

  12314.     }
    12315. 

  12315.     *t = '\0';
    12316. 

  12316.   }
    12317. 

  12317.   return r;
    12318. 

  12318. }
    12319. 

  12319. #endif
    12320. 

  12320. 

  12321. /******************************************************************************/
    12322. 

  12322. #ifndef PALM_2
    12323. 

  12323. SOAP_FMAC1
    12324. 

  12324. int
    12325. 

  12325. SOAP_FMAC2
    12326. 

  12326. soap_outstring(struct soap *soap, const char *tag, int id, char *const*p, const char *type, int n) 
    12327. 

  12327. { id = soap_element_id(soap, tag, id, *p, NULL, 0, type, n);
    12328. 

  12328.   if (id < 0)
    12329. 

  12329.     return soap->error;
    12330. 

  12330.   if (!**p && (soap->mode & SOAP_C_NILSTRING))
    12331. 

  12331.     return soap_element_null(soap, tag, id, type);
    12332. 

  12332.   if (soap_element_begin_out(soap, tag, id, type)
    12333. 

  12333.    || soap_string_out(soap, *p, 0)
    12334. 

  12334.    || soap_element_end_out(soap, tag))
    12335. 

  12335.     return soap->error;
    12336. 

  12336.   return SOAP_OK;
    12337. 

  12337. }
    12338. 

  12338. #endif
    12339. 

  12339. 

  12340. /******************************************************************************/
    12341. 

  12341. #ifndef PALM_2
    12342. 

  12342. SOAP_FMAC1
    12343. 

  12343. char **
    12344. 

  12344. SOAP_FMAC2
    12345. 

  12345. soap_instring(struct soap *soap, const char *tag, char **p, const char *type, int t, int flag, long minlen, long maxlen)
    12346. 

  12346. { if (soap_element_begin_in(soap, tag, 1, NULL))
    12347. 

  12347.   { if (!tag || *tag != '-' || soap->error != SOAP_NO_TAG)
    12348. 

  12348.       return NULL;
    12349. 

  12349.     soap->error = SOAP_OK;
    12350. 

  12350.   }
    12351. 

  12351.   if (!p)
    12352. 

  12352.   { if (!(p = (char**)soap_malloc(soap, sizeof(char*))))
    12353. 

  12353.       return NULL;
    12354. 

  12354.   }
    12355. 

  12355.   if (soap->null)
    12356. 

  12356.     *p = NULL;
    12357. 

  12357.   else if (soap->body)
    12358. 

  12358.   { *p = soap_string_in(soap, flag, minlen, maxlen);
    12359. 

  12359.     if (!*p || !(char*)soap_id_enter(soap, soap->id, *p, t, sizeof(char*), 0, NULL, NULL, NULL))
    12360. 

  12360.       return NULL;
    12361. 

  12361.     if (!**p && tag && *tag == '-')
    12362. 

  12362.     { soap->error = SOAP_NO_TAG;
    12363. 

  12363.       return NULL;
    12364. 

  12364.     }
    12365. 

  12365.   }
    12366. 

  12366.   else if (tag && *tag == '-')
    12367. 

  12367.   { soap->error = SOAP_NO_TAG;
    12368. 

  12368.     return NULL;
    12369. 

  12369.   }
    12370. 

  12370.   else if (!*soap->href && minlen > 0)
    12371. 

  12371.   { soap->error = SOAP_LENGTH;
    12372. 

  12372.     return NULL;
    12373. 

  12373.   }
    12374. 

  12374.   else
    12375. 

  12375.     *p = soap_strdup(soap, SOAP_STR_EOS);
    12376. 

  12376.   if (*soap->href)
    12377. 

  12377.     p = (char**)soap_id_lookup(soap, soap->href, (void**)p, t, sizeof(char**), 0);
    12378. 

  12378.   if (soap->body && soap_element_end_in(soap, tag))
    12379. 

  12379.     return NULL;
    12380. 

  12380.   return p;
    12381. 

  12381. }
    12382. 

  12382. #endif
    12383. 

  12383. 

  12384. /******************************************************************************/
    12385. 

  12385. #ifndef WITH_LEANER
    12386. 

  12386. #ifndef PALM_2
    12387. 

  12387. SOAP_FMAC1
    12388. 

  12388. int
    12389. 

  12389. SOAP_FMAC2
    12390. 

  12390. soap_outwstring(struct soap *soap, const char *tag, int id, wchar_t *const*p, const char *type, int n) 
    12391. 

  12391. { id = soap_element_id(soap, tag, id, *p, NULL, 0, type, n);
    12392. 

  12392.   if (id < 0)
    12393. 

  12393.     return soap->error;
    12394. 

  12394.   if (!**p && (soap->mode & SOAP_C_NILSTRING))
    12395. 

  12395.     return soap_element_null(soap, tag, id, type);
    12396. 

  12396.   if (soap_element_begin_out(soap, tag, id, type)
    12397. 

  12397.    || soap_wstring_out(soap, *p, 0)
    12398. 

  12398.    || soap_element_end_out(soap, tag))
    12399. 

  12399.     return soap->error;
    12400. 

  12400.   return SOAP_OK;
    12401. 

  12401. }
    12402. 

  12402. #endif
    12403. 

  12403. #endif
    12404. 

  12404. 

  12405. /******************************************************************************/
    12406. 

  12406. #ifndef WITH_LEANER
    12407. 

  12407. #ifndef PALM_2
    12408. 

  12408. SOAP_FMAC1
    12409. 

  12409. wchar_t **
    12410. 

  12410. SOAP_FMAC2
    12411. 

  12411. soap_inwstring(struct soap *soap, const char *tag, wchar_t **p, const char *type, int t, long minlen, long maxlen)
    12412. 

  12412. { if (soap_element_begin_in(soap, tag, 1, NULL))
    12413. 

  12413.   { if (!tag || *tag != '-' || soap->error != SOAP_NO_TAG)
    12414. 

  12414.       return NULL;
    12415. 

  12415.     soap->error = SOAP_OK;
    12416. 

  12416.   }
    12417. 

  12417.   if (!p)
    12418. 

  12418.   { if (!(p = (wchar_t**)soap_malloc(soap, sizeof(wchar_t*))))
    12419. 

  12419.       return NULL;
    12420. 

  12420.   }
    12421. 

  12421.   if (soap->body)
    12422. 

  12422.   { *p = soap_wstring_in(soap, 1, minlen, maxlen);
    12423. 

  12423.     if (!*p || !(wchar_t*)soap_id_enter(soap, soap->id, *p, t, sizeof(wchar_t*), 0, NULL, NULL, NULL))
    12424. 

  12424.       return NULL;
    12425. 

  12425.     if (!**p && tag && *tag == '-')
    12426. 

  12426.     { soap->error = SOAP_NO_TAG;
    12427. 

  12427.       return NULL;
    12428. 

  12428.     }
    12429. 

  12429.   }
    12430. 

  12430.   else if (tag && *tag == '-')
    12431. 

  12431.   { soap->error = SOAP_NO_TAG;
    12432. 

  12432.     return NULL;
    12433. 

  12433.   }
    12434. 

  12434.   else if (soap->null)
    12435. 

  12435.     *p = NULL;
    12436. 

  12436.   else
    12437. 

  12437.     *p = soap_wstrdup(soap, (wchar_t*)SOAP_STR_EOS);
    12438. 

  12438.   if (*soap->href)
    12439. 

  12439.     p = (wchar_t**)soap_id_lookup(soap, soap->href, (void**)p, t, sizeof(wchar_t**), 0);
    12440. 

  12440.   if (soap->body && soap_element_end_in(soap, tag))
    12441. 

  12441.     return NULL;
    12442. 

  12442.   return p;
    12443. 

  12443. }
    12444. 

  12444. #endif
    12445. 

  12445. #endif
    12446. 

  12446. 

  12447. /******************************************************************************/
    12448. 

  12448. #ifndef WITH_LEAN
    12449. 

  12449. SOAP_FMAC1
    12450. 

  12450. time_t
    12451. 

  12451. SOAP_FMAC2
    12452. 

  12452. soap_timegm(struct tm *T)
    12453. 

  12453. {
    12454. 

  12454. #if defined(HAVE_TIMEGM)
    12455. 

  12455.   return timegm(T);
    12456. 

  12456. #else
    12457. 

  12457.   time_t t, g, z;
    12458. 

  12458.   struct tm tm;
    12459. 

  12459.   t = mktime(T);
    12460. 

  12460.   if (t == (time_t)-1)
    12461. 

  12461.     return (time_t)-1;
    12462. 

  12462. #ifdef HAVE_GMTIME_R
    12463. 

  12463.   gmtime_r(&t, &tm);
    12464. 

  12464. #else
    12465. 

  12465.   tm = *gmtime(&t);
    12466. 

  12466. #endif
    12467. 

  12467.   tm.tm_isdst = 0;
    12468. 

  12468.   g = mktime(&tm);
    12469. 

  12469.   if (g == (time_t)-1)
    12470. 

  12470.     return (time_t)-1;
    12471. 

  12471.   z = g - t;
    12472. 

  12472.   return t - z;
    12473. 

  12473. #endif
    12474. 

  12474. }
    12475. 

  12475. #endif
    12476. 

  12476. 

  12477. /******************************************************************************/
    12478. 

  12478. #ifndef WITH_LEAN
    12479. 

  12479. SOAP_FMAC1
    12480. 

  12480. const char*
    12481. 

  12481. SOAP_FMAC2
    12482. 

  12482. soap_dateTime2s(struct soap *soap, time_t n)
    12483. 

  12483. { struct tm T, *pT = &T;
    12484. 

  12484. #if defined(HAVE_GMTIME_R)
    12485. 

  12485.   if (gmtime_r(&n, pT))
    12486. 

  12486.     strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%SZ", pT);
    12487. 

  12487. #elif defined(HAVE_GMTIME)
    12488. 

  12488.   if ((pT = gmtime(&n)))
    12489. 

  12489.     strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%SZ", pT);
    12490. 

  12490. #elif defined(HAVE_GETTIMEOFDAY)
    12491. 

  12491.   struct timezone tz;
    12492. 

  12492.   memset((void*)&tz, 0, sizeof(tz));
    12493. 

  12493. #if defined(HAVE_LOCALTIME_R)
    12494. 

  12494.   if (localtime_r(&n, pT))
    12495. 

  12495.   { struct timeval tv;
    12496. 

  12496.     gettimeofday(&tv, &tz);
    12497. 

  12497.     strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT);
    12498. 

  12498.     sprintf(soap->tmpbuf + strlen(soap->tmpbuf), "%+03d:%02d", -tz.tz_minuteswest/60+(pT->tm_isdst!=0), abs(tz.tz_minuteswest)%60);
    12499. 

  12499.   }
    12500. 

  12500. #else
    12501. 

  12501.   if ((pT = localtime(&n)))
    12502. 

  12502.   { struct timeval tv;
    12503. 

  12503.     gettimeofday(&tv, &tz);
    12504. 

  12504.     strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT);
    12505. 

  12505.     sprintf(soap->tmpbuf + strlen(soap->tmpbuf), "%+03d:%02d", -tz.tz_minuteswest/60+(pT->tm_isdst!=0), abs(tz.tz_minuteswest)%60);
    12506. 

  12506.   }
    12507. 

  12507. #endif
    12508. 

  12508. #elif defined(HAVE_FTIME)
    12509. 

  12509.   struct timeb t;
    12510. 

  12510.   memset((void*)&t, 0, sizeof(t));
    12511. 

  12511. #if defined(HAVE_LOCALTIME_R)
    12512. 

  12512.   if (localtime_r(&n, pT))
    12513. 

  12513.   {
    12514. 

  12514. #ifdef __BORLANDC__
    12515. 

  12515.     ::ftime(&t);
    12516. 

  12516. #else
    12517. 

  12517.     ftime(&t);
    12518. 

  12518. #endif
    12519. 

  12519.     strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT);
    12520. 

  12520.     sprintf(soap->tmpbuf + strlen(soap->tmpbuf), "%+03d:%02d", -t.timezone/60+(pT->tm_isdst!=0), abs(t.timezone)%60);
    12521. 

  12521.   }
    12522. 

  12522. #else
    12523. 

  12523.   if ((pT = localtime(&n)))
    12524. 

  12524.   {
    12525. 

  12525. #ifdef __BORLANDC__
    12526. 

  12526.     ::ftime(&t);
    12527. 

  12527. #else
    12528. 

  12528.     ftime(&t);
    12529. 

  12529. #endif
    12530. 

  12530.     strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT);
    12531. 

  12531.     sprintf(soap->tmpbuf + strlen(soap->tmpbuf), "%+03d:%02d", -t.timezone/60+(pT->tm_isdst!=0), abs(t.timezone)%60);
    12532. 

  12532.   }
    12533. 

  12533. #endif
    12534. 

  12534. #elif defined(HAVE_LOCALTIME_R)
    12535. 

  12535.   if (localtime_r(&n, pT))
    12536. 

  12536.     strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT);
    12537. 

  12537. #else
    12538. 

  12538.   if ((pT = localtime(&n)))
    12539. 

  12539.     strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT);
    12540. 

  12540. #endif
    12541. 

  12541.   else
    12542. 

  12542.     strcpy(soap->tmpbuf, "1969-12-31T23:59:59Z");
    12543. 

  12543.   return soap->tmpbuf;
    12544. 

  12544. }
    12545. 

  12545. #endif
    12546. 

  12546. 

  12547. /******************************************************************************/
    12548. 

  12548. #ifndef WITH_LEAN
    12549. 

  12549. SOAP_FMAC1
    12550. 

  12550. int
    12551. 

  12551. SOAP_FMAC2
    12552. 

  12552. soap_outdateTime(struct soap *soap, const char *tag, int id, const time_t *p, const char *type, int n)
    12553. 

  12553. { if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type)
    12554. 

  12554.    || soap_string_out(soap, soap_dateTime2s(soap, *p), 0))
    12555. 

  12555.     return soap->error;
    12556. 

  12556.   return soap_element_end_out(soap, tag);
    12557. 

  12557. }
    12558. 

  12558. #endif
    12559. 

  12559. 

  12560. /******************************************************************************/
    12561. 

  12561. #ifndef WITH_LEAN
    12562. 

  12562. SOAP_FMAC1
    12563. 

  12563. int
    12564. 

  12564. SOAP_FMAC2
    12565. 

  12565. soap_s2dateTime(struct soap *soap, const char *s, time_t *p)
    12566. 

  12566. { if (s)
    12567. 

  12567.   { char zone[32];
    12568. 

  12568.     struct tm T;
    12569. 

  12569.     const char *t;
    12570. 

  12570.     *zone = '\0';
    12571. 

  12571.     memset((void*)&T, 0, sizeof(T));
    12572. 

  12572.     if (strchr(s, '-'))
    12573. 

  12573.       t = "%d-%d-%dT%d:%d:%d%31s";
    12574. 

  12574.     else if (strchr(s, ':'))
    12575. 

  12575.       t = "%4d%2d%2dT%d:%d:%d%31s";
    12576. 

  12576.     else /* parse non-XSD-standard alternative ISO 8601 format */
    12577. 

  12577.       t = "%4d%2d%2dT%2d%2d%2d%31s";
    12578. 

  12578.     if (sscanf(s, t, &T.tm_year, &T.tm_mon, &T.tm_mday, &T.tm_hour, &T.tm_min, &T.tm_sec, zone) < 6)
    12579. 

  12579.       return soap->error = SOAP_TYPE;
    12580. 

  12580.     if (T.tm_year == 1)
    12581. 

  12581.       T.tm_year = 70;
    12582. 

  12582.     else
    12583. 

  12583.       T.tm_year -= 1900;
    12584. 

  12584.     T.tm_mon--;
    12585. 

  12585.     if (*zone == '.')
    12586. 

  12586.     { for (s = zone + 1; *s; s++)
    12587. 

  12587.         if (*s < '0' || *s > '9')
    12588. 

  12588.           break;
    12589. 

  12589.     }
    12590. 

  12590.     else
    12591. 

  12591.       s = zone;
    12592. 

  12592.     if (*s)
    12593. 

  12593.     {
    12594. 

  12594. #ifndef WITH_NOZONE
    12595. 

  12595.       if (*s == '+' || *s == '-')
    12596. 

  12596.       { int h = 0, m = 0;
    12597. 

  12597.         if (s[3] == ':')
    12598. 

  12598.         { /* +hh:mm */
    12599. 

  12599. 	  sscanf(s, "%d:%d", &h, &m);
    12600. 

  12600.           if (h < 0)
    12601. 

  12601.             m = -m;
    12602. 

  12602.         }
    12603. 

  12603.         else /* +hhmm */
    12604. 

  12604.         { m = (int)soap_strtol(s, NULL, 10);
    12605. 

  12605.           h = m / 100;
    12606. 

  12606.           m = m % 100;
    12607. 

  12607.         }
    12608. 

  12608. 	T.tm_min -= m;
    12609. 

  12609. 	T.tm_hour -= h;
    12610. 

  12610. 	/* put hour and min in range */
    12611. 

  12611.         T.tm_hour += T.tm_min / 60;
    12612. 

  12612.         T.tm_min %= 60;
    12613. 

  12613.         if (T.tm_min < 0)
    12614. 

  12614.         { T.tm_min += 60;
    12615. 

  12615. 	  T.tm_hour--;
    12616. 

  12616. 	}
    12617. 

  12617.         T.tm_mday += T.tm_hour / 24;
    12618. 

  12618.         T.tm_hour %= 24;
    12619. 

  12619.         if (T.tm_hour < 0)
    12620. 

  12620.         { T.tm_hour += 24;
    12621. 

  12621.           T.tm_mday--;
    12622. 

  12622. 	}
    12623. 

  12623. 	/* note: day of the month may be out of range, timegm() handles it */
    12624. 

  12624.       }
    12625. 

  12625. #endif
    12626. 

  12626.       *p = soap_timegm(&T);
    12627. 

  12627.     }
    12628. 

  12628.     else /* no UTC or timezone, so assume we got a localtime */
    12629. 

  12629.     { T.tm_isdst = -1;
    12630. 

  12630.       *p = mktime(&T);
    12631. 

  12631.     }
    12632. 

  12632.   }
    12633. 

  12633.   return soap->error;
    12634. 

  12634. }
    12635. 

  12635. #endif
    12636. 

  12636. 

  12637. /******************************************************************************/
    12638. 

  12638. #ifndef WITH_LEAN
    12639. 

  12639. SOAP_FMAC1
    12640. 

  12640. time_t *
    12641. 

  12641. SOAP_FMAC2
    12642. 

  12642. soap_indateTime(struct soap *soap, const char *tag, time_t *p, const char *type, int t)
    12643. 

  12643. { if (soap_element_begin_in(soap, tag, 0, NULL))
    12644. 

  12644.     return NULL;
    12645. 

  12645.   if (*soap->type
    12646. 

  12646.    && soap_match_tag(soap, soap->type, type)
    12647. 

  12647.    && soap_match_tag(soap, soap->type, ":dateTime"))
    12648. 

  12648.   { soap->error = SOAP_TYPE;
    12649. 

  12649.     soap_revert(soap);
    12650. 

  12650.     return NULL;
    12651. 

  12651.   }
    12652. 

  12652.   p = (time_t*)soap_id_enter(soap, soap->id, p, t, sizeof(time_t), 0, NULL, NULL, NULL);
    12653. 

  12653.   if (*soap->href)
    12654. 

  12654.     p = (time_t*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(time_t), 0, NULL);
    12655. 

  12655.   else if (p)
    12656. 

  12656.   { if (soap_s2dateTime(soap, soap_value(soap), p))
    12657. 

  12657.       return NULL;
    12658. 

  12658.   }
    12659. 

  12659.   if (soap->body && soap_element_end_in(soap, tag))
    12660. 

  12660.     return NULL;
    12661. 

  12661.   return p;
    12662. 

  12662. }
    12663. 

  12663. #endif
    12664. 

  12664. 

  12665. /******************************************************************************/
    12666. 

  12666. #ifndef PALM_2
    12667. 

  12667. SOAP_FMAC1
    12668. 

  12668. int
    12669. 

  12669. SOAP_FMAC2
    12670. 

  12670. soap_outliteral(struct soap *soap, const char *tag, char *const*p, const char *type)
    12671. 

  12671. { int i;
    12672. 

  12672.   const char *t = NULL;
    12673. 

  12673.   if (tag && *tag != '-')
    12674. 

  12674.   { if (soap->local_namespaces && (t = strchr(tag, ':')))
    12675. 

  12675.     { strncpy(soap->tmpbuf, tag, t-tag);
    12676. 

  12676.       soap->tmpbuf[t-tag] = '\0';
    12677. 

  12677.       for (i = 0; soap->local_namespaces[i].id; i++)
    12678. 

  12678.         if (!strcmp(soap->tmpbuf, soap->local_namespaces[i].id))
    12679. 

  12679.           break;
    12680. 

  12680.       t++;
    12681. 

  12681.       if (soap_element(soap, t, 0, type)
    12682. 

  12682.        || soap_attribute(soap, "xmlns", soap->local_namespaces[i].ns ? soap->local_namespaces[i].ns : SOAP_STR_EOS)
    12683. 

  12683.        || soap_element_start_end_out(soap, NULL))
    12684. 

  12684.         return soap->error;
    12685. 

  12685.     }
    12686. 

  12686.     else
    12687. 

  12687.     { t = tag;
    12688. 

  12688.       if (soap_element_begin_out(soap, t, 0, type))
    12689. 

  12689.         return soap->error;
    12690. 

  12690.     }
    12691. 

  12691.   }
    12692. 

  12692.   if (p && *p)
    12693. 

  12693.   { if (soap_send(soap, *p))
    12694. 

  12694.       return soap->error;
    12695. 

  12695.   }
    12696. 

  12696.   if (t)
    12697. 

  12697.     return soap_element_end_out(soap, t);
    12698. 

  12698.   return SOAP_OK;
    12699. 

  12699. }
    12700. 

  12700. #endif
    12701. 

  12701. 

  12702. /******************************************************************************/
    12703. 

  12703. #ifndef PALM_2
    12704. 

  12704. SOAP_FMAC1
    12705. 

  12705. char **
    12706. 

  12706. SOAP_FMAC2
    12707. 

  12707. soap_inliteral(struct soap *soap, const char *tag, char **p)
    12708. 

  12708. { if (soap_element_begin_in(soap, tag, 1, NULL))
    12709. 

  12709.   { if (soap->error != SOAP_NO_TAG || soap_unget(soap, soap_get(soap)) == SOAP_TT)
    12710. 

  12710.       return NULL;
    12711. 

  12711.     soap->error = SOAP_OK;
    12712. 

  12712.   }
    12713. 

  12713.   if (!p)
    12714. 

  12714.   { if (!(p = (char**)soap_malloc(soap, sizeof(char*))))
    12715. 

  12715.       return NULL;
    12716. 

  12716.   }
    12717. 

  12717.   if (soap->body || (tag && *tag == '-'))
    12718. 

  12718.   { *p = soap_string_in(soap, 0, -1, -1);
    12719. 

  12719.     if (!*p)
    12720. 

  12720.       return NULL;
    12721. 

  12721.     if (!**p && tag && *tag == '-')
    12722. 

  12722.     { soap->error = SOAP_NO_TAG;
    12723. 

  12723.       return NULL;
    12724. 

  12724.     }
    12725. 

  12725.   }
    12726. 

  12726.   else if (soap->null)
    12727. 

  12727.     *p = NULL;
    12728. 

  12728.   else
    12729. 

  12729.     *p = soap_strdup(soap, SOAP_STR_EOS);
    12730. 

  12730.   if (soap->body && soap_element_end_in(soap, tag))
    12731. 

  12731.     return NULL;
    12732. 

  12732.   return p;
    12733. 

  12733. }
    12734. 

  12734. #endif
    12735. 

  12735. 

  12736. /******************************************************************************/
    12737. 

  12737. #ifndef WITH_LEANER
    12738. 

  12738. #ifndef PALM_2
    12739. 

  12739. SOAP_FMAC1
    12740. 

  12740. int
    12741. 

  12741. SOAP_FMAC2
    12742. 

  12742. soap_outwliteral(struct soap *soap, const char *tag, wchar_t *const*p, const char *type)
    12743. 

  12743. { int i;
    12744. 

  12744.   const char *t = NULL;
    12745. 

  12745.   if (tag && *tag != '-')
    12746. 

  12746.   { if (soap->local_namespaces && (t = strchr(tag, ':')))
    12747. 

  12747.     { strncpy(soap->tmpbuf, tag, t-tag);
    12748. 

  12748.       soap->tmpbuf[t-tag] = '\0';
    12749. 

  12749.       for (i = 0; soap->local_namespaces[i].id; i++)
    12750. 

  12750.         if (!strcmp(soap->tmpbuf, soap->local_namespaces[i].id))
    12751. 

  12751.           break;
    12752. 

  12752.       t++;
    12753. 

  12753.       if (soap_element(soap, t, 0, type)
    12754. 

  12754.        || soap_attribute(soap, "xmlns", soap->local_namespaces[i].ns ? soap->local_namespaces[i].ns : SOAP_STR_EOS)
    12755. 

  12755.        || soap_element_start_end_out(soap, NULL))
    12756. 

  12756.         return soap->error;
    12757. 

  12757.     }
    12758. 

  12758.     else
    12759. 

  12759.     { t = tag;
    12760. 

  12760.       if (soap_element_begin_out(soap, t, 0, type))
    12761. 

  12761.         return soap->error;
    12762. 

  12762.     }
    12763. 

  12763.     if (soap_send(soap, soap->tmpbuf))
    12764. 

  12764.       return soap->error;
    12765. 

  12765.   }
    12766. 

  12766.   if (p)
    12767. 

  12767.   { wchar_t c;
    12768. 

  12768.     const wchar_t *s = *p;
    12769. 

  12769.     while ((c = *s++))
    12770. 

  12770.     { if (soap_pututf8(soap, (unsigned long)c))
    12771. 

  12771.         return soap->error;
    12772. 

  12772.     }
    12773. 

  12773.   }
    12774. 

  12774.   if (t)
    12775. 

  12775.     return soap_element_end_out(soap, t);
    12776. 

  12776.   return SOAP_OK;
    12777. 

  12777. }
    12778. 

  12778. #endif
    12779. 

  12779. #endif
    12780. 

  12780. 

  12781. /******************************************************************************/
    12782. 

  12782. #ifndef WITH_LEANER
    12783. 

  12783. #ifndef PALM_2
    12784. 

  12784. SOAP_FMAC1
    12785. 

  12785. wchar_t **
    12786. 

  12786. SOAP_FMAC2
    12787. 

  12787. soap_inwliteral(struct soap *soap, const char *tag, wchar_t **p)
    12788. 

  12788. { if (soap_element_begin_in(soap, tag, 1, NULL))
    12789. 

  12789.   { if (soap->error != SOAP_NO_TAG || soap_unget(soap, soap_get(soap)) == SOAP_TT)
    12790. 

  12790.       return NULL;
    12791. 

  12791.     soap->error = SOAP_OK;
    12792. 

  12792.   }
    12793. 

  12793.   if (!p)
    12794. 

  12794.   { if (!(p = (wchar_t**)soap_malloc(soap, sizeof(wchar_t*))))
    12795. 

  12795.       return NULL;
    12796. 

  12796.   }
    12797. 

  12797.   if (soap->body)
    12798. 

  12798.   { *p = soap_wstring_in(soap, 0, -1, -1);
    12799. 

  12799.     if (!*p)
    12800. 

  12800.       return NULL;
    12801. 

  12801.     if (!**p && tag && *tag == '-')
    12802. 

  12802.     { soap->error = SOAP_NO_TAG;
    12803. 

  12803.       return NULL;
    12804. 

  12804.     }
    12805. 

  12805.   }
    12806. 

  12806.   else if (tag && *tag == '-')
    12807. 

  12807.   { soap->error = SOAP_NO_TAG;
    12808. 

  12808.     return NULL;
    12809. 

  12809.   }
    12810. 

  12810.   else if (soap->null)
    12811. 

  12811.     *p = NULL;
    12812. 

  12812.   else
    12813. 

  12813.     *p = soap_wstrdup(soap, (wchar_t*)SOAP_STR_EOS);
    12814. 

  12814.   if (soap->body && soap_element_end_in(soap, tag))
    12815. 

  12815.     return NULL;
    12816. 

  12816.   return p;
    12817. 

  12817. }
    12818. 

  12818. #endif
    12819. 

  12819. #endif
    12820. 

  12820. 

  12821. /******************************************************************************/
    12822. 

  12822. #ifndef PALM_2
    12823. 

  12823. SOAP_FMAC1
    12824. 

  12824. const char *
    12825. 

  12825. SOAP_FMAC2
    12826. 

  12826. soap_value(struct soap *soap)
    12827. 

  12827. { register size_t i;
    12828. 

  12828.   register soap_wchar c = 0;
    12829. 

  12829.   register char *s = soap->tmpbuf;
    12830. 

  12830.   if (!soap->body)
    12831. 

  12831.     return SOAP_STR_EOS;
    12832. 

  12832.   do c = soap_get(soap);
    12833. 

  12833.   while (soap_blank(c));
    12834. 

  12834.   for (i = 0; i < sizeof(soap->tmpbuf) - 1; i++)
    12835. 

  12835.   { if (c == SOAP_TT || c == SOAP_LT || (int)c == EOF)
    12836. 

  12836.       break;
    12837. 

  12837.     *s++ = (char)c;
    12838. 

  12838.     c = soap_get(soap);
    12839. 

  12839.   }
    12840. 

  12840.   for (s--; i > 0; i--, s--)
    12841. 

  12841.   { if (!soap_blank(*s))
    12842. 

  12842.       break;
    12843. 

  12843.   }
    12844. 

  12844.   s[1] = '\0';
    12845. 

  12845.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Element content value='%s'\n", soap->tmpbuf));
    12846. 

  12846.   if (c == SOAP_TT || c == SOAP_LT || (int)c == EOF)
    12847. 

  12847.     soap_unget(soap, c);
    12848. 

  12848.   else if (soap->mode & SOAP_XML_STRICT)
    12849. 

  12849.   { soap->error = SOAP_LENGTH;
    12850. 

  12850.     return NULL;
    12851. 

  12851.   }
    12852. 

  12852. #ifdef WITH_DOM
    12853. 

  12853.   if ((soap->mode & SOAP_XML_DOM) && soap->dom)
    12854. 

  12854.     soap->dom->data = soap_strdup(soap, soap->tmpbuf);
    12855. 

  12855. #endif
    12856. 

  12856.   return soap->tmpbuf; /* return non-null pointer */
    12857. 

  12857. }
    12858. 

  12858. #endif
    12859. 

  12859. 

  12860. /******************************************************************************/
    12861. 

  12861. #if !defined(WITH_LEANER) || !defined(WITH_NOHTTP)
    12862. 

  12862. #ifndef PALM_2
    12863. 

  12863. SOAP_FMAC1
    12864. 

  12864. int
    12865. 

  12865. SOAP_FMAC2
    12866. 

  12866. soap_getline(struct soap *soap, char *s, int len)
    12867. 

  12867. { int i = len;
    12868. 

  12868.   soap_wchar c = 0;
    12869. 

  12869.   for (;;)
    12870. 

  12870.   { while (--i > 0)
    12871. 

  12871.     { c = soap_getchar(soap);
    12872. 

  12872.       if (c == '\r' || c == '\n')
    12873. 

  12873.         break;
    12874. 

  12874.       if ((int)c == EOF)
    12875. 

  12875.         return soap->error = SOAP_EOF;
    12876. 

  12876.       *s++ = (char)c;
    12877. 

  12877.     }
    12878. 

  12878.     if (c != '\n')
    12879. 

  12879.       c = soap_getchar(soap); /* got \r or something else, now get \n */
    12880. 

  12880.     if (c == '\n')
    12881. 

  12881.     { *s = '\0';
    12882. 

  12882.       if (i+1 == len) /* empty line: end of HTTP/MIME header */
    12883. 

  12883.         break;
    12884. 

  12884.       c = soap_get0(soap);
    12885. 

  12885.       if (c != ' ' && c != '\t') /* HTTP line continuation? */
    12886. 

  12886.         break;
    12887. 

  12887.     }
    12888. 

  12888.     else if ((int)c == EOF)
    12889. 

  12889.       return soap->error = SOAP_EOF;
    12890. 

  12890.     if (i < 0)
    12891. 

  12891.       return soap->error = SOAP_HDR;
    12892. 

  12892.   }
    12893. 

  12893.   return SOAP_OK;
    12894. 

  12894. }
    12895. 

  12895. #endif
    12896. 

  12896. #endif
    12897. 

  12897. 

  12898. /******************************************************************************/
    12899. 

  12899. #ifndef PALM_1
    12900. 

  12900. static size_t
    12901. 

  12901. soap_count_attachments(struct soap *soap)
    12902. 

  12902. { 
    12903. 

  12903. #ifndef WITH_LEANER
    12904. 

  12904.   register struct soap_multipart *content;
    12905. 

  12905.   register size_t count = soap->count;
    12906. 

  12906.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Calculating the message size with attachments, current count=%lu\n", (unsigned long)count));
    12907. 

  12907.   if ((soap->mode & SOAP_ENC_DIME) && !(soap->mode & SOAP_ENC_MTOM))
    12908. 

  12908.   { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Calculating the size of DIME attachments\n"));
    12909. 

  12909.     for (content = soap->dime.first; content; content = content->next)
    12910. 

  12910.     { count += 12 + ((content->size+3)&(~3));
    12911. 

  12911.       if (content->id)
    12912. 

  12912.         count += ((strlen(content->id)+3)&(~3));
    12913. 

  12913.       if (content->type)
    12914. 

  12914.         count += ((strlen(content->type)+3)&(~3));
    12915. 

  12915.       if (content->options)
    12916. 

  12916.         count += ((((unsigned char)content->options[2] << 8) | ((unsigned char)content->options[3]))+7)&(~3);
    12917. 

  12917.       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Size of DIME attachment content is %lu bytes\n", (unsigned long)content->size));
    12918. 

  12918.     }
    12919. 

  12919.   }
    12920. 

  12920.   if ((soap->mode & SOAP_ENC_MIME) && soap->mime.boundary)
    12921. 

  12921.   { register size_t n = strlen(soap->mime.boundary);
    12922. 

  12922.     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Calculating the size of MIME attachments\n"));
    12923. 

  12923.     for (content = soap->mime.first; content; content = content->next)
    12924. 

  12924.     { register const char *s;
    12925. 

  12925.       /* count \r\n--boundary\r\n */
    12926. 

  12926.       count += 6 + n;
    12927. 

  12927.       /* count Content-Type: ...\r\n */
    12928. 

  12928.       if (content->type)
    12929. 

  12929.         count += 16 + strlen(content->type);
    12930. 

  12930.       /* count Content-Transfer-Encoding: ...\r\n */
    12931. 

  12931.       s = soap_code_str(mime_codes, content->encoding);
    12932. 

  12932.       if (s)
    12933. 

  12933.         count += 29 + strlen(s);
    12934. 

  12934.       /* count Content-ID: ...\r\n */
    12935. 

  12935.       if (content->id)
    12936. 

  12936.         count += 14 + strlen(content->id);
    12937. 

  12937.       /* count Content-Location: ...\r\n */
    12938. 

  12938.       if (content->location)
    12939. 

  12939.         count += 20 + strlen(content->location);
    12940. 

  12940.       /* count Content-Description: ...\r\n */
    12941. 

  12941.       if (content->description)
    12942. 

  12942.         count += 23 + strlen(content->description);
    12943. 

  12943.       /* count \r\n...content */
    12944. 

  12944.       count += 2 + content->size;
    12945. 

  12945.       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Size of MIME attachment content is %lu bytes\n", (unsigned long)content->size));
    12946. 

  12946.     }
    12947. 

  12947.     /* count \r\n--boundary-- */
    12948. 

  12948.     count += 6 + n;
    12949. 

  12949.   }
    12950. 

  12950.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "New count is %lu bytes\n", (unsigned long)count));
    12951. 

  12951.   return count;
    12952. 

  12952. #else
    12953. 

  12953.   return soap->count;
    12954. 

  12954. #endif
    12955. 

  12955. }
    12956. 

  12956. #endif
    12957. 

  12957. 

  12958. /******************************************************************************/
    12959. 

  12959. #ifndef WITH_LEANER
    12960. 

  12960. #ifndef PALM_1
    12961. 

  12961. static int
    12962. 

  12962. soap_putdimefield(struct soap *soap, const char *s, size_t n)
    12963. 

  12963. { if (soap_send_raw(soap, s, n))
    12964. 

  12964.     return soap->error;
    12965. 

  12965.   return soap_send_raw(soap, SOAP_STR_PADDING, -(long)n&3);
    12966. 

  12966. }
    12967. 

  12967. #endif
    12968. 

  12968. #endif
    12969. 

  12969. 

  12970. /******************************************************************************/
    12971. 

  12971. #ifndef WITH_LEANER
    12972. 

  12972. #ifndef PALM_1
    12973. 

  12973. SOAP_FMAC1
    12974. 

  12974. char *
    12975. 

  12975. SOAP_FMAC2
    12976. 

  12976. soap_dime_option(struct soap *soap, unsigned short optype, const char *option)
    12977. 

  12977. { size_t n;
    12978. 

  12978.   char *s = NULL;
    12979. 

  12979.   if (option)
    12980. 

  12980.   { n = strlen(option);
    12981. 

  12981.     s = (char*)soap_malloc(soap, n + 5);
    12982. 

  12982.     if (s)
    12983. 

  12983.     { s[0] = (char)(optype >> 8);
    12984. 

  12984.       s[1] = (char)(optype & 0xFF);
    12985. 

  12985.       s[2] = (char)(n >> 8);
    12986. 

  12986.       s[3] = (char)(n & 0xFF);
    12987. 

  12987.       strcpy(s + 4, option);
    12988. 

  12988.     }
    12989. 

  12989.   }
    12990. 

  12990.   return s;
    12991. 

  12991. }
    12992. 

  12992. #endif
    12993. 

  12993. #endif
    12994. 

  12994. 

  12995. /******************************************************************************/
    12996. 

  12996. #ifndef WITH_LEANER
    12997. 

  12997. #ifndef PALM_1
    12998. 

  12998. SOAP_FMAC1
    12999. 

  12999. int
    13000. 

  13000. SOAP_FMAC2
    13001. 

  13001. soap_putdimehdr(struct soap *soap)
    13002. 

  13002. { unsigned char tmp[12];
    13003. 

  13003.   size_t optlen = 0, idlen = 0, typelen = 0;
    13004. 

  13004.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Put DIME header id='%s'\n", soap->dime.id?soap->dime.id:SOAP_STR_EOS));
    13005. 

  13005.   if (soap->dime.options)
    13006. 

  13006.     optlen = (((unsigned char)soap->dime.options[2] << 8) | ((unsigned char)soap->dime.options[3])) + 4;
    13007. 

  13007.   if (soap->dime.id)
    13008. 

  13008.   { idlen = strlen(soap->dime.id);
    13009. 

  13009.     if (idlen > 0x0000FFFF)
    13010. 

  13010.       idlen = 0x0000FFFF;
    13011. 

  13011.   }
    13012. 

  13012.   if (soap->dime.type)
    13013. 

  13013.   { typelen = strlen(soap->dime.type);
    13014. 

  13014.     if (typelen > 0x0000FFFF)
    13015. 

  13015.       typelen = 0x0000FFFF;
    13016. 

  13016.   }
    13017. 

  13017.   tmp[0] = SOAP_DIME_VERSION | (soap->dime.flags & 0x7);
    13018. 

  13018.   tmp[1] = soap->dime.flags & 0xF0;
    13019. 

  13019.   tmp[2] = (char)(optlen >> 8);
    13020. 

  13020.   tmp[3] = (char)(optlen & 0xFF);
    13021. 

  13021.   tmp[4] = (char)(idlen >> 8);
    13022. 

  13022.   tmp[5] = (char)(idlen & 0xFF);
    13023. 

  13023.   tmp[6] = (char)(typelen >> 8);
    13024. 

  13024.   tmp[7] = (char)(typelen & 0xFF);
    13025. 

  13025.   tmp[8] = (char)(soap->dime.size >> 24);
    13026. 

  13026.   tmp[9] = (char)((soap->dime.size >> 16) & 0xFF);
    13027. 

  13027.   tmp[10] = (char)((soap->dime.size >> 8) & 0xFF);
    13028. 

  13028.   tmp[11] = (char)(soap->dime.size & 0xFF);
    13029. 

  13029.   if (soap_send_raw(soap, (char*)tmp, 12)
    13030. 

  13030.    || soap_putdimefield(soap, soap->dime.options, optlen)
    13031. 

  13031.    || soap_putdimefield(soap, soap->dime.id, idlen)
    13032. 

  13032.    || soap_putdimefield(soap, soap->dime.type, typelen))
    13033. 

  13033.     return soap->error;
    13034. 

  13034.   return SOAP_OK;
    13035. 

  13035. }
    13036. 

  13036. #endif
    13037. 

  13037. #endif
    13038. 

  13038. 

  13039. /******************************************************************************/
    13040. 

  13040. #ifndef WITH_LEANER
    13041. 

  13041. #ifndef PALM_1
    13042. 

  13042. SOAP_FMAC1
    13043. 

  13043. int
    13044. 

  13044. SOAP_FMAC2
    13045. 

  13045. soap_putdime(struct soap *soap)
    13046. 

  13046. { struct soap_multipart *content;
    13047. 

  13047.   if (!(soap->mode & SOAP_ENC_DIME))
    13048. 

  13048.     return SOAP_OK;
    13049. 

  13049.   for (content = soap->dime.first; content; content = content->next)
    13050. 

  13050.   { void *handle;
    13051. 

  13051.     soap->dime.size = content->size;
    13052. 

  13052.     soap->dime.id = content->id;
    13053. 

  13053.     soap->dime.type = content->type;
    13054. 

  13054.     soap->dime.options = content->options;
    13055. 

  13055.     soap->dime.flags = SOAP_DIME_VERSION | SOAP_DIME_MEDIA;
    13056. 

  13056.     if (soap->fdimereadopen && ((handle = soap->fdimereadopen(soap, (void*)content->ptr, content->id, content->type, content->options)) || soap->error))
    13057. 

  13057.     { size_t size = content->size;
    13058. 

  13058.       if (!handle)
    13059. 

  13059.       { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fdimereadopen failed\n"));
    13060. 

  13060.         return soap->error;
    13061. 

  13061.       }
    13062. 

  13062.       if (!size && ((soap->mode & SOAP_ENC_XML) || (soap->mode & SOAP_IO) == SOAP_IO_CHUNK || (soap->mode & SOAP_IO) == SOAP_IO_STORE))
    13063. 

  13063.       { size_t chunksize = sizeof(soap->tmpbuf);
    13064. 

  13064.         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Chunked streaming DIME\n"));
    13065. 

  13065.         do 
    13066. 

  13066.         { size = soap->fdimeread(soap, handle, soap->tmpbuf, chunksize);
    13067. 

  13067.           DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fdimeread returned %lu bytes\n", (unsigned long)size));
    13068. 

  13068.           if (size < chunksize)
    13069. 

  13069.           { soap->dime.flags &= ~SOAP_DIME_CF;
    13070. 

  13070.             if (!content->next)
    13071. 

  13071.               soap->dime.flags |= SOAP_DIME_ME;
    13072. 

  13072.           }
    13073. 

  13073.           else
    13074. 

  13074.             soap->dime.flags |= SOAP_DIME_CF;
    13075. 

  13075.           soap->dime.size = size;
    13076. 

  13076.           if (soap_putdimehdr(soap)
    13077. 

  13077.            || soap_putdimefield(soap, soap->tmpbuf, size))
    13078. 

  13078.             break;
    13079. 

  13079.           if (soap->dime.id)
    13080. 

  13080.           { soap->dime.flags &= ~(SOAP_DIME_MB | SOAP_DIME_MEDIA);
    13081. 

  13081.             soap->dime.id = NULL;
    13082. 

  13082.             soap->dime.type = NULL;
    13083. 

  13083.             soap->dime.options = NULL;
    13084. 

  13084.           }  
    13085. 

  13085.         } while (size >= chunksize);
    13086. 

  13086.       }
    13087. 

  13087.       else
    13088. 

  13088.       { if (!content->next)
    13089. 

  13089.           soap->dime.flags |= SOAP_DIME_ME;
    13090. 

  13090.         if (soap_putdimehdr(soap))
    13091. 

  13091.           return soap->error;
    13092. 

  13092.         do
    13093. 

  13093.         { size_t bufsize;
    13094. 

  13094.           if (size < sizeof(soap->tmpbuf))
    13095. 

  13095.             bufsize = size;
    13096. 

  13096.           else
    13097. 

  13097.             bufsize = sizeof(soap->tmpbuf);
    13098. 

  13098.           if (!(bufsize = soap->fdimeread(soap, handle, soap->tmpbuf, bufsize)))
    13099. 

  13099.           { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fdimeread failed: insufficient data (%lu bytes remaining from %lu bytes)\n", (unsigned long)size, (unsigned long)content->size));
    13100. 

  13100.             soap->error = SOAP_EOF;
    13101. 

  13101.             break;
    13102. 

  13102.           }
    13103. 

  13103.           if (soap_send_raw(soap, soap->tmpbuf, bufsize))
    13104. 

  13104.             break;
    13105. 

  13105.           size -= bufsize;
    13106. 

  13106.         } while (size);
    13107. 

  13107.         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fdimereadclose\n"));
    13108. 

  13108.         soap_send_raw(soap, SOAP_STR_PADDING, -(long)soap->dime.size&3);
    13109. 

  13109.       }
    13110. 

  13110.       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fdimereadclose\n"));
    13111. 

  13111.       if (soap->fdimereadclose)
    13112. 

  13112.         soap->fdimereadclose(soap, handle);
    13113. 

  13113.     }
    13114. 

  13114.     else
    13115. 

  13115.     { if (!content->next)
    13116. 

  13116.         soap->dime.flags |= SOAP_DIME_ME;
    13117. 

  13117.       if (soap_putdimehdr(soap)
    13118. 

  13118.        || soap_putdimefield(soap, (char*)content->ptr, content->size))
    13119. 

  13119.         return soap->error;
    13120. 

  13120.     }
    13121. 

  13121.   }
    13122. 

  13122.   return SOAP_OK;
    13123. 

  13123. }
    13124. 

  13124. #endif
    13125. 

  13125. #endif
    13126. 

  13126. 

  13127. /******************************************************************************/
    13128. 

  13128. #ifndef WITH_LEANER
    13129. 

  13129. #ifndef PALM_1
    13130. 

  13130. static char *
    13131. 

  13131. soap_getdimefield(struct soap *soap, size_t n)
    13132. 

  13132. { register soap_wchar c;
    13133. 

  13133.   register size_t i;
    13134. 

  13134.   register char *s;
    13135. 

  13135.   register char *p = NULL;
    13136. 

  13136.   if (n)
    13137. 

  13137.   { p = (char*)soap_malloc(soap, n + 1);
    13138. 

  13138.     if (p)
    13139. 

  13139.     { s = p;
    13140. 

  13140.       for (i = n; i > 0; i--)
    13141. 

  13141.       { if ((int)(c = soap_get1(soap)) == EOF)
    13142. 

  13142.         { soap->error = SOAP_EOF;
    13143. 

  13143.           return NULL;
    13144. 

  13144.         }
    13145. 

  13145.         *s++ = (char)c;
    13146. 

  13146.       }
    13147. 

  13147.       *s = '\0';
    13148. 

  13148.       if ((soap->error = soap_move(soap, -(long)n&3)))
    13149. 

  13149.         return NULL;
    13150. 

  13150.     }
    13151. 

  13151.     else
    13152. 

  13152.       soap->error = SOAP_EOM;
    13153. 

  13153.   }
    13154. 

  13154.   return p;
    13155. 

  13155. }
    13156. 

  13156. #endif
    13157. 

  13157. #endif
    13158. 

  13158. 

  13159. /******************************************************************************/
    13160. 

  13160. #ifndef WITH_LEANER
    13161. 

  13161. #ifndef PALM_1
    13162. 

  13162. SOAP_FMAC1
    13163. 

  13163. int
    13164. 

  13164. SOAP_FMAC2
    13165. 

  13165. soap_getdimehdr(struct soap *soap)
    13166. 

  13166. { register soap_wchar c;
    13167. 

  13167.   register char *s;
    13168. 

  13168.   register int i;
    13169. 

  13169.   unsigned char tmp[12];
    13170. 

  13170.   size_t optlen, idlen, typelen;
    13171. 

  13171.   if (!(soap->mode & SOAP_ENC_DIME))
    13172. 

  13172.     return soap->error = SOAP_DIME_END;
    13173. 

  13173.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Get DIME header\n"));
    13174. 

  13174.   if (soap->dime.buflen || soap->dime.chunksize)
    13175. 

  13175.   { if (soap_move(soap, (long)(soap->dime.size - soap_tell(soap))))
    13176. 

  13176.       return soap->error = SOAP_EOF;
    13177. 

  13177.     soap_unget(soap, soap_getchar(soap)); /* skip padding and get hdr */
    13178. 

  13178.     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "... From chunked\n"));
    13179. 

  13179.     return SOAP_OK;
    13180. 

  13180.   }
    13181. 

  13181.   s = (char*)tmp;
    13182. 

  13182.   for (i = 12; i > 0; i--)
    13183. 

  13183.   { if ((int)(c = soap_getchar(soap)) == EOF)
    13184. 

  13184.       return soap->error = SOAP_EOF;
    13185. 

  13185.     *s++ = (char)c;
    13186. 

  13186.   }
    13187. 

  13187.   if ((tmp[0] & 0xF8) != SOAP_DIME_VERSION)
    13188. 

  13188.     return soap->error = SOAP_DIME_MISMATCH;
    13189. 

  13189.   soap->dime.flags = (tmp[0] & 0x7) | (tmp[1] & 0xF0);
    13190. 

  13190.   optlen = (tmp[2] << 8) | tmp[3];
    13191. 

  13191.   idlen = (tmp[4] << 8) | tmp[5];
    13192. 

  13192.   typelen = (tmp[6] << 8) | tmp[7];
    13193. 

  13193.   soap->dime.size = (tmp[8] << 24) | (tmp[9] << 16) | (tmp[10] << 8) | tmp[11];
    13194. 

  13194.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "DIME size=%lu flags=0x%X\n", (unsigned long)soap->dime.size, soap->dime.flags));
    13195. 

  13195.   if (!(soap->dime.options = soap_getdimefield(soap, optlen)) && soap->error)
    13196. 

  13196.     return soap->error;
    13197. 

  13197.   if (!(soap->dime.id = soap_getdimefield(soap, idlen)) && soap->error)
    13198. 

  13198.     return soap->error;
    13199. 

  13199.   if (!(soap->dime.type = soap_getdimefield(soap, typelen)) && soap->error)
    13200. 

  13200.     return soap->error;
    13201. 

  13201.   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));
    13202. 

  13202.   if (soap->dime.flags & SOAP_DIME_ME)
    13203. 

  13203.     soap->mode &= ~SOAP_ENC_DIME;
    13204. 

  13204.   return SOAP_OK;
    13205. 

  13205. }
    13206. 

  13206. #endif
    13207. 

  13207. #endif
    13208. 

  13208. 

  13209. /******************************************************************************/
    13210. 

  13210. #ifndef WITH_LEANER
    13211. 

  13211. #ifndef PALM_1
    13212. 

  13212. SOAP_FMAC1
    13213. 

  13213. int
    13214. 

  13214. SOAP_FMAC2
    13215. 

  13215. soap_getdime(struct soap *soap)
    13216. 

  13216. { while (soap->dime.flags & SOAP_DIME_CF)
    13217. 

  13217.   { if (soap_getdimehdr(soap))
    13218. 

  13218.       return soap->error;
    13219. 

  13219.     if (soap_move(soap, (long)soap->dime.size))
    13220. 

  13220.       return soap->error = SOAP_EOF;
    13221. 

  13221.   }
    13222. 

  13222.   if (soap_move(soap, (long)(((soap->dime.size+3)&(~3))-soap_tell(soap))))
    13223. 

  13223.     return soap->error = SOAP_EOF;
    13224. 

  13224.   for (;;)
    13225. 

  13225.   { register struct soap_multipart *content;
    13226. 

  13226.     if (soap_getdimehdr(soap))
    13227. 

  13227.       break;
    13228. 

  13228.     if (soap->fdimewriteopen && ((soap->dime.ptr = (char*)soap->fdimewriteopen(soap, soap->dime.id, soap->dime.type, soap->dime.options)) || soap->error))
    13229. 

  13229.     { const char *id, *type, *options;
    13230. 

  13230.       size_t size, n;
    13231. 

  13231.       if (!soap->dime.ptr)
    13232. 

  13232.         return soap->error;
    13233. 

  13233.       id = soap->dime.id;
    13234. 

  13234.       type = soap->dime.type;
    13235. 

  13235.       options = soap->dime.options;
    13236. 

  13236.       for (;;)
    13237. 

  13237.       { size = soap->dime.size;
    13238. 

  13238.         for (;;)
    13239. 

  13239.         { n = soap->buflen - soap->bufidx;
    13240. 

  13240.           if (size < n)
    13241. 

  13241.             n = size;
    13242. 

  13242.           if ((soap->error = soap->fdimewrite(soap, (void*)soap->dime.ptr, soap->buf + soap->bufidx, n)))
    13243. 

  13243.             break;
    13244. 

  13244.           size -= n;
    13245. 

  13245.           if (!size)
    13246. 

  13246.           { soap->bufidx += n;
    13247. 

  13247.             break;
    13248. 

  13248.           }
    13249. 

  13249.           if (soap_recv(soap))
    13250. 

  13250.           { soap->error = SOAP_EOF;
    13251. 

  13251.             goto end;
    13252. 

  13252.           }
    13253. 

  13253.         }
    13254. 

  13254.         if (soap_move(soap, -(long)soap->dime.size&3))
    13255. 

  13255.         { soap->error = SOAP_EOF;
    13256. 

  13256.           break;
    13257. 

  13257.         }
    13258. 

  13258.         if (!(soap->dime.flags & SOAP_DIME_CF))
    13259. 

  13259.           break;
    13260. 

  13260.         if (soap_getdimehdr(soap))
    13261. 

  13261.           break;
    13262. 

  13262.       }
    13263. 

  13263. end:
    13264. 

  13264.       if (soap->fdimewriteclose)
    13265. 

  13265.         soap->fdimewriteclose(soap, (void*)soap->dime.ptr);
    13266. 

  13266.       soap->dime.size = 0;
    13267. 

  13267.       soap->dime.id = id;
    13268. 

  13268.       soap->dime.type = type;
    13269. 

  13269.       soap->dime.options = options;
    13270. 

  13270.     }
    13271. 

  13271.     else if (soap->dime.flags & SOAP_DIME_CF)
    13272. 

  13272.     { const char *id, *type, *options;
    13273. 

  13273.       id = soap->dime.id;
    13274. 

  13274.       type = soap->dime.type;
    13275. 

  13275.       options = soap->dime.options;
    13276. 

  13276.       if (soap_new_block(soap) == NULL)
    13277. 

  13277.         return SOAP_EOM;
    13278. 

  13278.       for (;;)
    13279. 

  13279.       { register soap_wchar c;
    13280. 

  13280.         register size_t i;
    13281. 

  13281.         register char *s;
    13282. 

  13282.         s = (char*)soap_push_block(soap, NULL, soap->dime.size);
    13283. 

  13283.         if (!s)
    13284. 

  13284.           return soap->error = SOAP_EOM;
    13285. 

  13285.         for (i = soap->dime.size; i > 0; i--)
    13286. 

  13286.         { if ((int)(c = soap_get1(soap)) == EOF)
    13287. 

  13287.             return soap->error = SOAP_EOF;
    13288. 

  13288.           *s++ = (char)c;
    13289. 

  13289.         }
    13290. 

  13290.         if (soap_move(soap, -(long)soap->dime.size&3))
    13291. 

  13291.           return soap->error = SOAP_EOF;
    13292. 

  13292.         if (!(soap->dime.flags & SOAP_DIME_CF))
    13293. 

  13293.           break;
    13294. 

  13294.         if (soap_getdimehdr(soap))
    13295. 

  13295.           return soap->error;
    13296. 

  13296.       }
    13297. 

  13297.       soap->dime.size = soap->blist->size++; /* allocate one more for '\0' */
    13298. 

  13298.       if (!(soap->dime.ptr = soap_save_block(soap, NULL, NULL, 0)))
    13299. 

  13299.         return soap->error;
    13300. 

  13300.       soap->dime.ptr[soap->dime.size] = '\0'; /* force 0-terminated */
    13301. 

  13301.       soap->dime.id = id;
    13302. 

  13302.       soap->dime.type = type;
    13303. 

  13303.       soap->dime.options = options;
    13304. 

  13304.     }
    13305. 

  13305.     else
    13306. 

  13306.       soap->dime.ptr = soap_getdimefield(soap, soap->dime.size);
    13307. 

  13307.     content = soap_new_multipart(soap, &soap->dime.first, &soap->dime.last, soap->dime.ptr, soap->dime.size);
    13308. 

  13308.     if (!content)
    13309. 

  13309.       return soap->error = SOAP_EOM;
    13310. 

  13310.     content->id = soap->dime.id;
    13311. 

  13311.     content->type = soap->dime.type;
    13312. 

  13312.     content->options = soap->dime.options;
    13313. 

  13313.     if (soap->error)
    13314. 

  13314.       return soap->error;
    13315. 

  13315.     soap_resolve_attachment(soap, content);
    13316. 

  13316.   }
    13317. 

  13317.   if (soap->error != SOAP_DIME_END)
    13318. 

  13318.     return soap->error;
    13319. 

  13319.   return soap->error = SOAP_OK;
    13320. 

  13320. }
    13321. 

  13321. #endif
    13322. 

  13322. #endif
    13323. 

  13323. 

  13324. /******************************************************************************/
    13325. 

  13325. #ifndef WITH_LEANER
    13326. 

  13326. #ifndef PALM_1
    13327. 

  13327. SOAP_FMAC1
    13328. 

  13328. int
    13329. 

  13329. SOAP_FMAC2
    13330. 

  13330. soap_getmimehdr(struct soap *soap)
    13331. 

  13331. { struct soap_multipart *content;
    13332. 

  13332.   do
    13333. 

  13333.   { if (soap_getline(soap, soap->msgbuf, sizeof(soap->msgbuf)))
    13334. 

  13334.       return soap->error;
    13335. 

  13335.   }
    13336. 

  13336.   while (!*soap->msgbuf);
    13337. 

  13337.   if (soap->msgbuf[0] == '-' && soap->msgbuf[1] == '-')
    13338. 

  13338.   { char *s = soap->msgbuf + strlen(soap->msgbuf) - 1;
    13339. 

  13339.     /* remove white space */
    13340. 

  13340.     while (soap_blank(*s))
    13341. 

  13341.       s--;
    13342. 

  13342.     s[1] = '\0';
    13343. 

  13343.     if (soap->mime.boundary)
    13344. 

  13344.     { if (strcmp(soap->msgbuf + 2, soap->mime.boundary))
    13345. 

  13345.         return soap->error = SOAP_MIME_ERROR;
    13346. 

  13346.     }
    13347. 

  13347.     else
    13348. 

  13348.       soap->mime.boundary = soap_strdup(soap, soap->msgbuf + 2);
    13349. 

  13349.     if (soap_getline(soap, soap->msgbuf, sizeof(soap->msgbuf)))
    13350. 

  13350.       return soap->error;
    13351. 

  13351.   }
    13352. 

  13352.   if (soap_set_mime_attachment(soap, NULL, 0, SOAP_MIME_NONE, NULL, NULL, NULL, NULL))
    13353. 

  13353.     return soap->error = SOAP_EOM;
    13354. 

  13354.   content = soap->mime.last;
    13355. 

  13355.   for (;;)
    13356. 

  13356.   { register char *key = soap->msgbuf;
    13357. 

  13357.     register char *val;
    13358. 

  13358.     if (!*key)
    13359. 

  13359.       break;
    13360. 

  13360.     DBGLOG(TEST,SOAP_MESSAGE(fdebug, "MIME header: %s\n", key));
    13361. 

  13361.     val = strchr(soap->msgbuf, ':');
    13362. 

  13362.     if (val)
    13363. 

  13363.     { *val = '\0';
    13364. 

  13364.       do val++;
    13365. 

  13365.       while (*val && *val <= 32);
    13366. 

  13366.       if (!soap_tag_cmp(key, "Content-ID"))
    13367. 

  13367.         content->id = soap_strdup(soap, val);
    13368. 

  13368.       else if (!soap_tag_cmp(key, "Content-Location"))
    13369. 

  13369.         content->location = soap_strdup(soap, val);
    13370. 

  13370.       else if (!soap_tag_cmp(key, "Content-Disposition"))
    13371. 

  13371.         content->id = soap_strdup(soap, soap_get_header_attribute(soap, val, "name"));
    13372. 

  13372.       else if (!soap_tag_cmp(key, "Content-Type"))
    13373. 

  13373.         content->type = soap_strdup(soap, val);
    13374. 

  13374.       else if (!soap_tag_cmp(key, "Content-Description"))
    13375. 

  13375.         content->description = soap_strdup(soap, val);
    13376. 

  13376.       else if (!soap_tag_cmp(key, "Content-Transfer-Encoding"))
    13377. 

  13377.         content->encoding = (enum soap_mime_encoding)soap_code_int(mime_codes, val, (long)SOAP_MIME_NONE);
    13378. 

  13378.     }
    13379. 

  13379.     if (soap_getline(soap, key, sizeof(soap->msgbuf)))
    13380. 

  13380.       return soap->error;
    13381. 

  13381.   }
    13382. 

  13382.   return SOAP_OK;
    13383. 

  13383. }
    13384. 

  13384. #endif
    13385. 

  13385. #endif
    13386. 

  13386. 

  13387. /******************************************************************************/
    13388. 

  13388. #ifndef WITH_LEANER
    13389. 

  13389. #ifndef PALM_1
    13390. 

  13390. SOAP_FMAC1
    13391. 

  13391. int
    13392. 

  13392. SOAP_FMAC2
    13393. 

  13393. soap_getmime(struct soap *soap)
    13394. 

  13394. { while (soap_get_mime_attachment(soap, NULL))
    13395. 

  13395.     ;
    13396. 

  13396.   return soap->error;
    13397. 

  13397. }
    13398. 

  13398. #endif
    13399. 

  13399. #endif
    13400. 

  13400. 

  13401. /******************************************************************************/
    13402. 

  13402. #ifndef WITH_LEANER
    13403. 

  13403. #ifndef PALM_1
    13404. 

  13404. SOAP_FMAC1
    13405. 

  13405. void
    13406. 

  13406. SOAP_FMAC2
    13407. 

  13407. soap_post_check_mime_attachments(struct soap *soap)
    13408. 

  13408. { soap->imode |= SOAP_MIME_POSTCHECK;
    13409. 

  13409. }
    13410. 

  13410. #endif
    13411. 

  13411. #endif
    13412. 

  13412. 

  13413. /******************************************************************************/
    13414. 

  13414. #ifndef WITH_LEANER
    13415. 

  13415. #ifndef PALM_1
    13416. 

  13416. SOAP_FMAC1
    13417. 

  13417. int
    13418. 

  13418. SOAP_FMAC2
    13419. 

  13419. soap_check_mime_attachments(struct soap *soap)
    13420. 

  13420. { if (soap->mode & SOAP_MIME_POSTCHECK)
    13421. 

  13421.     return soap_get_mime_attachment(soap, NULL) != NULL;
    13422. 

  13422.   return 0;
    13423. 

  13423. }
    13424. 

  13424. #endif
    13425. 

  13425. #endif
    13426. 

  13426. 

  13427. /******************************************************************************/
    13428. 

  13428. #ifndef WITH_LEANER
    13429. 

  13429. #ifndef PALM_1
    13430. 

  13430. SOAP_FMAC1
    13431. 

  13431. struct soap_multipart *
    13432. 

  13432. SOAP_FMAC2
    13433. 

  13433. soap_get_mime_attachment(struct soap *soap, void *handle)
    13434. 

  13434. { register soap_wchar c = 0;
    13435. 

  13435.   register size_t i, m = 0;
    13436. 

  13436.   register char *s, *t = NULL;
    13437. 

  13437.   register struct soap_multipart *content;
    13438. 

  13438.   register short flag = 0;
    13439. 

  13439.   if (!(soap->mode & SOAP_ENC_MIME))
    13440. 

  13440.     return NULL;
    13441. 

  13441.   content = soap->mime.last;
    13442. 

  13442.   if (!content)
    13443. 

  13443.   { if (soap_getmimehdr(soap))
    13444. 

  13444.       return NULL;
    13445. 

  13445.     content = soap->mime.last;
    13446. 

  13446.   }
    13447. 

  13447.   else if (content != soap->mime.first)
    13448. 

  13448.   { if (soap->fmimewriteopen && ((content->ptr = (char*)soap->fmimewriteopen(soap, (void*)handle, content->id, content->type, content->description, content->encoding)) || soap->error))
    13449. 

  13449.     { if (!content->ptr)
    13450. 

  13450.         return NULL;
    13451. 

  13451.     }
    13452. 

  13452.   }
    13453. 

  13453.   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));
    13454. 

  13454.   if (!content->ptr && soap_new_block(soap) == NULL)
    13455. 

  13455.   { soap->error = SOAP_EOM;
    13456. 

  13456.     return NULL;
    13457. 

  13457.   }
    13458. 

  13458.   for (;;)
    13459. 

  13459.   { if (content->ptr)
    13460. 

  13460.       s = soap->tmpbuf;
    13461. 

  13461.     else if (!(s = (char*)soap_push_block(soap, NULL, sizeof(soap->tmpbuf))))
    13462. 

  13462.     { soap->error = SOAP_EOM;
    13463. 

  13463.       return NULL;
    13464. 

  13464.     }
    13465. 

  13465.     for (i = 0; i < sizeof(soap->tmpbuf); i++)
    13466. 

  13466.     { if (m > 0)
    13467. 

  13467.       { *s++ = *t++;
    13468. 

  13468.         m--;
    13469. 

  13469.       }
    13470. 

  13470.       else
    13471. 

  13471.       { if (!flag)
    13472. 

  13472.         { c = soap_get1(soap);
    13473. 

  13473.           if ((int)c == EOF)
    13474. 

  13474.           { soap->error = SOAP_EOF;
    13475. 

  13475.             return NULL;
    13476. 

  13476.           }
    13477. 

  13477.         }
    13478. 

  13478.         if (flag || c == '\r')
    13479. 

  13479.         { t = soap->msgbuf;
    13480. 

  13480.           memset(t, 0, sizeof(soap->msgbuf));
    13481. 

  13481.           strcpy(t, "\n--");
    13482. 

  13482.           if (soap->mime.boundary)
    13483. 

  13483.             strncat(t, soap->mime.boundary, sizeof(soap->msgbuf)-4);
    13484. 

  13484.           do c = soap_getchar(soap);
    13485. 

  13485.           while (c == *t++);
    13486. 

  13486.           if ((int)c == EOF)
    13487. 

  13487.           { soap->error = SOAP_EOF;
    13488. 

  13488.             return NULL;
    13489. 

  13489.           }
    13490. 

  13490.           if (!*--t)
    13491. 

  13491.             goto end;
    13492. 

  13492.           *t = (char)c;
    13493. 

  13493.           flag = (c == '\r');
    13494. 

  13494.           m = t - soap->msgbuf + 1 - flag;
    13495. 

  13495.           t = soap->msgbuf;
    13496. 

  13496.           c = '\r';
    13497. 

  13497.         }
    13498. 

  13498.         *s++ = (char)c;
    13499. 

  13499.       }
    13500. 

  13500.     }
    13501. 

  13501.     if (content->ptr && soap->fmimewrite)
    13502. 

  13502.     { if ((soap->error = soap->fmimewrite(soap, (void*)content->ptr, soap->tmpbuf, i)))
    13503. 

  13503.         break;
    13504. 

  13504.     }
    13505. 

  13505.   }
    13506. 

  13506. end:
    13507. 

  13507.   *s = '\0'; /* force 0-terminated */
    13508. 

  13508.   if (content->ptr)
    13509. 

  13509.   { if (!soap->error && soap->fmimewrite)
    13510. 

  13510.       soap->error = soap->fmimewrite(soap, (void*)content->ptr, soap->tmpbuf, i);
    13511. 

  13511.     if (soap->fmimewriteclose)
    13512. 

  13512.       soap->fmimewriteclose(soap, (void*)content->ptr);
    13513. 

  13513.     if (soap->error)
    13514. 

  13514.       return NULL;
    13515. 

  13515.   }
    13516. 

  13516.   else
    13517. 

  13517.   { content->size = soap_size_block(soap, NULL, i+1)-1;
    13518. 

  13518.     content->ptr = soap_save_block(soap, NULL, NULL, 0);
    13519. 

  13519.   }
    13520. 

  13520.   soap_resolve_attachment(soap, content);
    13521. 

  13521.   if (c == '-' && soap_getchar(soap) == '-')
    13522. 

  13522.   { soap->mode &= ~SOAP_ENC_MIME;
    13523. 

  13523.     if ((soap->mode & SOAP_MIME_POSTCHECK) && soap_end_recv(soap))
    13524. 

  13524.       return NULL;
    13525. 

  13525.   }
    13526. 

  13526.   else
    13527. 

  13527.   { while (c != '\r' && (int)c != EOF && soap_blank(c))
    13528. 

  13528.       c = soap_getchar(soap);
    13529. 

  13529.     if (c != '\r' || soap_getchar(soap) != '\n')
    13530. 

  13530.     { soap->error = SOAP_MIME_ERROR;
    13531. 

  13531.       return NULL;
    13532. 

  13532.     }
    13533. 

  13533.     if (soap_getmimehdr(soap))
    13534. 

  13534.       return NULL;
    13535. 

  13535.   }
    13536. 

  13536.   return content;
    13537. 

  13537. }
    13538. 

  13538. #endif
    13539. 

  13539. #endif
    13540. 

  13540. 

  13541. /******************************************************************************/
    13542. 

  13542. #ifndef WITH_LEANER
    13543. 

  13543. #ifndef PALM_1
    13544. 

  13544. SOAP_FMAC1
    13545. 

  13545. int
    13546. 

  13546. SOAP_FMAC2
    13547. 

  13547. soap_match_cid(struct soap *soap, const char *s, const char *t)
    13548. 

  13548. { register size_t n;
    13549. 

  13549.   if (!s)
    13550. 

  13550.     return 1;
    13551. 

  13551.   if (!strcmp(s, t))
    13552. 

  13552.     return 0;
    13553. 

  13553.   if (!strncmp(s, "cid:", 4))
    13554. 

  13554.     s += 4;
    13555. 

  13555.   n = strlen(t);
    13556. 

  13556.   if (*t == '<')
    13557. 

  13557.   { t++;
    13558. 

  13558.     n -= 2;
    13559. 

  13559.   }
    13560. 

  13560.   if (!strncmp(s, t, n) && !s[n])
    13561. 

  13561.     return 0;
    13562. 

  13562.   soap_decode(soap->tmpbuf, sizeof(soap->tmpbuf), s, SOAP_STR_EOS);
    13563. 

  13563.   if (!strncmp(soap->tmpbuf, t, n) && !soap->tmpbuf[n])
    13564. 

  13564.     return 0;
    13565. 

  13565.   return 1;
    13566. 

  13566. }
    13567. 

  13567. #endif
    13568. 

  13568. #endif
    13569. 

  13569. 

  13570. /******************************************************************************/
    13571. 

  13571. #ifndef WITH_LEANER
    13572. 

  13572. #ifndef PALM_1
    13573. 

  13573. static void
    13574. 

  13574. soap_resolve_attachment(struct soap *soap, struct soap_multipart *content)
    13575. 

  13575. { if (content->id)
    13576. 

  13576.   { register struct soap_xlist **xp = &soap->xlist;
    13577. 

  13577.     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Resolving attachment data for id=%s\n", content->id));
    13578. 

  13578.     while (*xp)
    13579. 

  13579.     { register struct soap_xlist *xq = *xp;
    13580. 

  13580.       if (!soap_match_cid(soap, xq->id, content->id))
    13581. 

  13581.       { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Found matching attachment %s for content id=%s\n", xq->id, content->id));
    13582. 

  13582.         *xp = xq->next;
    13583. 

  13583.         *xq->ptr = (unsigned char*)content->ptr;
    13584. 

  13584.         *xq->size = (int)content->size;
    13585. 

  13585.         *xq->type = (char*)content->type;
    13586. 

  13586.         if (content->options)
    13587. 

  13587.           *xq->options = (char*)content->options;
    13588. 

  13588.         else
    13589. 

  13589.           *xq->options = (char*)content->description;
    13590. 

  13590.         SOAP_FREE(soap, xq);
    13591. 

  13591.       }
    13592. 

  13592.       else
    13593. 

  13593.         xp = &(*xp)->next;
    13594. 

  13594.     }
    13595. 

  13595.   }
    13596. 

  13596. }
    13597. 

  13597. #endif
    13598. 

  13598. #endif
    13599. 

  13599. 

  13600. /******************************************************************************/
    13601. 

  13601. #ifndef WITH_LEANER
    13602. 

  13602. #ifndef PALM_1
    13603. 

  13603. SOAP_FMAC1
    13604. 

  13604. int
    13605. 

  13605. SOAP_FMAC2
    13606. 

  13606. soap_putmimehdr(struct soap *soap, struct soap_multipart *content)
    13607. 

  13607. { const char *s;
    13608. 

  13608.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "MIME attachment type=%s\n", content->type?content->type:SOAP_STR_EOS));
    13609. 

  13609.   if (soap_send3(soap, "\r\n--", soap->mime.boundary, "\r\n"))
    13610. 

  13610.     return soap->error;
    13611. 

  13611.   if (content->type && soap_send3(soap, "Content-Type: ", content->type, "\r\n"))
    13612. 

  13612.     return soap->error;
    13613. 

  13613.   s = soap_code_str(mime_codes, content->encoding);
    13614. 

  13614.   if (s && soap_send3(soap, "Content-Transfer-Encoding: ", s, "\r\n"))
    13615. 

  13615.     return soap->error;
    13616. 

  13616.   if (content->id && soap_send3(soap, "Content-ID: ", content->id, "\r\n"))
    13617. 

  13617.     return soap->error;
    13618. 

  13618.   if (content->location && soap_send3(soap, "Content-Location: ", content->location, "\r\n"))
    13619. 

  13619.     return soap->error;
    13620. 

  13620.   if (content->description && soap_send3(soap, "Content-Description: ", content->description, "\r\n"))
    13621. 

  13621.     return soap->error;
    13622. 

  13622.   return soap_send_raw(soap, "\r\n", 2);
    13623. 

  13623. }
    13624. 

  13624. #endif
    13625. 

  13625. #endif
    13626. 

  13626. 

  13627. /******************************************************************************/
    13628. 

  13628. #ifndef WITH_LEANER
    13629. 

  13629. #ifndef PALM_1
    13630. 

  13630. SOAP_FMAC1
    13631. 

  13631. int
    13632. 

  13632. SOAP_FMAC2
    13633. 

  13633. soap_putmime(struct soap *soap)
    13634. 

  13634. { struct soap_multipart *content;
    13635. 

  13635.   if (!(soap->mode & SOAP_ENC_MIME) || !soap->mime.boundary)
    13636. 

  13636.     return SOAP_OK;
    13637. 

  13637.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Sending MIME attachments\n"));
    13638. 

  13638.   for (content = soap->mime.first; content; content = content->next)
    13639. 

  13639.   { void *handle;
    13640. 

  13640.     if (soap->fmimereadopen && ((handle = soap->fmimereadopen(soap, (void*)content->ptr, content->id, content->type, content->description)) || soap->error))
    13641. 

  13641.     { size_t size = content->size;
    13642. 

  13642.       if (!handle)
    13643. 

  13643.       { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fmimereadopen failed\n"));
    13644. 

  13644.         return soap->error;
    13645. 

  13645.       }
    13646. 

  13646.       if (soap_putmimehdr(soap, content))
    13647. 

  13647.         return soap->error;
    13648. 

  13648.       if (!size)
    13649. 

  13649.       { if ((soap->mode & SOAP_ENC_XML) || (soap->mode & SOAP_IO) == SOAP_IO_CHUNK || (soap->mode & SOAP_IO) == SOAP_IO_STORE)
    13650. 

  13650.         { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Chunked streaming MIME\n"));
    13651. 

  13651.           do 
    13652. 

  13652.           { size = soap->fmimeread(soap, handle, soap->tmpbuf, sizeof(soap->tmpbuf));
    13653. 

  13653.             DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fmimeread returned %lu bytes\n", (unsigned long)size));
    13654. 

  13654.             if (soap_send_raw(soap, soap->tmpbuf, size))
    13655. 

  13655.               break;
    13656. 

  13656.           } while (size); 
    13657. 

  13657.         }
    13658. 

  13658.         else
    13659. 

  13659.         { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Error: cannot chunk streaming MIME (no HTTP chunking)\n"));
    13660. 

  13660.         }
    13661. 

  13661.       }
    13662. 

  13662.       else
    13663. 

  13663.       { do
    13664. 

  13664.         { size_t bufsize;
    13665. 

  13665.           if (size < sizeof(soap->tmpbuf))
    13666. 

  13666.             bufsize = size;
    13667. 

  13667.           else
    13668. 

  13668.             bufsize = sizeof(soap->tmpbuf);
    13669. 

  13669.           if (!(bufsize = soap->fmimeread(soap, handle, soap->tmpbuf, bufsize)))
    13670. 

  13670.           { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fmimeread failed: insufficient data (%lu bytes remaining from %lu bytes)\n", (unsigned long)size, (unsigned long)content->size));
    13671. 

  13671.             soap->error = SOAP_EOF;
    13672. 

  13672.             break;
    13673. 

  13673.           }
    13674. 

  13674.           if (soap_send_raw(soap, soap->tmpbuf, bufsize))
    13675. 

  13675.             break;
    13676. 

  13676.           size -= bufsize;
    13677. 

  13677.         } while (size);
    13678. 

  13678.       }
    13679. 

  13679.       if (soap->fmimereadclose)
    13680. 

  13680.         soap->fmimereadclose(soap, handle);
    13681. 

  13681.     }
    13682. 

  13682.     else
    13683. 

  13683.     { if (soap_putmimehdr(soap, content)
    13684. 

  13684.        || soap_send_raw(soap, content->ptr, content->size))
    13685. 

  13685.         return soap->error;
    13686. 

  13686.     }
    13687. 

  13687.   }
    13688. 

  13688.   return soap_send3(soap, "\r\n--", soap->mime.boundary, "--");
    13689. 

  13689. }
    13690. 

  13690. #endif
    13691. 

  13691. #endif
    13692. 

  13692. 

  13693. /******************************************************************************/
    13694. 

  13694. #ifndef WITH_LEANER
    13695. 

  13695. #ifndef PALM_1
    13696. 

  13696. SOAP_FMAC1
    13697. 

  13697. void
    13698. 

  13698. SOAP_FMAC2
    13699. 

  13699. soap_set_dime(struct soap *soap)
    13700. 

  13700. { soap->omode |= SOAP_ENC_DIME;
    13701. 

  13701.   soap->dime.first = NULL;
    13702. 

  13702.   soap->dime.last = NULL;
    13703. 

  13703. }
    13704. 

  13704. #endif
    13705. 

  13705. #endif
    13706. 

  13706. 

  13707. /******************************************************************************/
    13708. 

  13708. #ifndef WITH_LEANER
    13709. 

  13709. #ifndef PALM_1
    13710. 

  13710. SOAP_FMAC1
    13711. 

  13711. void
    13712. 

  13712. SOAP_FMAC2
    13713. 

  13713. soap_set_mime(struct soap *soap, const char *boundary, const char *start)
    13714. 

  13714. { soap->omode |= SOAP_ENC_MIME;
    13715. 

  13715.   soap->mime.first = NULL;
    13716. 

  13716.   soap->mime.last = NULL;
    13717. 

  13717.   soap->mime.boundary = soap_strdup(soap, boundary);
    13718. 

  13718.   soap->mime.start = soap_strdup(soap, start);
    13719. 

  13719. }
    13720. 

  13720. #endif
    13721. 

  13721. #endif
    13722. 

  13722. 

  13723. /******************************************************************************/
    13724. 

  13724. #ifndef WITH_LEANER
    13725. 

  13725. #ifndef PALM_1
    13726. 

  13726. SOAP_FMAC1
    13727. 

  13727. void
    13728. 

  13728. SOAP_FMAC2
    13729. 

  13729. soap_clr_dime(struct soap *soap)
    13730. 

  13730. { soap->omode &= ~SOAP_ENC_DIME;
    13731. 

  13731.   soap->dime.first = NULL;
    13732. 

  13732.   soap->dime.last = NULL;
    13733. 

  13733. }
    13734. 

  13734. #endif
    13735. 

  13735. #endif
    13736. 

  13736. 

  13737. /******************************************************************************/
    13738. 

  13738. #ifndef WITH_LEANER
    13739. 

  13739. #ifndef PALM_1
    13740. 

  13740. SOAP_FMAC1
    13741. 

  13741. void
    13742. 

  13742. SOAP_FMAC2
    13743. 

  13743. soap_clr_mime(struct soap *soap)
    13744. 

  13744. { soap->omode &= ~SOAP_ENC_MIME;
    13745. 

  13745.   soap->mime.first = NULL;
    13746. 

  13746.   soap->mime.last = NULL;
    13747. 

  13747.   soap->mime.boundary = NULL;
    13748. 

  13748.   soap->mime.start = NULL;
    13749. 

  13749. }
    13750. 

  13750. #endif
    13751. 

  13751. #endif
    13752. 

  13752. 

  13753. /******************************************************************************/
    13754. 

  13754. #ifndef WITH_LEANER
    13755. 

  13755. #ifndef PALM_1
    13756. 

  13756. static struct soap_multipart*
    13757. 

  13757. soap_new_multipart(struct soap *soap, struct soap_multipart **first, struct soap_multipart **last, char *ptr, size_t size)
    13758. 

  13758. { struct soap_multipart *content;
    13759. 

  13759.   content = (struct soap_multipart*)soap_malloc(soap, sizeof(struct soap_multipart));
    13760. 

  13760.   if (content)
    13761. 

  13761.   { content->next = NULL;
    13762. 

  13762.     content->ptr = ptr;
    13763. 

  13763.     content->size = size;
    13764. 

  13764.     content->id = NULL;
    13765. 

  13765.     content->type = NULL;
    13766. 

  13766.     content->options = NULL;
    13767. 

  13767.     content->encoding = SOAP_MIME_NONE;
    13768. 

  13768.     content->location = NULL;
    13769. 

  13769.     content->description = NULL;
    13770. 

  13770.     if (!*first)
    13771. 

  13771.       *first = content;
    13772. 

  13772.     if (*last)
    13773. 

  13773.       (*last)->next = content;
    13774. 

  13774.     *last = content;
    13775. 

  13775.   }
    13776. 

  13776.   return content;
    13777. 

  13777. }
    13778. 

  13778. #endif
    13779. 

  13779. #endif
    13780. 

  13780. 

  13781. /******************************************************************************/
    13782. 

  13782. #ifndef WITH_LEANER
    13783. 

  13783. #ifndef PALM_1
    13784. 

  13784. SOAP_FMAC1
    13785. 

  13785. int
    13786. 

  13786. SOAP_FMAC2
    13787. 

  13787. soap_set_dime_attachment(struct soap *soap, char *ptr, size_t size, const char *type, const char *id, unsigned short optype, const char *option)
    13788. 

  13788. { struct soap_multipart *content = soap_new_multipart(soap, &soap->dime.first, &soap->dime.last, ptr, size);
    13789. 

  13789.   if (!content)
    13790. 

  13790.     return SOAP_EOM;
    13791. 

  13791.   content->id = soap_strdup(soap, id);
    13792. 

  13792.   content->type = soap_strdup(soap, type);
    13793. 

  13793.   content->options = soap_dime_option(soap, optype, option);
    13794. 

  13794.   return SOAP_OK;
    13795. 

  13795. }
    13796. 

  13796. #endif
    13797. 

  13797. #endif
    13798. 

  13798. 

  13799. /******************************************************************************/
    13800. 

  13800. #ifndef WITH_LEANER
    13801. 

  13801. #ifndef PALM_1
    13802. 

  13802. SOAP_FMAC1
    13803. 

  13803. int
    13804. 

  13804. SOAP_FMAC2
    13805. 

  13805. 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)
    13806. 

  13806. { struct soap_multipart *content = soap_new_multipart(soap, &soap->mime.first, &soap->mime.last, ptr, size);
    13807. 

  13807.   if (!content)
    13808. 

  13808.     return SOAP_EOM;
    13809. 

  13809.   content->id = soap_strdup(soap, id);
    13810. 

  13810.   content->type = soap_strdup(soap, type);
    13811. 

  13811.   content->encoding = encoding;
    13812. 

  13812.   content->location = soap_strdup(soap, location);
    13813. 

  13813.   content->description = soap_strdup(soap, description);
    13814. 

  13814.   return SOAP_OK;
    13815. 

  13815. }
    13816. 

  13816. #endif
    13817. 

  13817. #endif
    13818. 

  13818. 

  13819. /******************************************************************************/
    13820. 

  13820. #ifndef WITH_LEANER
    13821. 

  13821. #ifndef PALM_1
    13822. 

  13822. SOAP_FMAC1
    13823. 

  13823. struct soap_multipart*
    13824. 

  13824. SOAP_FMAC2
    13825. 

  13825. soap_next_multipart(struct soap_multipart *content)
    13826. 

  13826. { if (content)
    13827. 

  13827.     return content->next;
    13828. 

  13828.   return NULL;
    13829. 

  13829. }
    13830. 

  13830. #endif
    13831. 

  13831. #endif
    13832. 

  13832. 

  13833. /******************************************************************************/
    13834. 

  13834. #ifndef WITH_LEANER
    13835. 

  13835. #ifndef PALM_1
    13836. 

  13836. static void
    13837. 

  13837. soap_select_mime_boundary(struct soap *soap)
    13838. 

  13838. { while (!soap->mime.boundary || soap_valid_mime_boundary(soap))
    13839. 

  13839.   { register char *s = soap->mime.boundary;
    13840. 

  13840.     register size_t n = 0;
    13841. 

  13841.     if (s)
    13842. 

  13842.       n = strlen(s);
    13843. 

  13843.     if (n < 16)
    13844. 

  13844.     { n = 64;
    13845. 

  13845.       s = soap->mime.boundary = (char*)soap_malloc(soap, n + 1);
    13846. 

  13846.       if (!s)
    13847. 

  13847.         return;
    13848. 

  13848.     }
    13849. 

  13849.     strcpy(s, "==");
    13850. 

  13850.     s += 2;
    13851. 

  13851.     n -= 4;
    13852. 

  13852.     while (n)
    13853. 

  13853.     { *s++ = soap_base64o[soap_random & 0x3F];
    13854. 

  13854.       n--;
    13855. 

  13855.     }
    13856. 

  13856.     strcpy(s, "==");
    13857. 

  13857.   }
    13858. 

  13858.   if (!soap->mime.start)
    13859. 

  13859.     soap->mime.start = "<SOAP-ENV:Envelope>";
    13860. 

  13860. }
    13861. 

  13861. #endif
    13862. 

  13862. #endif
    13863. 

  13863. 

  13864. /******************************************************************************/
    13865. 

  13865. #ifndef WITH_LEANER
    13866. 

  13866. #ifndef PALM_1
    13867. 

  13867. static int
    13868. 

  13868. soap_valid_mime_boundary(struct soap *soap)
    13869. 

  13869. { register struct soap_multipart *content;
    13870. 

  13870.   register size_t k;
    13871. 

  13871.   if (soap->fmimeread)
    13872. 

  13872.     return SOAP_OK;
    13873. 

  13873.   k = strlen(soap->mime.boundary);
    13874. 

  13874.   for (content = soap->mime.first; content; content = content->next)
    13875. 

  13875.   { if (content->ptr && content->size >= k)
    13876. 

  13876.     { register const char *p = (const char*)content->ptr; 
    13877. 

  13877.       register size_t i;
    13878. 

  13878.       for (i = 0; i < content->size - k; i++, p++)
    13879. 

  13879.       { if (!strncmp(p, soap->mime.boundary, k))
    13880. 

  13880.           return SOAP_ERR;
    13881. 

  13881.       }
    13882. 

  13882.     }
    13883. 

  13883.   }
    13884. 

  13884.   return SOAP_OK;
    13885. 

  13885. }
    13886. 

  13886. #endif
    13887. 

  13887. #endif
    13888. 

  13888. 

  13889. /******************************************************************************/
    13890. 

  13890. #ifdef WITH_GZIP
    13891. 

  13891. #ifndef PALM_1
    13892. 

  13892. static int
    13893. 

  13893. soap_getgziphdr(struct soap *soap)
    13894. 

  13894. { int i;
    13895. 

  13895.   soap_wchar c = 0, f = 0;
    13896. 

  13896.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Get gzip header\n"));
    13897. 

  13897.   for (i = 0; i < 9; i++)
    13898. 

  13898.   { if ((int)(c = soap_get1(soap) == EOF))
    13899. 

  13899.       return soap->error = SOAP_EOF;
    13900. 

  13900.     if (i == 1 && c == 8)
    13901. 

  13901.       soap->z_dict = 0;
    13902. 

  13902.     if (i == 2)
    13903. 

  13903.       f = c;
    13904. 

  13904.   }
    13905. 

  13905.   if (f & 0x04) /* FEXTRA */
    13906. 

  13906.   { for (i = soap_get1(soap) | (soap_get1(soap) << 8); i; i--)
    13907. 

  13907.     { if ((int)soap_get1(soap) == EOF)
    13908. 

  13908.         return soap->error = SOAP_EOF;
    13909. 

  13909.     }
    13910. 

  13910.   }
    13911. 

  13911.   if (f & 0x08) /* skip FNAME */
    13912. 

  13912.   { do
    13913. 

  13913.       c = soap_get1(soap);
    13914. 

  13914.     while (c && (int)c != EOF);
    13915. 

  13915.   }
    13916. 

  13916.   if ((int)c != EOF && (f & 0x10)) /* skip FCOMMENT */
    13917. 

  13917.   { do
    13918. 

  13918.       c = soap_get1(soap);
    13919. 

  13919.     while (c && (int)c != EOF);
    13920. 

  13920.   }
    13921. 

  13921.   if ((int)c != EOF && (f & 0x02)) /* skip FHCRC (CRC32 is used) */
    13922. 

  13922.   { if ((int)(c = soap_get1(soap)) != EOF)
    13923. 

  13923.       c = soap_get1(soap);
    13924. 

  13924.   }
    13925. 

  13925.   if ((int)c == EOF)
    13926. 

  13926.     return soap->error = SOAP_EOF;
    13927. 

  13927.   return SOAP_OK;
    13928. 

  13928. }
    13929. 

  13929. #endif
    13930. 

  13930. #endif
    13931. 

  13931. 

  13932. /******************************************************************************/
    13933. 

  13933. #ifndef PALM_1
    13934. 

  13934. SOAP_FMAC1
    13935. 

  13935. int
    13936. 

  13936. SOAP_FMAC2
    13937. 

  13937. soap_begin_recv(struct soap *soap)
    13938. 

  13938. { soap_wchar c;
    13939. 

  13939.   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Initializing for input\n"));
    13940. 

  13940.   soap->error = SOAP_OK;
    13941. 

  13941.   soap_free_temp(soap);
    13942. 

  13942.   soap_set_local_namespaces(soap);
    13943. 

  13943.   soap->version = 0;	/* don't assume we're parsing SOAP content by default */
    13944. 

  13944. #ifndef WITH_NOIDREF
    13945. 

  13945.   soap_free_iht(soap);
    13946. 

  13946. #endif
    13947. 

  13947.   if ((soap->imode & SOAP_IO) == SOAP_IO_CHUNK)
    13948. 

  13948.     soap->omode |= SOAP_IO_CHUNK;
    13949. 

  13949.   soap->imode &= ~(SOAP_IO | SOAP_ENC_MIME);
    13950. 

  13950.   soap->mode = soap->imode;
    13951. 

  13951.   if (!soap->keep_alive)
    13952. 

  13952.   { soap->buflen = 0;
    13953. 

  13953.     soap->bufidx = 0;
    13954. 

  13954.   }
    13955. 

  13955.   if (!(soap->mode & SOAP_IO_KEEPALIVE))
    13956. 

  13956.     soap->keep_alive = 0;
    13957. 

  13957.   soap->ahead = 0;
    13958. 

  13958.   soap->peeked = 0;
    13959. 

  13959.   soap->level = 0;
    13960. 

  13960.   soap->part = SOAP_BEGIN;
    13961. 

  13961.   soap->alloced = 0;
    13962. 

  13962.   soap->count = 0;
    13963. 

  13963.   soap->length = 0;
    13964. 

  13964.   soap->cdata = 0;
    13965. 

  13965.   *soap->endpoint = '\0';
    13966. 

  13966.   soap->action = NULL;
    13967. 

  13967.   soap->header = NULL;
    13968. 

  13968.   soap->fault = NULL;
    13969. 

  13969.   soap->status = 0;
    13970. 

  13970. #ifndef WITH_LEANER
    13971. 

  13971.   soap->dom = NULL;
    13972. 

  13972.   soap->dime.chunksize = 0;
    13973. 

  13973.   soap->dime.buflen = 0;
    13974. 

  13974.   soap->dime.list = NULL;
    13975. 

  13975.   soap->dime.first = NULL;
    13976. 

  13976.   soap->dime.last = NULL;
    13977. 

  13977.   soap->mime.list = NULL;
    13978. 

  13978.   soap->mime.first = NULL;
    13979. 

  13979.   soap->mime.last = NULL;
    13980. 

  13980.   soap->mime.boundary = NULL;
    13981. 

  13981.   soap->mime.start = NULL;
    13982. 

  13982. #endif
    13983. 

  13983. #ifdef WIN32
    13984. 

  13984. #ifndef UNDER_CE
    13985. 

  13985. #ifndef WITH_FASTCGI
    13986. 

  13986.   if (!soap_valid_socket(soap->socket))
    13987. 

  13987. #ifdef __BORLANDC__
    13988. 

  13988.     setmode(soap->recvfd, _O_BINARY);
    13989. 

  13989. #else
    13990. 

  13990.     _setmode(soap->recvfd, _O_BINARY);
    13991. 

  13991. #endif
    13992. 

  13992. #endif
    13993. 

  13993. #endif
    13994. 

  13994. #endif
    13995. 

  13995. #ifdef WITH_ZLIB
    13996. 

  13996.   soap->mode &= ~SOAP_ENC_ZLIB;
    13997. 

  13997.   soap->zlib_in = SOAP_ZLIB_NONE;
    13998. 

  13998.   soap->zlib_out = SOAP_ZLIB_NONE;
    13999. 

  13999.   soap->d_stream->next_in = Z_NULL;
    14000. 

  14000.   soap->d_stream->avail_in = 0;
    14001. 

  14001.   soap->d_stream->next_out = (Byte*)soap->buf;
    14002. 

  14002.   soap->d_stream->avail_out = SOAP_BUFLEN;
    14003. 

  14003.   soap->z_ratio_in = 1.0;
    14004. 

  14004. #endif
    14005. 

  14005. #ifdef WITH_OPENSSL
    14006. 

  14006.   if (soap->ssl)
    14007. 

  14007.     ERR_clear_error();
    14008. 

  14008. #endif
    14009. 

  14009. #ifndef WITH_LEANER
    14010. 

  14010.   if (soap->fprepareinitrecv && (soap->error = soap->fprepareinitrecv(soap)))
    14011. 

  14011.     return soap->error;
    14012. 

  14012. #endif
    14013. 

  14013.   c = soap_getchar(soap);
    14014. 

  14014. #ifdef WITH_GZIP
    14015. 

  14015.   if (c == 0x1F)
    14016. 

  14016.   { if (soap_getgziphdr(soap))
    14017. 

  14017.       return soap->error;
    14018. 

  14018.     if (inflateInit2(soap->d_stream, -MAX_WBITS) != Z_OK)
    14019. 

  14019.       return soap->error = SOAP_ZLIB_ERROR;
    14020. 

  14020.     if (soap->z_dict)
    14021. 

  14021.     { if (inflateSetDictionary(soap->d_stream, (const Bytef*)soap->z_dict, soap->z_dict_len) != Z_OK)
    14022. 

  14022.         return soap->error = SOAP_ZLIB_ERROR;
    14023. 

  14023.     }
    14024. 

  14024.     soap->zlib_state = SOAP_ZLIB_INFLATE;
    14025. 

  14025.     soap->mode |= SOAP_ENC_ZLIB;
    14026. 

  14026.     soap->zlib_in = SOAP_ZLIB_GZIP;
    14027. 

  14027.     soap->z_crc = crc32(0L, NULL, 0);
    14028. 

  14028.     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "gzip initialized\n"));
    14029. 

  14029.     if (!soap->z_buf)
    14030. 

  14030.       soap->z_buf = (char*)SOAP_MALLOC(soap, SOAP_BUFLEN);
    14031. 

  14031.     memcpy(soap->z_buf, soap->buf, SOAP_BUFLEN);
    14032. 

  14032.     /* should not chunk over plain transport, so why bother to check? */
    14033. 

  14033.     /* if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK) */
    14034. 

  14034.     /*   soap->z_buflen = soap->bufidx; */
    14035. 

  14035.     /* else */
    14036. 

  14036.     soap->d_stream->next_in = (Byte*)(soap->z_buf + soap->bufidx);
    14037. 

  14037.     soap->d_stream->avail_in = soap->buflen - soap->bufidx;
    14038. 

  14038.     soap->z_buflen = soap->buflen;
    14039. 

  14039.     soap->buflen = soap->bufidx;
    14040. 

  14040.     c = ' ';
    14041. 

  14041.   }
    14042. 

  14042. #endif
    14043. 

  14043.   while (soap_blank(c))
    14044. 

  14044.     c = soap_getchar(soap);
    14045. 

  14045. #ifndef WITH_LEANER
    14046. 

  14046.   if (c == '-' && soap_get0(soap) == '-')
    14047. 

  14047.     soap->mode |= SOAP_ENC_MIME;
    14048. 

  14048.   else if ((c & 0xFFFC) == (SOAP_DIME_VERSION | SOAP_DIME_MB) && (soap_get0(soap) & 0xFFF0) == 0x20)
    14049. 

  14049.     soap->mode |= SOAP_ENC_DIME;
    14050. 

  14050.   else
    14051. 

  14051. #endif
    14052. 

  14052.   { /* skip BOM */
    14053. 

  14053.     if (c == 0xEF && (c = soap_getchar(soap)) == 0xBB && (c = soap_getchar(soap)) == 0xBF)
    14054. 

  14054.       c = soap_getchar(soap);
    14055. 

  14055.     /* skip space */
    14056. 

  14056.     while (soap_blank(c))
    14057. 

  14057.       c = soap_getchar(soap);
    14058. 

  14058.   }
    14059. 

  14059.   if ((int)c == EOF)
    14060. 

  14060.     return soap->error = SOAP_EOF;
    14061. 

  14061.   soap_unget(soap, c);
    14062. 

  14062. #ifndef WITH_NOHTTP
    14063. 

  14063.   /* if not XML or MIME/DIME/ZLIB, assume HTTP header */
    14064. 

  14064.   if (c != '<' && !(soap->mode & (SOAP_ENC_MIME | SOAP_ENC_DIME | SOAP_ENC_ZLIB)))
    14065. 

  14065.   { soap_mode m = soap->imode;
    14066. 

  14066.     soap->mode &= ~SOAP_IO;
    14067. 

  14067.     soap->error = soap->fparse(soap);
    14068. 

  14068.     if (soap->error && soap->error < SOAP_STOP)
    14069. 

  14069.     { soap->keep_alive = 0; /* force close later */
    14070. 

  14070.       return soap->error;
    14071. 

  14071.     }
    14072. 

  14072.     if (soap->error == SOAP_STOP)
    14073. 

  14073.       return soap->error;
    14074. 

  14074.     soap->mode = soap->imode; /* if imode is changed, effectuate */
    14075. 

  14075.     soap->imode = m; /* restore imode */
    14076. 

  14076. #ifdef WITH_ZLIB
    14077. 

  14077.     soap->mode &= ~SOAP_ENC_ZLIB;
    14078. 

  14078. #endif
    14079. 

  14079.     if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK)
    14080. 

  14080.     { soap->chunkbuflen = soap->buflen;
    14081. 

  14081.       soap->buflen = soap->bufidx;
    14082. 

  14082.       soap->chunksize = 0;
    14083. 

  14083.     }
    14084. 

  14084.     /* Note: fparse should not use soap_unget to push back last char */
    14085. 

  14085.     if (soap_get0(soap) == (int)EOF)
    14086. 

  14086.     { if (soap->status == 200)
    14087. 

  14087.         return soap->error = SOAP_NO_DATA; /* HTTP OK: always expect data */
    14088. 

  14088.       return soap->error = soap->status;
    14089. 

  14089.     }
    14090. 

  14090. #ifdef WITH_ZLIB
    14091. 

  14091.     if (soap->zlib_in != SOAP_ZLIB_NONE)
    14092. 

  14092.     {
    14093. 

  14093. #ifdef WITH_GZIP
    14094. 

  14094.       if (soap->zlib_in != SOAP_ZLIB_DEFLATE)
    14095. 

  14095.       { c = soap_get1(soap);
    14096. 

  14096.         if (c == 0x1F)
    14097. 

  14097.         { if (soap_getgziphdr(soap))
    14098. 

  14098.             return soap->error;
    14099. 

  14099.           if (inflateInit2(soap->d_stream, -MAX_WBITS) != Z_OK)
    14100. 

  14100.             return soap->error = SOAP_ZLIB_ERROR;
    14101. 

  14101.           soap->z_crc = crc32(0L, NULL, 0);
    14102. 

  14102.           DBGLOG(TEST, SOAP_MESSAGE(fdebug, "gzip initialized\n"));
    14103. 

  14103.         }
    14104. 

  14104.         else
    14105. 

  14105.         { soap_revget1(soap);
    14106. 

  14106.           if (inflateInit(soap->d_stream) != Z_OK)
    14107. 

  14107.             return soap->error = SOAP_ZLIB_ERROR;
    14108. 

  14108.           soap->zlib_in = SOAP_ZLIB_DEFLATE;
    14109. 

  14109.         }
    14110. 

  14110.       }
    14111. 

  14111.       else
    14112. 

  14112. #endif
    14113. 

  14113.       if (inflateInit(soap->d_stream) != Z_OK)
    14114. 

  14114.         return soap->error = SOAP_ZLIB_ERROR;
    14115. 

  14115.       if (soap->z_dict)
    14116. 

  14116.       { if (inflateSetDictionary(soap->d_stream, (const Bytef*)soap->z_dict, soap->z_dict_len) != Z_OK)
    14117. 

  14117.           return soap->error = SOAP_ZLIB_ERROR;
    14118. 

  14118.       }
    14119. 

  14119.       soap->zlib_state = SOAP_ZLIB_INFLATE;
    14120. 

  14120.       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflate initialized\n"));
    14121. 

  14121.       soap->mode |= SOAP_ENC_ZLIB;
    14122. 

  14122.       if (!soap->z_buf)
    14123. 

  14123.         soap->z_buf = (char*)SOAP_MALLOC(soap, SOAP_BUFLEN);
    14124. 

  14124.       memcpy(soap->z_buf, soap->buf, SOAP_BUFLEN);
    14125. 

  14125.       soap->d_stream->next_in = (Byte*)(soap->z_buf + soap->bufidx);
    14126. 

  14126.       soap->d_stream->avail_in = soap->buflen - soap->bufidx;
    14127. 

  14127.       soap->z_buflen = soap->buflen;
    14128. 

  14128.       soap->buflen = soap->bufidx;
    14129. 

  14129.     }
    14130. 

  14130. #endif
    14131. 

  14131. #ifndef WITH_LEANER
    14132. 

  14132.     if (soap->fpreparerecv && (soap->mode & SOAP_IO) != SOAP_IO_CHUNK && soap->buflen > soap->bufidx)
    14133. 

  14133.     { int r;
    14134. 

  14134.       if ((r = soap->fpreparerecv(soap, soap->buf + soap->bufidx, soap->buflen - soap->bufidx)))
    14135. 

  14135.         return soap->error = r;
    14136. 

  14136.     }
    14137. 

  14137. #endif
    14138. 

  14138.     if (soap->error)
    14139. 

  14139.     { if (soap->error == SOAP_FORM && soap->fform)
    14140. 

  14140.       { soap->error = soap->fform(soap);
    14141. 

  14141.         if (soap->error == SOAP_OK)
    14142. 

  14142.           soap->error = SOAP_STOP; /* prevents further processing */
    14143. 

  14143.       }
    14144. 

  14144.       return soap->error;
    14145. 

  14145.     }
    14146. 

  14146.   }
    14147. 

  14147. #endif
    14148. 

  14148. #ifndef WITH_LEANER
    14149. 

  14149.   if (soap->mode & SOAP_ENC_MIME)
    14150. 

  14150.   { if (soap_getmimehdr(soap))
    14151. 

  14151.       return soap->error;
    14152. 

  14152.     if (soap->mime.start)
    14153. 

  14153.     { do
    14154. 

  14154.       { if (!soap->mime.last->id)
    14155. 

  14155.           break;
    14156. 

  14156.         if (!soap_match_cid(soap, soap->mime.start, soap->mime.last->id))
    14157. 

  14157.           break;
    14158. 

  14158.       } while (soap_get_mime_attachment(soap, NULL));
    14159. 

  14159.     }
    14160. 

  14160.     if (soap_get_header_attribute(soap, soap->mime.first->type, "application/dime"))
    14161. 

  14161.       soap->mode |= SOAP_ENC_DIME;
    14162. 

  14162.   }
    14163. 

  14163.   if (soap->mode & SOAP_ENC_DIME)
    14164. 

  14164.   { if (soap_getdimehdr(soap))
    14165. 

  14165.       return soap->error;
    14166. 

  14166.     if (soap->dime.flags & SOAP_DIME_CF)
    14167. 

  14167.     { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Chunked DIME SOAP message\n"));
    14168. 

  14168.       soap->dime.chunksize = soap->dime.size;
    14169. 

  14169.       if (soap->buflen - soap->bufidx >= soap->dime.chunksize)
    14170. 

  14170.       { soap->dime.buflen = soap->buflen;
    14171. 

  14171.         soap->buflen = soap->bufidx + soap->dime.chunksize;
    14172. 

  14172.       }
    14173. 

  14173.       else
    14174. 

  14174.         soap->dime.chunksize -= soap->buflen - soap->bufidx;
    14175. 

  14175.     }
    14176. 

  14176.     soap->count = soap->buflen - soap->bufidx;
    14177. 

  14177.   }
    14178. 

  14178. #endif
    14179. 

  14179.   return SOAP_OK;
    14180. 

  14180. }
    14181. 

  14181. #endif
    14182. 

  14182. 

  14183. /******************************************************************************/
    14184. 

  14184. #ifndef PALM_2
    14185. 

  14185. SOAP_FMAC1
    14186. 

  14186. int
    14187. 

  14187. SOAP_FMAC2
    14188. 

  14188. soap_envelope_begin_out(struct soap *soap)
    14189. 

  14189. {
    14190. 

  14190. #ifndef WITH_LEANER
    14191. 

  14191.   size_t n = 0;
    14192. 

  14192.   if ((soap->mode & SOAP_ENC_MIME) && soap->mime.boundary && soap->mime.start && strlen(soap->mime.boundary) + strlen(soap->mime.start) < sizeof(soap->tmpbuf) - 80 )
    14193. 

  14193.   { const char *s;
    14194. 

  14194.     if ((soap->mode & SOAP_ENC_DIME) && !(soap->mode & SOAP_ENC_MTOM))
    14195. 

  14195.       s = "application/dime";
    14196. 

  14196.     else if (soap->version == 2)
    14197. 

  14197.     { if (soap->mode & SOAP_ENC_MTOM)
    14198. 

  14198.         s = "application/xop+xml; charset=utf-8; type=\"application/soap+xml\"";
    14199. 

  14199.       else
    14200. 

  14200.         s = "application/soap+xml; charset=utf-8";
    14201. 

  14201.     }
    14202. 

  14202.     else if (soap->mode & SOAP_ENC_MTOM)
    14203. 

  14203.       s = "application/xop+xml; charset=utf-8; type=\"text/xml\"";
    14204. 

  14204.     else
    14205. 

  14205.       s = "text/xml; charset=utf-8";
    14206. 

  14206.     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);
    14207. 

  14207.     n = strlen(soap->tmpbuf);
    14208. 

  14208.     if (soap_send_raw(soap, soap->tmpbuf, n))
    14209. 

  14209.       return soap->error;
    14210. 

  14210.   }
    14211. 

  14211.   if (soap->mode & SOAP_IO_LENGTH)
    14212. 

  14212.     soap->dime.size = soap->count;	/* DIME in MIME correction */
    14213. 

  14213.   if (!(soap->mode & SOAP_IO_LENGTH) && (soap->mode & SOAP_ENC_DIME))
    14214. 

  14214.   { if (soap_putdimehdr(soap))
    14215. 

  14215.       return soap->error;
    14216. 

  14216.   }
    14217. 

  14217. #endif
    14218. 

  14218.   soap->part = SOAP_IN_ENVELOPE;
    14219. 

  14219.   return soap_element_begin_out(soap, "SOAP-ENV:Envelope", 0, NULL);
    14220. 

  14220. }
    14221. 

  14221. #endif
    14222. 

  14222. 

  14223. /******************************************************************************/
    14224. 

  14224. #ifndef PALM_2
    14225. 

  14225. SOAP_FMAC1
    14226. 

  14226. int
    14227. 

  14227. SOAP_FMAC2
    14228. 

  14228. soap_envelope_end_out(struct soap *soap)
    14229. 

  14229. { if (soap_element_end_out(soap, "SOAP-ENV:Envelope") || ((soap->mode & SOAP_XML_INDENT) && soap_send_raw(soap, "\r\n", 2)))
    14230. 

  14230.     return soap->error;
    14231. 

  14231. #ifndef WITH_LEANER
    14232. 

  14232.   if ((soap->mode & SOAP_IO_LENGTH) && (soap->mode & SOAP_ENC_DIME) && !(soap->mode & SOAP_ENC_MTOM))
    14233. 

  14233.   { soap->dime.size = soap->count - soap->dime.size;	/* DIME in MIME correction */
    14234. 

  14234.     sprintf(soap->id, soap->dime_id_format, 0);
    14235. 

  14235.     soap->dime.id = soap->id;
    14236. 

  14236.     if (soap->local_namespaces)
    14237. 

  14237.     { if (soap->local_namespaces[0].out)
    14238. 

  14238.         soap->dime.type = (char*)soap->local_namespaces[0].out;
    14239. 

  14239.       else
    14240. 

  14240.         soap->dime.type = (char*)soap->local_namespaces[0].ns;
    14241. 

  14241.     }
    14242. 

  14242.     soap->dime.options = NULL;
    14243. 

  14243.     soap->dime.flags = SOAP_DIME_MB | SOAP_DIME_ABSURI;
    14244. 

  14244.     if (!soap->dime.first)
    14245. 

  14245.       soap->dime.flags |= SOAP_DIME_ME;
    14246. 

  14246.     soap->count += 12 + ((strlen(soap->dime.id)+3)&(~3)) + (soap->dime.type ? ((strlen(soap->dime.type)+3)&(~3)) : 0);
    14247. 

  14247.   }
    14248. 

  14248.   if ((soap->mode & SOAP_ENC_DIME) && !(soap->mode & SOAP_ENC_MTOM))
    14249. 

  14249.     return soap_send_raw(soap, SOAP_STR_PADDING, -(long)soap->dime.size&3);
    14250. 

  14250. #endif
    14251. 

  14251.   soap->part = SOAP_END_ENVELOPE;
    14252. 

  14252.   return SOAP_OK;
    14253. 

  14253. } 
    14254. 

  14254. #endif
    14255. 

  14255. 

  14256. /******************************************************************************/
    14257. 

  14257. #ifndef PALM_1
    14258. 

  14258. static char*
    14259. 

  14259. soap_get_http_body(struct soap *soap)
    14260. 

  14260. {
    14261. 

  14261. #ifndef WITH_LEAN
    14262. 

  14262.   register size_t l = 0, n = 0;
    14263. 

  14263.   register char *s;
    14264. 

  14264.   /* get HTML body of HTTP error content */
    14265. 

  14265.   if (!(soap->mode & SOAP_ENC_ZLIB) && (soap->mode & SOAP_IO) != SOAP_IO_CHUNK)
    14266. 

  14266.   { n = soap->length;
    14267. 

  14267.     if (!n)
    14268. 

  14268.       return NULL;
    14269. 

  14269.   }
    14270. 

  14270. #ifdef WITH_FAST
    14271. 

  14271.   soap->labidx = 0;			/* use look-aside buffer */
    14272. 

  14272. #else
    14273. 

  14273.   if (soap_new_block(soap) == NULL)
    14274. 

  14274.     return NULL;
    14275. 

  14275. #endif
    14276. 

  14276.   for (;;)
    14277. 

  14277.   { 
    14278. 

  14278. #ifdef WITH_FAST
    14279. 

  14279.     register size_t i, k;
    14280. 

  14280.     if (soap_append_lab(soap, NULL, 0))	/* allocate more space in look-aside buffer if necessary */
    14281. 

  14281.       return NULL;
    14282. 

  14282.     s = soap->labbuf + soap->labidx;	/* space to populate */
    14283. 

  14283.     k = soap->lablen - soap->labidx;	/* number of bytes available */
    14284. 

  14284.     soap->labidx = soap->lablen;	/* claim this space */
    14285. 

  14285. #else
    14286. 

  14286.     register size_t i, k = SOAP_BLKLEN;
    14287. 

  14287.     if (!(s = (char*)soap_push_block(soap, NULL, k)))
    14288. 

  14288.       return NULL;
    14289. 

  14289. #endif
    14290. 

  14290.     for (i = 0; i < k; i++)
    14291. 

  14291.     { register soap_wchar c = soap_getchar(soap);
    14292. 

  14292.       if ((int)c == EOF)
    14293. 

  14293.         goto end;
    14294. 

  14294.       *s++ = (char)(c & 0xFF);
    14295. 

  14295.       l++;
    14296. 

  14296.       if (n > 0 && l >= n)
    14297. 

  14297.         goto end;
    14298. 

  14298.     }
    14299. 

  14299.   }
    14300. 

  14300. end:
    14301. 

  14301.   *s = '\0';
    14302. 

  14302. #ifdef WITH_FAST
    14303. 

  14303.   s = soap_strdup(soap, soap->labbuf);
    14304. 

  14304. #else
    14305. 

  14305.   soap_size_block(soap, NULL, i+1);
    14306. 

  14306.   s = soap_save_block(soap, NULL, 0);
    14307. 

  14307. #endif
    14308. 

  14308.   return s;
    14309. 

  14309. #else
    14310. 

  14310.   return NULL;
    14311. 

  14311. #endif
    14312. 

  14312. }
    14313. 

  14313. #endif
    14314. 

  14314. 

  14315. /******************************************************************************/
    14316. 

  14316. #ifndef PALM_1
    14317. 

  14317. SOAP_FMAC1
    14318. 

  14318. int
    14319. 

  14319. SOAP_FMAC2
    14320. 

  14320. soap_envelope_begin_in(struct soap *soap)
    14321. 

  14321. { register struct Namespace *p;
    14322. 

  14322.   soap->part = SOAP_IN_ENVELOPE;
    14323. 

  14323.   if (soap_element_begin_in(soap, "SOAP-ENV:Envelope", 0, NULL))
    14324. 

  14324.   { if (soap->error == SOAP_TAG_MISMATCH
    14325. 

  14325.      && !soap_element_begin_in(soap, "Envelope", 0, NULL))
    14326. 

  14326.       soap->error = SOAP_VERSIONMISMATCH;
    14327. 

  14327.     else if (soap->status)
    14328. 

  14328.       soap->error = soap->status;
    14329. 

  14329.     return soap->error;
    14330. 

  14330.   }
    14331. 

  14331.   p = soap->local_namespaces;
    14332. 

  14332.   if (p)
    14333. 

  14333.   { const char *ns = p[0].out;
    14334. 

  14334.     if (!ns)
    14335. 

  14335.       ns = p[0].ns;
    14336. 

  14336.     if (!strcmp(ns, soap_env1))
    14337. 

  14337.     { soap->version = 1; /* make sure we use SOAP 1.1 */
    14338. 

  14338.       if (p[1].out)
    14339. 

  14339.         SOAP_FREE(soap, p[1].out);
    14340. 

  14340.       if ((p[1].out = (char*)SOAP_MALLOC(soap, sizeof(soap_enc1))))
    14341. 

  14341.         strcpy(p[1].out, soap_enc1);
    14342. 

  14342.     }
    14343. 

  14343.     else if (!strcmp(ns, soap_env2))
    14344. 

  14344.     { soap->version = 2; /* make sure we use SOAP 1.2 */
    14345. 

  14345.       if (p[1].out)
    14346. 

  14346.         SOAP_FREE(soap, p[1].out);
    14347. 

  14347.       if ((p[1].out = (char*)SOAP_MALLOC(soap, sizeof(soap_enc2))))
    14348. 

  14348.         strcpy(p[1].out, soap_enc2);
    14349. 

  14349.     }
    14350. 

  14350.   }
    14351. 

  14351.   return SOAP_OK;
    14352. 

  14352. }
    14353. 

  14353. #endif
    14354. 

  14354. 

  14355. /******************************************************************************/
    14356. 

  14356. #ifndef PALM_1
    14357. 

  14357. SOAP_FMAC1
    14358. 

  14358. int
    14359. 

  14359. SOAP_FMAC2
    14360. 

  14360. soap_envelope_end_in(struct soap *soap)
    14361. 

  14361. { soap->part = SOAP_END_ENVELOPE;
    14362. 

  14362.   return soap_element_end_in(soap, "SOAP-ENV:Envelope");
    14363. 

  14363. }
    14364. 

  14364. #endif
    14365. 

  14365. 

  14366. /******************************************************************************/
    14367. 

  14367. #ifndef PALM_2
    14368. 

  14368. SOAP_FMAC1
    14369. 

  14369. int
    14370. 

  14370. SOAP_FMAC2
    14371. 

  14371. soap_body_begin_out(struct soap *soap)
    14372. 

  14372. { soap->part = SOAP_IN_BODY;
    14373. 

  14373.   if (soap->version == 1)
    14374. 

  14374.     soap->encoding = 1;
    14375. 

  14375. #ifndef WITH_LEAN
    14376. 

  14376.   if ((soap->mode & SOAP_XML_SEC) && soap_set_attr(soap, "wsu:Id", "Body", 1))
    14377. 

  14377.     return soap->error;
    14378. 

  14378. #endif
    14379. 

  14379.   if (soap_element(soap, "SOAP-ENV:Body", 0, NULL))
    14380. 

  14380.     return soap->error;
    14381. 

  14381.   return soap_element_start_end_out(soap, NULL);
    14382. 

  14382. }
    14383. 

  14383. #endif
    14384. 

  14384. 

  14385. /******************************************************************************/
    14386. 

  14386. #ifndef PALM_2
    14387. 

  14387. SOAP_FMAC1
    14388. 

  14388. int
    14389. 

  14389. SOAP_FMAC2
    14390. 

  14390. soap_body_end_out(struct soap *soap)
    14391. 

  14391. { if (soap_element_end_out(soap, "SOAP-ENV:Body"))
    14392. 

  14392.     return soap->error;
    14393. 

  14393.   soap->part = SOAP_END_BODY;
    14394. 

  14394.   return SOAP_OK;
    14395. 

  14395. }
    14396. 

  14396. #endif
    14397. 

  14397. 

  14398. /******************************************************************************/
    14399. 

  14399. #ifndef PALM_2
    14400. 

  14400. SOAP_FMAC1
    14401. 

  14401. int
    14402. 

  14402. SOAP_FMAC2
    14403. 

  14403. soap_body_begin_in(struct soap *soap)
    14404. 

  14404. { soap->part = SOAP_IN_BODY;
    14405. 

  14405.   if (soap_element_begin_in(soap, "SOAP-ENV:Body", 0, NULL))
    14406. 

  14406.     return soap->error;
    14407. 

  14407.   if (!soap->body)
    14408. 

  14408.     soap->part = SOAP_NO_BODY;
    14409. 

  14409.   return SOAP_OK;
    14410. 

  14410. }
    14411. 

  14411. #endif
    14412. 

  14412. 

  14413. /******************************************************************************/
    14414. 

  14414. #ifndef PALM_2
    14415. 

  14415. SOAP_FMAC1
    14416. 

  14416. int
    14417. 

  14417. SOAP_FMAC2
    14418. 

  14418. soap_body_end_in(struct soap *soap)
    14419. 

  14419. { if (soap->part == SOAP_NO_BODY)
    14420. 

  14420.     return soap->error = SOAP_OK;
    14421. 

  14421.   soap->part = SOAP_END_BODY;
    14422. 

  14422.   return soap_element_end_in(soap, "SOAP-ENV:Body");
    14423. 

  14423. }
    14424. 

  14424. #endif
    14425. 

  14425. 

  14426. /******************************************************************************/
    14427. 

  14427. #ifndef PALM_2
    14428. 

  14428. SOAP_FMAC1
    14429. 

  14429. int
    14430. 

  14430. SOAP_FMAC2
    14431. 

  14431. soap_recv_header(struct soap *soap)
    14432. 

  14432. { if (soap_getheader(soap) && soap->error == SOAP_TAG_MISMATCH)
    14433. 

  14433.     soap->error = SOAP_OK;
    14434. 

  14434.   if (soap->error == SOAP_OK && soap->fheader)
    14435. 

  14435.     soap->error = soap->fheader(soap);
    14436. 

  14436.   return soap->error;
    14437. 

  14437. }
    14438. 

  14438. #endif
    14439. 

  14439. 

  14440. /******************************************************************************/
    14441. 

  14441. #ifndef PALM_1
    14442. 

  14442. SOAP_FMAC1
    14443. 

  14443. void
    14444. 

  14444. SOAP_FMAC2
    14445. 

  14445. soap_set_endpoint(struct soap *soap, const char *endpoint)
    14446. 

  14446. { register const char *s;
    14447. 

  14447.   register size_t i, n;
    14448. 

  14448.   soap->endpoint[0] = '\0';
    14449. 

  14449.   soap->host[0] = '\0';
    14450. 

  14450.   soap->path[0] = '/';
    14451. 

  14451.   soap->path[1] = '\0';
    14452. 

  14452.   soap->port = 80;
    14453. 

  14453.   if (!endpoint || !*endpoint)
    14454. 

  14454.     return;
    14455. 

  14455. #ifdef WITH_OPENSSL
    14456. 

  14456.   if (!soap_tag_cmp(endpoint, "https:*"))
    14457. 

  14457.     soap->port = 443;
    14458. 

  14458. #endif
    14459. 

  14459.   strncpy(soap->endpoint, endpoint, sizeof(soap->endpoint) - 1);
    14460. 

  14460.   soap->endpoint[sizeof(soap->endpoint) - 1] = '\0';
    14461. 

  14461.   s = strchr(endpoint, ':');
    14462. 

  14462.   if (s && s[1] == '/' && s[2] == '/')
    14463. 

  14463.     s += 3;
    14464. 

  14464.   else
    14465. 

  14465.     s = endpoint;
    14466. 

  14466.   n = strlen(s);
    14467. 

  14467.   if (n >= sizeof(soap->host))
    14468. 

  14468.     n = sizeof(soap->host) - 1;
    14469. 

  14469. #ifdef WITH_IPV6
    14470. 

  14470.   if (s[0] == '[')
    14471. 

  14471.   { s++;
    14472. 

  14472.     for (i = 0; i < n; i++)
    14473. 

  14473.     { if (s[i] == ']')
    14474. 

  14474.       { s++;
    14475. 

  14475.         --n;
    14476. 

  14476.         break; 
    14477. 

  14477.       }
    14478. 

  14478.       soap->host[i] = s[i];
    14479. 

  14479.     }
    14480. 

  14480.   }
    14481. 

  14481.   else
    14482. 

  14482.   { for (i = 0; i < n; i++)
    14483. 

  14483.     { soap->host[i] = s[i];
    14484. 

  14484.       if (s[i] == '/' || s[i] == ':')
    14485. 

  14485.         break; 
    14486. 

  14486.     }
    14487. 

  14487.   }
    14488. 

  14488. #else
    14489. 

  14489.   for (i = 0; i < n; i++)
    14490. 

  14490.   { soap->host[i] = s[i];
    14491. 

  14491.     if (s[i] == '/' || s[i] == ':')
    14492. 

  14492.       break; 
    14493. 

  14493.   }
    14494. 

  14494. #endif
    14495. 

  14495.   soap->host[i] = '\0';
    14496. 

  14496.   if (s[i] == ':')
    14497. 

  14497.   { soap->port = (int)soap_strtol(s + i + 1, NULL, 10);
    14498. 

  14498.     for (i++; i < n; i++)
    14499. 

  14499.       if (s[i] == '/')
    14500. 

  14500.         break;
    14501. 

  14501.   }
    14502. 

  14502.   if (i < n && s[i])
    14503. 

  14503.   { strncpy(soap->path, s + i, sizeof(soap->path));
    14504. 

  14504.     soap->path[sizeof(soap->path) - 1] = '\0';
    14505. 

  14505.   }
    14506. 

  14506. }
    14507. 

  14507. #endif
    14508. 

  14508. 

  14509. /******************************************************************************/
    14510. 

  14510. #ifndef PALM_1
    14511. 

  14511. SOAP_FMAC1
    14512. 

  14512. int
    14513. 

  14513. SOAP_FMAC2
    14514. 

  14514. soap_connect(struct soap *soap, const char *endpoint, const char *action)
    14515. 

  14515. { return soap_connect_command(soap, SOAP_POST, endpoint, action);
    14516. 

  14516. }
    14517. 

  14517. #endif
    14518. 

  14518. 

  14519. /******************************************************************************/
    14520. 

  14520. #ifndef PALM_1
    14521. 

  14521. SOAP_FMAC1
    14522. 

  14522. int
    14523. 

  14523. SOAP_FMAC2
    14524. 

  14524. soap_connect_command(struct soap *soap, int http_command, const char *endpoints, const char *action)
    14525. 

  14525. { char *endpoint;
    14526. 

  14526.   const char *s;
    14527. 

  14527.   if (endpoints && (s = strchr(endpoints, ' ')))
    14528. 

  14528.   { endpoint = (char*)SOAP_MALLOC(soap, strlen(endpoints) + 1);
    14529. 

  14529.     for (;;)
    14530. 

  14530.     { strncpy(endpoint, endpoints, s - endpoints);
    14531. 

  14531.       endpoint[s - endpoints] = '\0';
    14532. 

  14532.       if (soap_try_connect_command(soap, http_command, endpoint, action) != SOAP_TCP_ERROR)
    14533. 

  14533.         break;
    14534. 

  14534.       if (!*s)
    14535. 

  14535.         break;
    14536. 

  14536.       soap->error = SOAP_OK;
    14537. 

  14537.       while (*s == ' ')
    14538. 

  14538.         s++;
    14539. 

  14539.       endpoints = s;
    14540. 

  14540.       s = strchr(endpoints, ' ');
    14541. 

  14541.       if (!s)
    14542. 

  14542.         s = endpoints + strlen(endpoints);
    14543. 

  14543.     }
    14544. 

  14544.     SOAP_FREE(soap, endpoint);
    14545. 

  14545.   }
    14546. 

  14546.   else
    14547. 

  14547.     soap_try_connect_command(soap, http_command, endpoints, action);
    14548. 

  14548.   return soap->error;
    14549. 

  14549. }
    14550. 

  14550. #endif
    14551. 

  14551. 

  14552. /******************************************************************************/
    14553. 

  14553. #ifndef PALM_1
    14554. 

  14554. static int
    14555. 

  14555. soap_try_connect_command(struct soap *soap, int http_command, const char *endpoint, const char *action)
    14556. 

  14556. { char host[sizeof(soap->host)];
    14557. 

  14557.   int port;
    14558. 

  14558.   size_t count;
    14559. 

  14559.   soap->error = SOAP_OK;
    14560. 

  14560.   strcpy(host, soap->host); /* save previous host name: if != then reconnect */
    14561. 

  14561.   port = soap->port; /* save previous port to compare */
    14562. 

  14562.   soap->status = http_command;
    14563. 

  14563.   soap_set_endpoint(soap, endpoint);
    14564. 

  14564. #ifndef WITH_LEANER
    14565. 

  14565.   if (soap->fconnect)
    14566. 

  14566.   { if ((soap->error = soap->fconnect(soap, endpoint, soap->host, soap->port)))
    14567. 

  14567.       return soap->error;
    14568. 

  14568.   }
    14569. 

  14569.   else
    14570. 

  14570. #endif
    14571. 

  14571.   if (soap->fopen && *soap->host)
    14572. 

  14572.   { if (!soap->keep_alive || !soap_valid_socket(soap->socket) || strcmp(soap->host, host) || soap->port != port || !soap->fpoll || soap->fpoll(soap))
    14573. 

  14573.     { soap->keep_alive = 0; /* to force close */
    14574. 

  14574.       soap->omode &= ~SOAP_IO_UDP; /* to force close */
    14575. 

  14575.       soap_closesock(soap);
    14576. 

  14576.       DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Connect/reconnect to host='%s' path='%s' port=%d\n", soap->host, soap->path, soap->port));
    14577. 

  14577. #ifndef WITH_LEAN
    14578. 

  14578.       if (!strncmp(endpoint, "soap.udp:", 9))
    14579. 

  14579.         soap->omode |= SOAP_IO_UDP;
    14580. 

  14580. #endif
    14581. 

  14581.       soap->socket = soap->fopen(soap, endpoint, soap->host, soap->port);
    14582. 

  14582.       if (soap->error)
    14583. 

  14583.         return soap->error;
    14584. 

  14584.       soap->keep_alive = ((soap->omode & SOAP_IO_KEEPALIVE) != 0);
    14585. 

  14585.     }
    14586. 

  14586.   }
    14587. 

  14587.   count = soap_count_attachments(soap);
    14588. 

  14588.   if (soap_begin_send(soap))
    14589. 

  14589.     return soap->error;
    14590. 

  14590.   if (http_command == SOAP_GET)
    14591. 

  14591.   { soap->mode &= ~SOAP_IO;
    14592. 

  14592.     soap->mode |= SOAP_IO_BUFFER;
    14593. 

  14593.   }
    14594. 

  14594. #ifndef WITH_NOHTTP
    14595. 

  14595.   soap->action = soap_strdup(soap, action);
    14596. 

  14596.   if ((soap->mode & SOAP_IO) != SOAP_IO_STORE && !(soap->mode & SOAP_ENC_XML) && endpoint)
    14597. 

  14597.   { unsigned int k = soap->mode;
    14598. 

  14598.     soap->mode &= ~(SOAP_IO | SOAP_ENC_ZLIB);
    14599. 

  14599.     if ((k & SOAP_IO) != SOAP_IO_FLUSH)
    14600. 

  14600.       soap->mode |= SOAP_IO_BUFFER;
    14601. 

  14601.     if ((soap->error = soap->fpost(soap, endpoint, soap->host, soap->port, soap->path, action, count)))
    14602. 

  14602.       return soap->error;
    14603. 

  14603. #ifndef WITH_LEANER
    14604. 

  14604.     if ((k & SOAP_IO) == SOAP_IO_CHUNK)
    14605. 

  14605.     { if (soap_flush(soap))
    14606. 

  14606.         return soap->error;
    14607. 

  14607.     }
    14608. 

  14608. #endif
    14609. 

  14609.     soap->mode = k;
    14610. 

  14610.   }
    14611. 

  14611.   if (http_command == SOAP_GET)
    14612. 

  14612.     return soap_end_send(soap);
    14613. 

  14613. #endif
    14614. 

  14614.   return SOAP_OK;
    14615. 

  14615. }
    14616. 

  14616. #endif
    14617. 

  14617. 

  14618. /******************************************************************************/
    14619. 

  14619. #ifndef WITH_LEAN
    14620. 

  14620. SOAP_FMAC1
    14621. 

  14621. char*
    14622. 

  14622. SOAP_FMAC2
    14623. 

  14623. soap_s2base64(struct soap *soap, const unsigned char *s, char *t, int n)
    14624. 

  14624. { register int i;
    14625. 

  14625.   register unsigned long m;
    14626. 

  14626.   register char *p;
    14627. 

  14627.   if (!t)
    14628. 

  14628.     t = (char*)soap_malloc(soap, (n + 2) / 3 * 4 + 1);
    14629. 

  14629.   if (!t)
    14630. 

  14630.     return NULL;
    14631. 

  14631.   p = t;
    14632. 

  14632.   t[0] = '\0';
    14633. 

  14633.   if (!s)
    14634. 

  14634.     return p;
    14635. 

  14635.   for (; n > 2; n -= 3, s += 3)
    14636. 

  14636.   { m = s[0];
    14637. 

  14637.     m = (m << 8) | s[1];
    14638. 

  14638.     m = (m << 8) | s[2];
    14639. 

  14639.     for (i = 4; i > 0; m >>= 6)
    14640. 

  14640.       t[--i] = soap_base64o[m & 0x3F];
    14641. 

  14641.     t += 4;
    14642. 

  14642.   }
    14643. 

  14643.   t[0] = '\0';
    14644. 

  14644.   if (n > 0)
    14645. 

  14645.   { m = 0;
    14646. 

  14646.     for (i = 0; i < n; i++)
    14647. 

  14647.       m = (m << 8) | *s++;
    14648. 

  14648.     for (; i < 3; i++)
    14649. 

  14649.       m <<= 8;
    14650. 

  14650.     for (i++; i > 0; m >>= 6)
    14651. 

  14651.       t[--i] = soap_base64o[m & 0x3F];
    14652. 

  14652.     for (i = 3; i > n; i--)
    14653. 

  14653.       t[i] = '=';
    14654. 

  14654.     t[4] = '\0';
    14655. 

  14655.   }
    14656. 

  14656.   return p;
    14657. 

  14657. }
    14658. 

  14658. #endif
    14659. 

  14659. 

  14660. /******************************************************************************/
    14661. 

  14661. #ifndef WITH_LEAN
    14662. 

  14662. SOAP_FMAC1
    14663. 

  14663. const char*
    14664. 

  14664. SOAP_FMAC2
    14665. 

  14665. soap_base642s(struct soap *soap, const char *s, char *t, size_t l, int *n)
    14666. 

  14666. { register int i, j, c;
    14667. 

  14667.   register unsigned long m;
    14668. 

  14668.   register const char *p;
    14669. 

  14669.   if (!s || !*s)
    14670. 

  14670.   { if (n)
    14671. 

  14671.       *n = 0;
    14672. 

  14672.     if (soap->error)
    14673. 

  14673.       return NULL;
    14674. 

  14674.     return SOAP_NON_NULL;
    14675. 

  14675.   }
    14676. 

  14676.   if (!t)
    14677. 

  14677.   { l = (strlen(s) + 3) / 4 * 3;
    14678. 

  14678.     t = (char*)soap_malloc(soap, l);
    14679. 

  14679.   }
    14680. 

  14680.   if (!t)
    14681. 

  14681.     return NULL;
    14682. 

  14682.   p = t;
    14683. 

  14683.   if (n)
    14684. 

  14684.     *n = 0;
    14685. 

  14685.   for (;;)
    14686. 

  14686.   { for (i = 0; i < SOAP_BLKLEN; i++)
    14687. 

  14687.     { m = 0;
    14688. 

  14688.       j = 0;
    14689. 

  14689.       while (j < 4)
    14690. 

  14690.       { c = *s++;
    14691. 

  14691.         if (c == '=' || !c)
    14692. 

  14692.         { i *= 3;
    14693. 

  14693.           switch (j)
    14694. 

  14694.           { case 2:
    14695. 

  14695.               *t++ = (char)((m >> 4) & 0xFF);
    14696. 

  14696.               i++;
    14697. 

  14697.               break;
    14698. 

  14698.             case 3:
    14699. 

  14699.               *t++ = (char)((m >> 10) & 0xFF);
    14700. 

  14700.               *t++ = (char)((m >> 2) & 0xFF);
    14701. 

  14701.               i += 2;
    14702. 

  14702.           }
    14703. 

  14703.           if (n)
    14704. 

  14704.             *n += i;
    14705. 

  14705.           return p;
    14706. 

  14706.         }
    14707. 

  14707.         c -= '+';
    14708. 

  14708.         if (c >= 0 && c <= 79)
    14709. 

  14709.         { int b = soap_base64i[c];
    14710. 

  14710.           if (b >= 64)
    14711. 

  14711.           { soap->error = SOAP_TYPE;
    14712. 

  14712.             return NULL;  
    14713. 

  14713.           }
    14714. 

  14714.           m = (m << 6) + b;
    14715. 

  14715.           j++;
    14716. 

  14716.         }
    14717. 

  14717.         else if (!soap_blank(c + '+'))
    14718. 

  14718.         { soap->error = SOAP_TYPE;
    14719. 

  14719.           return NULL;  
    14720. 

  14720.         }
    14721. 

  14721.       }
    14722. 

  14722.       *t++ = (char)((m >> 16) & 0xFF);
    14723. 

  14723.       *t++ = (char)((m >> 8) & 0xFF);
    14724. 

  14724.       *t++ = (char)(m & 0xFF);
    14725. 

  14725.       if (l < 3)
    14726. 

  14726.       { if (n)
    14727. 

  14727.           *n += i;
    14728. 

  14728.         return p;
    14729. 

  14729.       }
    14730. 

  14730.       l -= 3;
    14731. 

  14731.     }
    14732. 

  14732.     if (n)
    14733. 

  14733.       *n += 3 * SOAP_BLKLEN;
    14734. 

  14734.   }
    14735. 

  14735. }
    14736. 

  14736. #endif
    14737. 

  14737. 

  14738. /******************************************************************************/
    14739. 

  14739. #ifndef WITH_LEAN
    14740. 

  14740. SOAP_FMAC1
    14741. 

  14741. char*
    14742. 

  14742. SOAP_FMAC2
    14743. 

  14743. soap_s2hex(struct soap *soap, const unsigned char *s, char *t, int n)
    14744. 

  14744. { register char *p;
    14745. 

  14745.   if (!t)
    14746. 

  14746.     t = (char*)soap_malloc(soap, 2 * n + 1);
    14747. 

  14747.   if (!t)
    14748. 

  14748.     return NULL;
    14749. 

  14749.   p = t;
    14750. 

  14750.   t[0] = '\0';
    14751. 

  14751.   if (s)
    14752. 

  14752.   { for (; n > 0; n--)
    14753. 

  14753.     { register int m = *s++;
    14754. 

  14754.       *t++ = (char)((m >> 4) + (m > 159 ? 'a' - 10 : '0'));
    14755. 

  14755.       m &= 0x0F;
    14756. 

  14756.       *t++ = (char)(m + (m > 9 ? 'a' - 10 : '0'));
    14757. 

  14757.     }
    14758. 

  14758.   }
    14759. 

  14759.   *t++ = '\0';
    14760. 

  14760.   return p;
    14761. 

  14761. }
    14762. 

  14762. #endif
    14763. 

  14763. 

  14764. /******************************************************************************/
    14765. 

  14765. #ifndef WITH_LEAN
    14766. 

  14766. SOAP_FMAC1
    14767. 

  14767. const char*
    14768. 

  14768. SOAP_FMAC2
    14769. 

  14769. soap_hex2s(struct soap *soap, const char *s, char *t, size_t l, int *n)
    14770. 

  14770. { register const char *p;
    14771. 

  14771.   if (!s || !*s)
    14772. 

  14772.   { if (n)
    14773. 

  14773.       *n = 0;
    14774. 

  14774.     if (soap->error)
    14775. 

  14775.       return NULL;
    14776. 

  14776.     return SOAP_NON_NULL;
    14777. 

  14777.   }
    14778. 

  14778.   if (!t)
    14779. 

  14779.   { l = strlen(s) / 2;
    14780. 

  14780.     t = (char*)soap_malloc(soap, l);
    14781. 

  14781.   }
    14782. 

  14782.   if (!t)
    14783. 

  14783.     return NULL;
    14784. 

  14784.   p = t;
    14785. 

  14785.   while (l)
    14786. 

  14786.   { register int d1, d2;
    14787. 

  14787.     d1 = *s++;
    14788. 

  14788.     if (!d1)
    14789. 

  14789.       break;
    14790. 

  14790.     d2 = *s++;
    14791. 

  14791.     if (!d2)
    14792. 

  14792.       break;
    14793. 

  14793.     *t++ = ((d1 >= 'A' ? (d1 & 0x7) + 9 : d1 - '0') << 4) + (d2 >= 'A' ? (d2 & 0x7) + 9 : d2 - '0');
    14794. 

  14794.     l--;
    14795. 

  14795.   }
    14796. 

  14796.   if (n)
    14797. 

  14797.     *n = (int)(t - p);
    14798. 

  14798.   return p;
    14799. 

  14799. }
    14800. 

  14800. #endif
    14801. 

  14801. 

  14802. /******************************************************************************/
    14803. 

  14803. #ifndef WITH_NOHTTP
    14804. 

  14804. #ifndef PALM_1
    14805. 

  14805. SOAP_FMAC1
    14806. 

  14806. int
    14807. 

  14807. SOAP_FMAC2
    14808. 

  14808. soap_puthttphdr(struct soap *soap, int status, size_t count)
    14809. 

  14809. { if (soap->status != SOAP_GET)
    14810. 

  14810.   { register const char *s = "text/xml; charset=utf-8";
    14811. 

  14811.     register int err = SOAP_OK;
    14812. 

  14812. #ifndef WITH_LEANER
    14813. 

  14813.     register const char *r = NULL;
    14814. 

  14814. #endif
    14815. 

  14815.     if ((status == SOAP_FILE || soap->status == SOAP_POST_FILE) && soap->http_content)
    14816. 

  14816.       s = soap->http_content;
    14817. 

  14817.     else if (status == SOAP_HTML)
    14818. 

  14818.       s = "text/html; charset=utf-8";
    14819. 

  14819.     else if (count || ((soap->omode & SOAP_IO) == SOAP_IO_CHUNK))
    14820. 

  14820.     { if (soap->version == 2)
    14821. 

  14821.         s = "application/soap+xml; charset=utf-8";
    14822. 

  14822.     }
    14823. 

  14823. #ifndef WITH_LEANER
    14824. 

  14824.     if (soap->mode & (SOAP_ENC_DIME | SOAP_ENC_MTOM))
    14825. 

  14825.     { if (soap->mode & SOAP_ENC_MTOM)
    14826. 

  14826.       { if (soap->version == 2)
    14827. 

  14827.           r = "application/soap+xml";
    14828. 

  14828. 	else
    14829. 

  14829.           r = "text/xml";
    14830. 

  14830.         s = "application/xop+xml";
    14831. 

  14831.       }
    14832. 

  14832.       else
    14833. 

  14833.         s = "application/dime";
    14834. 

  14834.     }
    14835. 

  14835.     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)
    14836. 

  14836.     { register const char *t = strchr(s, ';');
    14837. 

  14837.       sprintf(soap->tmpbuf, "multipart/related; charset=utf-8; boundary=\"%s\"; type=\"", soap->mime.boundary);
    14838. 

  14838.       if (t)
    14839. 

  14839.       { strncat(soap->tmpbuf, s, t - s);
    14840. 

  14840.         soap->tmpbuf[sizeof(soap->tmpbuf)-1] = '\0';
    14841. 

  14841.       }
    14842. 

  14842.       else
    14843. 

  14843.         strcat(soap->tmpbuf, s);
    14844. 

  14844.       if (soap->mime.start)
    14845. 

  14845.       { strcat(soap->tmpbuf, "\"; start=\"");
    14846. 

  14846.         strcat(soap->tmpbuf, soap->mime.start);
    14847. 

  14847.       }
    14848. 

  14848.       strcat(soap->tmpbuf, "\"");
    14849. 

  14849.       if (r)
    14850. 

  14850.       { strcat(soap->tmpbuf, "; start-info=\"");
    14851. 

  14851.         strcat(soap->tmpbuf, r);
    14852. 

  14852.         strcat(soap->tmpbuf, "\"");
    14853. 

  14853.       }
    14854. 

  14854.       s = soap->tmpbuf;
    14855. 

  14855.     }
    14856. 

  14856. #endif
    14857. 

  14857.     if (s && (err = soap->fposthdr(soap, "Content-Type", s)))
    14858. 

  14858.       return err;
    14859. 

  14859. #ifdef WITH_ZLIB
    14860. 

  14860.     if ((soap->omode & SOAP_ENC_ZLIB))
    14861. 

  14861.     { 
    14862. 

  14862. #ifdef WITH_GZIP
    14863. 

  14863.       err = soap->fposthdr(soap, "Content-Encoding", soap->zlib_out == SOAP_ZLIB_DEFLATE ? "deflate" : "gzip");
    14864. 

  14864. #else
    14865. 

  14865.       err = soap->fposthdr(soap, "Content-Encoding", "deflate");
    14866. 

  14866. #endif
    14867. 

  14867.       if (err)
    14868. 

  14868.         return err;
    14869. 

  14869.     }
    14870. 

  14870. #endif
    14871. 

  14871. #ifndef WITH_LEANER
    14872. 

  14872.     if ((soap->omode & SOAP_IO) == SOAP_IO_CHUNK)
    14873. 

  14873.       err = soap->fposthdr(soap, "Transfer-Encoding", "chunked");
    14874. 

  14874.     else
    14875. 

  14875. #endif
    14876. 

  14876.     if (s)
    14877. 

  14877.     { sprintf(soap->tmpbuf, "%lu", (unsigned long)count);
    14878. 

  14878.       err = soap->fposthdr(soap, "Content-Length", soap->tmpbuf);
    14879. 

  14879.     }
    14880. 

  14880.     if (err)
    14881. 

  14881.       return err;
    14882. 

  14882.   }
    14883. 

  14883.   return soap->fposthdr(soap, "Connection", soap->keep_alive ? "keep-alive" : "close");
    14884. 

  14884. }
    14885. 

  14885. #endif
    14886. 

  14886. #endif
    14887. 

  14887. 

  14888. /******************************************************************************/
    14889. 

  14889. #ifndef WITH_LEAN
    14890. 

  14890. static const char*
    14891. 

  14891. soap_set_validation_fault(struct soap *soap, const char *s, const char *t)
    14892. 

  14892. { if (*soap->tag)
    14893. 

  14893.     sprintf(soap->msgbuf, "Validation constraint violation: %s%s in element '%s'", s, t?t:SOAP_STR_EOS, soap->tag);
    14894. 

  14894.   else
    14895. 

  14895.     sprintf(soap->msgbuf, "Validation constraint violation: %s%s", s, t?t:SOAP_STR_EOS);
    14896. 

  14896.   return soap->msgbuf;
    14897. 

  14897. }
    14898. 

  14898. #endif
    14899. 

  14899. 

  14900. /******************************************************************************/
    14901. 

  14901. #ifndef PALM_1
    14902. 

  14902. SOAP_FMAC1
    14903. 

  14903. void
    14904. 

  14904. SOAP_FMAC2
    14905. 

  14905. soap_set_fault(struct soap *soap)
    14906. 

  14906. { const char **c = soap_faultcode(soap);
    14907. 

  14907.   const char **s = soap_faultstring(soap);
    14908. 

  14908.   if (soap->fseterror)
    14909. 

  14909.     soap->fseterror(soap, c, s);
    14910. 

  14910.   if (!*c)
    14911. 

  14911.   { if (soap->version == 2)
    14912. 

  14912.       *c = "SOAP-ENV:Sender";
    14913. 

  14913.     else
    14914. 

  14914.       *c = "SOAP-ENV:Client";
    14915. 

  14915.   }
    14916. 

  14916.   if (*s)
    14917. 

  14917.     return;
    14918. 

  14918.   switch (soap->error)
    14919. 

  14919.   {
    14920. 

  14920. #ifndef WITH_LEAN
    14921. 

  14921.     case SOAP_CLI_FAULT:
    14922. 

  14922.       *s = "Client fault";
    14923. 

  14923.       break;
    14924. 

  14924.     case SOAP_SVR_FAULT:
    14925. 

  14925.       *s = "Server fault";
    14926. 

  14926.       break;
    14927. 

  14927.     case SOAP_TAG_MISMATCH:
    14928. 

  14928.       *s = soap_set_validation_fault(soap, "tag name or namespace mismatch", NULL);
    14929. 

  14929.       break;
    14930. 

  14930.     case SOAP_TYPE:
    14931. 

  14931.       *s = soap_set_validation_fault(soap, "data type mismatch ", soap->type);
    14932. 

  14932.       break;
    14933. 

  14933.     case SOAP_SYNTAX_ERROR:
    14934. 

  14934.       *s = "Well-formedness violation";
    14935. 

  14935.       break;
    14936. 

  14936.     case SOAP_NO_TAG:
    14937. 

  14937.       *s = "No XML root element";
    14938. 

  14938.       break;
    14939. 

  14939.     case SOAP_MUSTUNDERSTAND:
    14940. 

  14940.       *c = "SOAP-ENV:MustUnderstand";
    14941. 

  14941.       sprintf(soap->msgbuf, "The data in element '%s' must be understood but cannot be handled", soap->tag);
    14942. 

  14942.       *s = soap->msgbuf;
    14943. 

  14943.       break;
    14944. 

  14944.     case SOAP_VERSIONMISMATCH:
    14945. 

  14945.       *c = "SOAP-ENV:VersionMismatch";
    14946. 

  14946.       *s = "Invalid SOAP message or SOAP version mismatch";
    14947. 

  14947.       break;
    14948. 

  14948.     case SOAP_DATAENCODINGUNKNOWN:
    14949. 

  14949.       *c = "SOAP-ENV:DataEncodingUnknown";
    14950. 

  14950.       *s = "Unsupported SOAP data encoding";
    14951. 

  14951.       break;
    14952. 

  14952.     case SOAP_NAMESPACE:
    14953. 

  14953.       *s = soap_set_validation_fault(soap, "namespace error", NULL);
    14954. 

  14954.       break;
    14955. 

  14955.     case SOAP_USER_ERROR:
    14956. 

  14956.       *s = "User error";
    14957. 

  14957.       break;
    14958. 

  14958.     case SOAP_FATAL_ERROR:
    14959. 

  14959.       *s = "Fatal error";
    14960. 

  14960.       break;
    14961. 

  14961.     case SOAP_NO_METHOD:
    14962. 

  14962.       sprintf(soap->msgbuf, "Method '%s' not implemented: method name or namespace not recognized", soap->tag);
    14963. 

  14963.       *s = soap->msgbuf;
    14964. 

  14964.       break;
    14965. 

  14965.     case SOAP_NO_DATA:
    14966. 

  14966.       *s = "Data required for operation";
    14967. 

  14967.       break;
    14968. 

  14968.     case SOAP_GET_METHOD:
    14969. 

  14969.       *s = "HTTP GET method not implemented";
    14970. 

  14970.       break;
    14971. 

  14971.     case SOAP_PUT_METHOD:
    14972. 

  14972.       *s = "HTTP PUT method not implemented";
    14973. 

  14973.       break;
    14974. 

  14974.     case SOAP_HEAD_METHOD:
    14975. 

  14975.       *s = "HTTP HEAD method not implemented";
    14976. 

  14976.       break;
    14977. 

  14977.     case SOAP_HTTP_METHOD:
    14978. 

  14978.       *s = "HTTP method not implemented";
    14979. 

  14979.       break;
    14980. 

  14980.     case SOAP_EOM:
    14981. 

  14981.       *s = "Out of memory";
    14982. 

  14982.       break;
    14983. 

  14983.     case SOAP_MOE:
    14984. 

  14984.       *s = "Memory overflow or memory corruption error";
    14985. 

  14985.       break;
    14986. 

  14986.     case SOAP_HDR:
    14987. 

  14987.       *s = "Header line too long";
    14988. 

  14988.       break;
    14989. 

  14989.     case SOAP_IOB:
    14990. 

  14990.       *s = "Array index out of bounds";
    14991. 

  14991.       break;
    14992. 

  14992.     case SOAP_NULL:
    14993. 

  14993.       *s = soap_set_validation_fault(soap, "nil not allowed", NULL);
    14994. 

  14994.       break;
    14995. 

  14995.     case SOAP_DUPLICATE_ID:
    14996. 

  14996.       *s = soap_set_validation_fault(soap, "multiple definitions of id ", soap->id);
    14997. 

  14997.       if (soap->version == 2)
    14998. 

  14998.         *soap_faultsubcode(soap) = "SOAP-ENC:DuplicateID";
    14999. 

  14999.       break;
    15000. 

  15000.     case SOAP_MISSING_ID:
    15001. 

  15001.       *s = soap_set_validation_fault(soap, "missing id for ref ", soap->id);
    15002. 

  15002.       if (soap->version == 2)
    15003. 

  15003.         *soap_faultsubcode(soap) = "SOAP-ENC:MissingID";
    15004. 

  15004.       break;
    15005. 

  15005.     case SOAP_HREF:
    15006. 

  15006.       *s = soap_set_validation_fault(soap, "incompatible object type ref/id pair ", soap->id);
    15007. 

  15007.       break;
    15008. 

  15008.     case SOAP_FAULT:
    15009. 

  15009.       break;
    15010. 

  15010. #ifndef WITH_NOIO
    15011. 

  15011.     case SOAP_UDP_ERROR:
    15012. 

  15012.       *s = "Message too large for UDP packet";
    15013. 

  15013.       break;
    15014. 

  15014.     case SOAP_TCP_ERROR:
    15015. 

  15015.       *s = tcp_error(soap);
    15016. 

  15016.       break;
    15017. 

  15017. #endif
    15018. 

  15018.     case SOAP_HTTP_ERROR:
    15019. 

  15019.       *s = "An HTTP processing error occurred";
    15020. 

  15020.       break;
    15021. 

  15021.     case SOAP_SSL_ERROR:
    15022. 

  15022. #ifdef WITH_OPENSSL
    15023. 

  15023.       *s = "SSL error";
    15024. 

  15024. #else
    15025. 

  15025.       *s = "OpenSSL not installed: recompile with -DWITH_OPENSSL";
    15026. 

  15026. #endif
    15027. 

  15027.       break;
    15028. 

  15028.     case SOAP_PLUGIN_ERROR:
    15029. 

  15029.       *s = "Plugin registry error";
    15030. 

  15030.       break;
    15031. 

  15031.     case SOAP_DIME_ERROR:
    15032. 

  15032.       *s = "DIME format error";
    15033. 

  15033.       break;
    15034. 

  15034.     case SOAP_DIME_HREF:
    15035. 

  15035.       *s = "DIME href to missing attachment";
    15036. 

  15036.       break;
    15037. 

  15037.     case SOAP_DIME_MISMATCH:
    15038. 

  15038.       *s = "DIME version/transmission error";
    15039. 

  15039.       break;
    15040. 

  15040.     case SOAP_DIME_END:
    15041. 

  15041.       *s = "End of DIME error";
    15042. 

  15042.       break;
    15043. 

  15043.     case SOAP_MIME_ERROR:
    15044. 

  15044.       *s = "MIME format error";
    15045. 

  15045.       break;
    15046. 

  15046.     case SOAP_MIME_HREF:
    15047. 

  15047.       *s = "MIME href to missing attachment";
    15048. 

  15048.       break;
    15049. 

  15049.     case SOAP_MIME_END:
    15050. 

  15050.       *s = "End of MIME error";
    15051. 

  15051.       break;
    15052. 

  15052.     case SOAP_ZLIB_ERROR:
    15053. 

  15053. #ifdef WITH_ZLIB
    15054. 

  15054.       sprintf(soap->msgbuf, "Zlib/gzip error: '%s'", soap->d_stream->msg?soap->d_stream->msg:SOAP_STR_EOS);
    15055. 

  15055.       *s = soap->msgbuf;
    15056. 

  15056. #else
    15057. 

  15057.       *s = "Zlib/gzip not installed for (de)compression: recompile with -DWITH_GZIP";
    15058. 

  15058. #endif
    15059. 

  15059.       break;
    15060. 

  15060.     case SOAP_REQUIRED:
    15061. 

  15061.       *s = soap_set_validation_fault(soap, "missing required attribute", NULL);
    15062. 

  15062.       break;
    15063. 

  15063.     case SOAP_PROHIBITED:
    15064. 

  15064.       *s = soap_set_validation_fault(soap, "prohibited attribute present", NULL);
    15065. 

  15065.       break;
    15066. 

  15066.     case SOAP_OCCURS:
    15067. 

  15067.       *s = soap_set_validation_fault(soap, "occurrence violation", NULL);
    15068. 

  15068.       break;
    15069. 

  15069.     case SOAP_LENGTH:
    15070. 

  15070.       *s = soap_set_validation_fault(soap, "content range or length violation", NULL);
    15071. 

  15071.       break;
    15072. 

  15072.     case SOAP_FD_EXCEEDED:
    15073. 

  15073.       *s = "Maximum number of open connections was reached (no define HAVE_POLL): increase FD_SETSIZE";
    15074. 

  15074.       break;
    15075. 

  15075.     case SOAP_STOP:
    15076. 

  15076.       *s = "Stopped: no response to be sent or received (informative)";
    15077. 

  15077.       break;
    15078. 

  15078. #endif
    15079. 

  15079.     case SOAP_EOF:
    15080. 

  15080. #ifndef WITH_NOIO
    15081. 

  15081.       strcpy(soap->msgbuf, soap_strerror(soap));
    15082. 

  15082. #ifndef WITH_LEAN
    15083. 

  15083.       if (strlen(soap->msgbuf) + 25 < sizeof(soap->msgbuf))
    15084. 

  15084.       { memmove(soap->msgbuf + 25, soap->msgbuf, strlen(soap->msgbuf) + 1);
    15085. 

  15085.         memcpy(soap->msgbuf, "End of file or no input: ", 25);
    15086. 

  15086.       }
    15087. 

  15087. #endif
    15088. 

  15088.       *s = soap->msgbuf;
    15089. 

  15089.       break;
    15090. 

  15090. #else
    15091. 

  15091.       *s = "End of file or no input";
    15092. 

  15092.       break;
    15093. 

  15093. #endif
    15094. 

  15094.     default:
    15095. 

  15095. #ifndef WITH_NOHTTP
    15096. 

  15096. #ifndef WITH_LEAN
    15097. 

  15097.       if (soap->error > 200 && soap->error < 600)
    15098. 

  15098.       { sprintf(soap->msgbuf, "HTTP Error: %d %s", soap->error, http_error(soap, soap->error));
    15099. 

  15099.         *s = soap->msgbuf;
    15100. 

  15100.       }
    15101. 

  15101.       else
    15102. 

  15102. #endif
    15103. 

  15103. #endif
    15104. 

  15104.       { sprintf(soap->msgbuf, "Error %d", soap->error);
    15105. 

  15105.         *s = soap->msgbuf;
    15106. 

  15106.       }
    15107. 

  15107.     }
    15108. 

  15108. }
    15109. 

  15109. #endif
    15110. 

  15110. 

  15111. /******************************************************************************/
    15112. 

  15112. #ifndef PALM_1
    15113. 

  15113. SOAP_FMAC1
    15114. 

  15114. int
    15115. 

  15115. SOAP_FMAC2
    15116. 

  15116. soap_send_fault(struct soap *soap)
    15117. 

  15117. { register int status = soap->error;
    15118. 

  15118.   if (status == SOAP_STOP)
    15119. 

  15119.     return soap_closesock(soap);
    15120. 

  15120.   DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Sending back fault struct for error code %d\n", soap->error));
    15121. 

  15121.   soap->keep_alive = 0; /* to terminate connection */
    15122. 

  15122.   soap_set_fault(soap);
    15123. 

  15123.   if (soap->error < 200 && soap->error != SOAP_FAULT)
    15124. 

  15124.     soap->header = NULL;
    15125. 

  15125.   if (status != SOAP_EOF || (!soap->recv_timeout && !soap->send_timeout))
    15126. 

  15126.   { int r = 1;
    15127. 

  15127. #ifndef WITH_NOIO
    15128. 

  15128.     if (soap->fpoll && soap->fpoll(soap))
    15129. 

  15129.       r = 0;
    15130. 

  15130. #ifndef WITH_LEAN
    15131. 

  15131.     else if (soap_valid_socket(soap->socket))
    15132. 

  15132.     { r = tcp_select(soap, soap->socket, SOAP_TCP_SELECT_RCV | SOAP_TCP_SELECT_SND, 0);
    15133. 

  15133.       if (r > 0)
    15134. 

  15134.       { if (!(r & SOAP_TCP_SELECT_SND)
    15135. 

  15135. 	 || ((r & SOAP_TCP_SELECT_RCV)
    15136. 

  15136.           && recv(soap->socket, soap->tmpbuf, 1, MSG_PEEK) < 0))
    15137. 

  15137.           r = 0;
    15138. 

  15138.       }
    15139. 

  15139.     }
    15140. 

  15140. #endif
    15141. 

  15141. #endif
    15142. 

  15142.     if (r > 0)
    15143. 

  15143.     { soap->error = SOAP_OK;
    15144. 

  15144.       soap_serializeheader(soap);
    15145. 

  15145.       soap_serializefault(soap);
    15146. 

  15146.       soap_begin_count(soap);
    15147. 

  15147.       if (soap->mode & SOAP_IO_LENGTH)
    15148. 

  15148.       { soap_envelope_begin_out(soap);
    15149. 

  15149.         soap_putheader(soap);
    15150. 

  15150.         soap_body_begin_out(soap);
    15151. 

  15151.         soap_putfault(soap);
    15152. 

  15152.         soap_body_end_out(soap);
    15153. 

  15153.         soap_envelope_end_out(soap);
    15154. 

  15154.       }
    15155. 

  15155.       soap_end_count(soap);
    15156. 

  15156.       if (soap_response(soap, status)
    15157. 

  15157.        || soap_envelope_begin_out(soap)
    15158. 

  15158.        || soap_putheader(soap)
    15159. 

  15159.        || soap_body_begin_out(soap)
    15160. 

  15160.        || soap_putfault(soap)
    15161. 

  15161.        || soap_body_end_out(soap)
    15162. 

  15162.        || soap_envelope_end_out(soap))
    15163. 

  15163.         return soap_closesock(soap);
    15164. 

  15164.       soap_end_send(soap);
    15165. 

  15165.     }
    15166. 

  15166.   } 
    15167. 

  15167.   soap->error = status;
    15168. 

  15168.   return soap_closesock(soap);
    15169. 

  15169. }
    15170. 

  15170. #endif
    15171. 

  15171. 

  15172. /******************************************************************************/
    15173. 

  15173. #ifndef PALM_1
    15174. 

  15174. SOAP_FMAC1
    15175. 

  15175. int
    15176. 

  15176. SOAP_FMAC2
    15177. 

  15177. soap_recv_fault(struct soap *soap, int check)
    15178. 

  15178. { register int status = soap->error;
    15179. 

  15179.   DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Check if receiving SOAP Fault\n"));
    15180. 

  15180.   if (!check)
    15181. 

  15181.   { /* try getfault when no tag or tag mismatched at level 2, otherwise ret */
    15182. 

  15182.     if (soap->error != SOAP_NO_TAG
    15183. 

  15183.      && (soap->error != SOAP_TAG_MISMATCH || soap->level != 2))
    15184. 

  15184.       return soap->error;
    15185. 

  15185.   }
    15186. 

  15186.   soap->error = SOAP_OK;
    15187. 

  15187.   if (soap_getfault(soap))
    15188. 

  15188.   { /* check flag set: check if SOAP Fault is present, if not just return */
    15189. 

  15189.     if (check && soap->error == SOAP_TAG_MISMATCH && soap->level == 2)
    15190. 

  15190.       return soap->error = SOAP_OK;
    15191. 

  15191.     DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Error: soap_get_soapfault() failed. Is this a SOAP message at all?\n"));
    15192. 

  15192.     *soap_faultcode(soap) = (soap->version == 2 ? "SOAP-ENV:Sender" : "SOAP-ENV:Client");
    15193. 

  15193.     soap->error = status;
    15194. 

  15194.     soap_set_fault(soap);
    15195. 

  15195.   }
    15196. 

  15196.   else
    15197. 

  15197.   { register const char *s = *soap_faultcode(soap);
    15198. 

  15198.     if (!soap_match_tag(soap, s, "SOAP-ENV:Server") || !soap_match_tag(soap, s, "SOAP-ENV:Receiver"))
    15199. 

  15199.       status = SOAP_SVR_FAULT; 
    15200. 

  15200.     else if (!soap_match_tag(soap, s, "SOAP-ENV:Client") || !soap_match_tag(soap, s, "SOAP-ENV:Sender"))
    15201. 

  15201.       status = SOAP_CLI_FAULT;
    15202. 

  15202.     else if (!soap_match_tag(soap, s, "SOAP-ENV:MustUnderstand"))
    15203. 

  15203.       status = SOAP_MUSTUNDERSTAND;
    15204. 

  15204.     else if (!soap_match_tag(soap, s, "SOAP-ENV:VersionMismatch"))
    15205. 

  15205.       status = SOAP_VERSIONMISMATCH;
    15206. 

  15206.     else
    15207. 

  15207.     { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Received SOAP Fault code %s\n", s));
    15208. 

  15208.       status = SOAP_FAULT;
    15209. 

  15209.     }
    15210. 

  15210.     if (!soap_body_end_in(soap))
    15211. 

  15211.       soap_envelope_end_in(soap);
    15212. 

  15212.   }
    15213. 

  15213.   soap_end_recv(soap);
    15214. 

  15214.   soap->error = status;
    15215. 

  15215.   return soap_closesock(soap);
    15216. 

  15216. }
    15217. 

  15217. #endif
    15218. 

  15218. 

  15219. /******************************************************************************/
    15220. 

  15220. #ifndef WITH_NOHTTP
    15221. 

  15221. #ifndef PALM_1
    15222. 

  15222. SOAP_FMAC1
    15223. 

  15223. int
    15224. 

  15224. SOAP_FMAC2
    15225. 

  15225. soap_send_empty_response(struct soap *soap, int httpstatuscode)
    15226. 

  15226. { register soap_mode m = soap->omode;
    15227. 

  15227.   soap->count = 0;
    15228. 

  15228.   if ((m & SOAP_IO) == SOAP_IO_CHUNK)
    15229. 

  15229.     soap->omode = (m & ~SOAP_IO) | SOAP_IO_BUFFER;
    15230. 

  15230.   if (soap_response(soap, httpstatuscode) || soap_end_send(soap))
    15231. 

  15231.   { soap->omode = m;
    15232. 

  15232.     return soap_closesock(soap);
    15233. 

  15233.   }
    15234. 

  15234.   soap->omode = m;
    15235. 

  15235.   return soap->error = SOAP_STOP; /* stops the server's response */
    15236. 

  15236. }
    15237. 

  15237. #endif
    15238. 

  15238. #endif
    15239. 

  15239. 

  15240. /******************************************************************************/
    15241. 

  15241. #ifndef WITH_NOHTTP
    15242. 

  15242. #ifndef PALM_1
    15243. 

  15243. SOAP_FMAC1
    15244. 

  15244. int
    15245. 

  15245. SOAP_FMAC2
    15246. 

  15246. soap_recv_empty_response(struct soap *soap)
    15247. 

  15247. { if (!soap_begin_recv(soap))
    15248. 

  15248.     soap_end_recv(soap);
    15249. 

  15249.   else if (soap->error == SOAP_NO_DATA || soap->error == 202)
    15250. 

  15250.     soap->error = SOAP_OK;
    15251. 

  15251.   return soap_closesock(soap);
    15252. 

  15252. }
    15253. 

  15253. #endif
    15254. 

  15254. #endif
    15255. 

  15255. 

  15256. /******************************************************************************/
    15257. 

  15257. #ifndef WITH_NOIO
    15258. 

  15258. #ifndef PALM_1
    15259. 

  15259. static const char*
    15260. 

  15260. soap_strerror(struct soap *soap)
    15261. 

  15261. { register int err = soap->errnum;
    15262. 

  15262.   if (err)
    15263. 

  15263.   {
    15264. 

  15264. #ifndef WIN32
    15265. 

  15265.     return strerror(err);
    15266. 

  15266. #else
    15267. 

  15267. #ifndef UNDER_CE
    15268. 

  15268.     DWORD len;
    15269. 

  15269.     *soap->msgbuf = '\0';
    15270. 

  15270.     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);
    15271. 

  15271. #else
    15272. 

  15272.     DWORD i, len;
    15273. 

  15273.     *soap->msgbuf = '\0';
    15274. 

  15274.     len = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, err, 0, (LPTSTR)soap->msgbuf, (DWORD)(sizeof(soap->msgbuf)/sizeof(TCHAR)), NULL);
    15275. 

  15275.     for (i = 0; i <= len; i++)
    15276. 

  15276.     { if (((TCHAR*)soap->msgbuf)[i] < 0x80)
    15277. 

  15277.         soap->msgbuf[i] = (char)((TCHAR*)soap->msgbuf)[i];
    15278. 

  15278.       else
    15279. 

  15279.         soap->msgbuf[i] = '?';
    15280. 

  15280.     }
    15281. 

  15281. #endif
    15282. 

  15282. #endif
    15283. 

  15283.   }
    15284. 

  15284.   else
    15285. 

  15285.   { char *s = soap->msgbuf;
    15286. 

  15286. #ifndef WITH_LEAN
    15287. 

  15287.     int rt = soap->recv_timeout, st = soap->send_timeout;
    15288. 

  15288.     int ru = ' ', su = ' ';
    15289. 

  15289. #endif
    15290. 

  15290.     strcpy(s, "Operation interrupted or timed out");
    15291. 

  15291. #ifndef WITH_LEAN
    15292. 

  15292.     if (rt < 0)
    15293. 

  15293.     { rt = -rt;
    15294. 

  15294.       ru = 'u';
    15295. 

  15295.     }
    15296. 

  15296.     if (st < 0)
    15297. 

  15297.     { st = -st;
    15298. 

  15298.       su = 'u';
    15299. 

  15299.     }
    15300. 

  15300.     if (rt)
    15301. 

  15301.       sprintf(s + strlen(s), " (%d%cs receive delay)", rt, ru);
    15302. 

  15302.     if (st)
    15303. 

  15303.       sprintf(s + strlen(s), " (%d%cs send delay)", st, su);
    15304. 

  15304. #endif
    15305. 

  15305.   }
    15306. 

  15306.   return soap->msgbuf;
    15307. 

  15307. }
    15308. 

  15308. #endif
    15309. 

  15309. #endif 
    15310. 

  15310. 

  15311. /******************************************************************************/
    15312. 

  15312. #ifndef PALM_2
    15313. 

  15313. static int
    15314. 

  15314. soap_set_error(struct soap *soap, const char *faultcode, const char *faultsubcodeQName, const char *faultstring, const char *faultdetailXML, int soaperror)
    15315. 

  15315. { *soap_faultcode(soap) = faultcode;
    15316. 

  15316.   if (faultsubcodeQName)
    15317. 

  15317.     *soap_faultsubcode(soap) = faultsubcodeQName;
    15318. 

  15318.   *soap_faultstring(soap) = faultstring;
    15319. 

  15319.   if (faultdetailXML && *faultdetailXML)
    15320. 

  15320.   { register const char **s = soap_faultdetail(soap);
    15321. 

  15321.     if (s)
    15322. 

  15322.       *s = faultdetailXML;
    15323. 

  15323.   }
    15324. 

  15324.   return soap->error = soaperror;
    15325. 

  15325. }
    15326. 

  15326. #endif
    15327. 

  15327. 

  15328. /******************************************************************************/
    15329. 

  15329. #ifndef PALM_2
    15330. 

  15330. SOAP_FMAC1
    15331. 

  15331. int
    15332. 

  15332. SOAP_FMAC2
    15333. 

  15333. soap_set_sender_error(struct soap *soap, const char *faultstring, const char *faultdetailXML, int soaperror)
    15334. 

  15334. { return soap_set_error(soap, soap->version == 2 ? "SOAP-ENV:Sender" : "SOAP-ENV:Client", NULL, faultstring, faultdetailXML, soaperror);
    15335. 

  15335. }
    15336. 

  15336. #endif
    15337. 

  15337. 

  15338. /******************************************************************************/
    15339. 

  15339. #ifndef PALM_2
    15340. 

  15340. SOAP_FMAC1
    15341. 

  15341. int
    15342. 

  15342. SOAP_FMAC2
    15343. 

  15343. soap_set_receiver_error(struct soap *soap, const char *faultstring, const char *faultdetailXML, int soaperror)
    15344. 

  15344. { return soap_set_error(soap, soap->version == 2 ? "SOAP-ENV:Receiver" : "SOAP-ENV:Server", NULL, faultstring, faultdetailXML, soaperror);
    15345. 

  15345. }
    15346. 

  15346. #endif
    15347. 

  15347. 

  15348. /******************************************************************************/
    15349. 

  15349. #ifndef PALM_2
    15350. 

  15350. static int
    15351. 

  15351. soap_copy_fault(struct soap *soap, const char *faultcode, const char *faultsubcodeQName, const char *faultstring, const char *faultdetailXML)
    15352. 

  15352. { char *r = NULL, *s = NULL, *t = NULL;
    15353. 

  15353.   if (faultsubcodeQName)
    15354. 

  15354.     r = soap_strdup(soap, faultsubcodeQName);
    15355. 

  15355.   if (faultstring)
    15356. 

  15356.     s = soap_strdup(soap, faultstring);
    15357. 

  15357.   if (faultdetailXML)
    15358. 

  15358.     t = soap_strdup(soap, faultdetailXML);
    15359. 

  15359.   return soap_set_error(soap, faultcode, r, s, t, SOAP_FAULT);
    15360. 

  15360. }
    15361. 

  15361. #endif
    15362. 

  15362. 

  15363. /******************************************************************************/
    15364. 

  15364. #ifndef PALM_2
    15365. 

  15365. SOAP_FMAC1
    15366. 

  15366. int
    15367. 

  15367. SOAP_FMAC2
    15368. 

  15368. soap_sender_fault(struct soap *soap, const char *faultstring, const char *faultdetailXML)
    15369. 

  15369. { return soap_sender_fault_subcode(soap, NULL, faultstring, faultdetailXML);
    15370. 

  15370. }
    15371. 

  15371. #endif
    15372. 

  15372. 

  15373. /******************************************************************************/
    15374. 

  15374. #ifndef PALM_2
    15375. 

  15375. SOAP_FMAC1
    15376. 

  15376. int
    15377. 

  15377. SOAP_FMAC2
    15378. 

  15378. soap_sender_fault_subcode(struct soap *soap, const char *faultsubcodeQName, const char *faultstring, const char *faultdetailXML)
    15379. 

  15379. { return soap_copy_fault(soap, soap->version == 2 ? "SOAP-ENV:Sender" : "SOAP-ENV:Client", faultsubcodeQName, faultstring, faultdetailXML);
    15380. 

  15380. }
    15381. 

  15381. #endif
    15382. 

  15382. 

  15383. /******************************************************************************/
    15384. 

  15384. #ifndef PALM_2
    15385. 

  15385. SOAP_FMAC1
    15386. 

  15386. int
    15387. 

  15387. SOAP_FMAC2
    15388. 

  15388. soap_receiver_fault(struct soap *soap, const char *faultstring, const char *faultdetailXML)
    15389. 

  15389. { return soap_receiver_fault_subcode(soap, NULL, faultstring, faultdetailXML);
    15390. 

  15390. }
    15391. 

  15391. #endif
    15392. 

  15392. 

  15393. /******************************************************************************/
    15394. 

  15394. #ifndef PALM_2
    15395. 

  15395. SOAP_FMAC1
    15396. 

  15396. int
    15397. 

  15397. SOAP_FMAC2
    15398. 

  15398. soap_receiver_fault_subcode(struct soap *soap, const char *faultsubcodeQName, const char *faultstring, const char *faultdetailXML)
    15399. 

  15399. { return soap_copy_fault(soap, soap->version == 2 ? "SOAP-ENV:Receiver" : "SOAP-ENV:Server", faultsubcodeQName, faultstring, faultdetailXML);
    15400. 

  15400. }
    15401. 

  15401. #endif
    15402. 

  15402. 

  15403. /******************************************************************************/
    15404. 

  15404. #ifndef PALM_2
    15405. 

  15405. #ifndef WITH_NOSTDLIB
    15406. 

  15406. SOAP_FMAC1
    15407. 

  15407. void
    15408. 

  15408. SOAP_FMAC2
    15409. 

  15409. soap_print_fault(struct soap *soap, FILE *fd)
    15410. 

  15410. { if (soap_check_state(soap))
    15411. 

  15411.     fprintf(fd, "Error: soap struct state not initialized\n");
    15412. 

  15412.   else if (soap->error)
    15413. 

  15413.   { const char *c, *v = NULL, *s, **d;
    15414. 

  15414.     d = soap_faultcode(soap);
    15415. 

  15415.     if (!*d)
    15416. 

  15416.       soap_set_fault(soap);
    15417. 

  15417.     c = *d;
    15418. 

  15418.     if (soap->version == 2)
    15419. 

  15419.       v = *soap_faultsubcode(soap);
    15420. 

  15420.     s = *soap_faultstring(soap);
    15421. 

  15421.     d = soap_faultdetail(soap);
    15422. 

  15422.     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 ? *d : "[no detail]");
    15423. 

  15423.   }
    15424. 

  15424. }
    15425. 

  15425. #endif
    15426. 

  15426. #endif
    15427. 

  15427.  
    15428. 

  15428. /******************************************************************************/
    15429. 

  15429. #ifdef __cplusplus
    15430. 

  15430. #ifndef WITH_LEAN
    15431. 

  15431. #ifndef WITH_NOSTDLIB
    15432. 

  15432. SOAP_FMAC1
    15433. 

  15433. void
    15434. 

  15434. SOAP_FMAC2
    15435. 

  15435. soap_stream_fault(struct soap *soap, std::ostream& os)
    15436. 

  15436. { if (soap_check_state(soap))
    15437. 

  15437.     os << "Error: soap struct state not initialized\n";
    15438. 

  15438.   else if (soap->error)
    15439. 

  15439.   { const char *c, *v = NULL, *s, **d;
    15440. 

  15440.     d = soap_faultcode(soap);
    15441. 

  15441.     if (!*d)
    15442. 

  15442.       soap_set_fault(soap);
    15443. 

  15443.     c = *d;
    15444. 

  15444.     if (soap->version == 2)
    15445. 

  15445.       v = *soap_faultsubcode(soap);
    15446. 

  15446.     s = *soap_faultstring(soap);
    15447. 

  15447.     d = soap_faultdetail(soap);
    15448. 

  15448.     os << (soap->version ? "SOAP 1." : "Error ")
    15449. 

  15449.        << (soap->version ? (int)soap->version : soap->error)
    15450. 

  15450.        << " fault: " << c
    15451. 

  15451.        << "[" << (v ? v : "no subcode") << "]"
    15452. 

  15452.        << std::endl
    15453. 

  15453.        << "\"" << (s ? s : "[no reason]") << "\""
    15454. 

  15454.        << std::endl
    15455. 

  15455.        << "Detail: " << (d && *d ? *d : "[no detail]")
    15456. 

  15456.        << std::endl;
    15457. 

  15457.   }
    15458. 

  15458. }
    15459. 

  15459. #endif
    15460. 

  15460. #endif
    15461. 

  15461. #endif
    15462. 

  15462.  
    15463. 

  15463. /******************************************************************************/
    15464. 

  15464. #ifndef WITH_LEAN
    15465. 

  15465. #ifndef WITH_NOSTDLIB
    15466. 

  15466. SOAP_FMAC1
    15467. 

  15467. char*
    15468. 

  15468. SOAP_FMAC2
    15469. 

  15469. soap_sprint_fault(struct soap *soap, char *buf, size_t len)
    15470. 

  15470. { if (soap_check_state(soap))
    15471. 

  15471.     strncpy(buf, "Error: soap struct not initialized", len);
    15472. 

  15472.   else if (soap->error)
    15473. 

  15473.   { const char *c, *v = NULL, *s, **d;
    15474. 

  15474.     d = soap_faultcode(soap);
    15475. 

  15475.     if (!*d)
    15476. 

  15476.       soap_set_fault(soap);
    15477. 

  15477.     c = *d;
    15478. 

  15478.     if (soap->version == 2)
    15479. 

  15479.       v = *soap_faultsubcode(soap);
    15480. 

  15480.     s = *soap_faultstring(soap);
    15481. 

  15481.     d = soap_faultdetail(soap);
    15482. 

  15482. #ifdef HAVE_SNPRINTF
    15483. 

  15483. # ifdef WIN32
    15484. 

  15484.     _snprintf
    15485. 

  15485. # else
    15486. 

  15486.     snprintf
    15487. 

  15487. # endif
    15488. 

  15488.       (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 ? *d : "[no detail]");
    15489. 

  15489. #else
    15490. 

  15490.     if (len > 40 + (v ? strlen(v) : 0) + (s ? strlen(s) : 0) + (d && *d ? strlen(*d) : 0))
    15491. 

  15491.       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 ? *d : "[no detail]");
    15492. 

  15492.     else if (len > 40)
    15493. 

  15493.       sprintf(buf, "%s%d fault: %s\n", soap->version ? "SOAP 1." : "Error ", soap->version ? (int)soap->version : soap->error, c);
    15494. 

  15494.     else
    15495. 

  15495.       buf[0] = '\0';
    15496. 

  15496. #endif
    15497. 

  15497.   }
    15498. 

  15498.   return buf;
    15499. 

  15499. }
    15500. 

  15500. #endif
    15501. 

  15501. #endif
    15502. 

  15502.  
    15503. 

  15503. /******************************************************************************/
    15504. 

  15504. #ifndef PALM_1
    15505. 

  15505. #ifndef WITH_NOSTDLIB
    15506. 

  15506. SOAP_FMAC1
    15507. 

  15507. void
    15508. 

  15508. SOAP_FMAC2
    15509. 

  15509. soap_print_fault_location(struct soap *soap, FILE *fd)
    15510. 

  15510. { 
    15511. 

  15511. #ifndef WITH_LEAN
    15512. 

  15512.   int i, j, c1, c2;
    15513. 

  15513.   if (soap->error && soap->error != SOAP_STOP && soap->bufidx <= soap->buflen && soap->buflen > 0 && soap->buflen <= SOAP_BUFLEN)
    15514. 

  15514.   { i = (int)soap->bufidx - 1;
    15515. 

  15515.     if (i <= 0)
    15516. 

  15516.       i = 0;
    15517. 

  15517.     c1 = soap->buf[i];
    15518. 

  15518.     soap->buf[i] = '\0';
    15519. 

  15519.     if ((int)soap->buflen >= i + 1024)
    15520. 

  15520.       j = i + 1023;
    15521. 

  15521.     else
    15522. 

  15522.       j = (int)soap->buflen - 1;
    15523. 

  15523.     c2 = soap->buf[j];
    15524. 

  15524.     soap->buf[j] = '\0';
    15525. 

  15525.     fprintf(fd, "%s%c\n<!-- ** HERE ** -->\n", soap->buf, c1);
    15526. 

  15526.     if (soap->bufidx < soap->buflen)
    15527. 

  15527.       fprintf(fd, "%s\n", soap->buf + soap->bufidx);
    15528. 

  15528.     soap->buf[i] = c1;
    15529. 

  15529.     soap->buf[j] = c2;
    15530. 

  15530.   }
    15531. 

  15531. #endif
    15532. 

  15532. }
    15533. 

  15533. #endif
    15534. 

  15534. #endif
    15535. 

  15535.  
    15536. 

  15536. /******************************************************************************/
    15537. 

  15537. #ifndef PALM_1
    15538. 

  15538. SOAP_FMAC1
    15539. 

  15539. int
    15540. 

  15540. SOAP_FMAC2
    15541. 

  15541. soap_register_plugin_arg(struct soap *soap, int (*fcreate)(struct soap*, struct soap_plugin*, void*), void *arg)
    15542. 

  15542. { register struct soap_plugin *p;
    15543. 

  15543.   register int r;
    15544. 

  15544.   if (!(p = (struct soap_plugin*)SOAP_MALLOC(soap, sizeof(struct soap_plugin))))
    15545. 

  15545.     return soap->error = SOAP_EOM;
    15546. 

  15546.   p->id = NULL;
    15547. 

  15547.   p->data = NULL;
    15548. 

  15548.   p->fcopy = NULL;
    15549. 

  15549.   p->fdelete = NULL;
    15550. 

  15550.   r = fcreate(soap, p, arg);
    15551. 

  15551.   if (!r && p->fdelete)
    15552. 

  15552.   { p->next = soap->plugins;
    15553. 

  15553.     soap->plugins = p;
    15554. 

  15554.     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Registered '%s' plugin\n", p->id));
    15555. 

  15555.     return SOAP_OK;
    15556. 

  15556.   }
    15557. 

  15557.   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));
    15558. 

  15558.   SOAP_FREE(soap, p);
    15559. 

  15559.   return r;
    15560. 

  15560. }
    15561. 

  15561. #endif
    15562. 

  15562. 

  15563. /******************************************************************************/
    15564. 

  15564. #ifndef PALM_1
    15565. 

  15565. static void *
    15566. 

  15566. fplugin(struct soap *soap, const char *id)
    15567. 

  15567. { register struct soap_plugin *p;
    15568. 

  15568.   for (p = soap->plugins; p; p = p->next)
    15569. 

  15569.     if (p->id == id || !strcmp(p->id, id))
    15570. 

  15570.       return p->data;
    15571. 

  15571.   return NULL;
    15572. 

  15572. }
    15573. 

  15573. #endif
    15574. 

  15574. 

  15575. /******************************************************************************/
    15576. 

  15576. #ifndef PALM_2
    15577. 

  15577. SOAP_FMAC1
    15578. 

  15578. void *
    15579. 

  15579. SOAP_FMAC2
    15580. 

  15580. soap_lookup_plugin(struct soap *soap, const char *id)
    15581. 

  15581. { return soap->fplugin(soap, id);
    15582. 

  15582. }
    15583. 

  15583. #endif
    15584. 

  15584. 

  15585. /******************************************************************************/
    15586. 

  15586. #ifdef __cplusplus
    15587. 

  15587. }
    15588. 

  15588. #endif
    15589. 

  15589. 

  15590. /******************************************************************************\
    15591. 

  15591.  *
    15592. 

  15592.  *	C++ soap struct methods
    15593. 

  15593.  *
    15594. 

  15594. \******************************************************************************/
    15595. 

  15595. 

  15596. #ifdef __cplusplus
    15597. 

  15597. soap::soap()
    15598. 

  15598. { soap_init(this);
    15599. 

  15599. }
    15600. 

  15600. #endif
    15601. 

  15601. 

  15602. /******************************************************************************/
    15603. 

  15603. #ifdef __cplusplus
    15604. 

  15604. soap::soap(soap_mode m)
    15605. 

  15605. { soap_init1(this, m);
    15606. 

  15606. }
    15607. 

  15607. #endif
    15608. 

  15608. 

  15609. /******************************************************************************/
    15610. 

  15610. #ifdef __cplusplus
    15611. 

  15611. soap::soap(soap_mode im, soap_mode om)
    15612. 

  15612. { soap_init2(this, im, om);
    15613. 

  15613. }
    15614. 

  15614. #endif
    15615. 

  15615. 

  15616. /******************************************************************************/
    15617. 

  15617. #ifdef __cplusplus
    15618. 

  15618. soap::soap(const struct soap& soap)
    15619. 

  15619. { soap_copy_context(this, &soap);
    15620. 

  15620. }
    15621. 

  15621. #endif
    15622. 

  15622. 

  15623. /******************************************************************************/
    15624. 

  15624. #ifdef __cplusplus
    15625. 

  15625. soap::~soap()
    15626. 

  15626. { soap_destroy(this);
    15627. 

  15627.   soap_end(this);
    15628. 

  15628.   soap_done(this);
    15629. 

  15629. }
    15630. 

  15630. #endif
    15631. 

  15631. 

  15632. /******************************************************************************/
    15633. 

  15633.