Changeset 19542 for trunk/Nebulous/nebclient/src/stdsoap2.c

Timestamp:

Sep 12, 2008, 3:15:59 PM (18 years ago)

Author:

jhoblitt

Message:

update to gSOAP 2.7.11

File:

• trunk/Nebulous/nebclient/src/stdsoap2.c (modified) (523 diffs)

trunk/Nebulous/nebclient/src/stdsoap2.c

@@ -1 +1 @@
 /*
-
-stdsoap2.c[pp] 2.7.0d
-
-Runtime environment.
+        stdsoap2.c[pp] 2.7.11-upd
+
+        gSOAP runtime engine
 
 gSOAP XML Web services tools
-Copyright (C) 2000-2004, Robert van Engelen, Genivia, Inc., All Rights Reserved.
-
+Copyright (C) 2000-2008, Robert van Engelen, Genivia Inc., All Rights Reserved.
+This part of the software is released under ONE of the following licenses:
+GPL, the gSOAP public license, OR Genivia's license for commercial use.
+--------------------------------------------------------------------------------
 Contributors:
 
-Wind River Systems, Inc., for the following additions (marked WR[...]):
+Wind River Systems Inc., for the following additions under gSOAP public license:
   - vxWorks compatible
-  - Support for IPv6.
-
 --------------------------------------------------------------------------------
 gSOAP public license.
@@ -26 +25 @@
 
 The Initial Developer of the Original Code is Robert A. van Engelen.
-Copyright (C) 2000-2004, Robert van Engelen, Genivia, Inc., All Rights Reserved.
+Copyright (C) 2000-2008, Robert van Engelen, Genivia Inc., All Rights Reserved.
 --------------------------------------------------------------------------------
 GPL license.
@@ -45 +44 @@
 Author contact information:
 engelen@genivia.com / engelen@acm.org
+
+This program is released under the GPL with the additional exemption that
+compiling, linking, and/or using OpenSSL is allowed.
+--------------------------------------------------------------------------------
+A commercial use license is available from Genivia, Inc., contact@genivia.com
 --------------------------------------------------------------------------------
 
@@ -60 +64 @@
 */
 
+#ifdef AS400
+# pragma convert(819)   /* EBCDIC to ASCII */
+#endif
+
 #include "stdsoap2.h"
 
+#ifdef __BORLANDC__
+# pragma warn -8060
+#else
+# ifdef WIN32
+#  ifdef UNDER_CE
+#   pragma comment(lib, "winsock.lib")
+#  else
+#   pragma comment(lib, "wsock32.lib")
+#  endif
+#  pragma warning(disable : 4996) /* disable deprecation warnings */
+# endif
+#endif
+
 #ifdef __cplusplus
-SOAP_SOURCE_STAMP("@(#) stdsoap2.cpp ver 2.7.0c 2004-09-27 12:00:00 GMT")
+SOAP_SOURCE_STAMP("@(#) stdsoap2.cpp ver 2.7.11 2008-07-26 00:00:00 GMT")
 extern "C" {
 #else
-SOAP_SOURCE_STAMP("@(#) stdsoap2.c ver 2.7.0c 2004-09-27 12:00:00 GMT")
-#endif
-
-/* 8bit character representing unknown/nonrepresentable character data (e.g. not supported by current locale) */
+SOAP_SOURCE_STAMP("@(#) stdsoap2.c ver 2.7.11 2008-07-26 00:00:00 GMT")
+#endif
+
+/* 8bit character representing unknown/nonrepresentable character data (e.g. not supported by current locale with multibyte support enabled) */
 #ifndef SOAP_UNKNOWN_CHAR
 #define SOAP_UNKNOWN_CHAR (127)
@@ -83 +104 @@
 #define soap_blank(c)           ((c) >= 0 && (c) <= 32)
 #define soap_notblank(c)        ((c) > 32)
-#define soap_hash_ptr(p)        (((unsigned long)(p) >> 3) & (SOAP_PTRHASH - 1))
-
+
+#if defined(WIN32) && !defined(UNDER_CE)
+#define soap_hash_ptr(p)        ((PtrToUlong(p) >> 3) & (SOAP_PTRHASH - 1))
+#else
+#define soap_hash_ptr(p)        ((size_t)(((unsigned long)(p) >> 3) & (SOAP_PTRHASH-1)))
+#endif
+
+#ifdef SOAP_DEBUG
+static void soap_init_logs(struct soap*);
+static void soap_close_logfile(struct soap*, int);
+static void soap_set_logfile(struct soap*, int, const char*);
+#endif
+
+#ifdef SOAP_MEM_DEBUG
+static void soap_init_mht(struct soap*);
+static void soap_free_mht(struct soap*);
+static void soap_track_unlink(struct soap*, const void*);
+#endif
+
+#ifndef PALM_2
+static int soap_set_error(struct soap*, const char*, const char*, const char*, const char*, int);
+static int soap_copy_fault(struct soap*, const char*, const char*, const char*, const char*);
+static int soap_getattrval(struct soap*, char*, size_t, soap_wchar);
+#endif
+
+#ifndef PALM_1
+static soap_wchar soap_char(struct soap*);
+static soap_wchar soap_get_pi(struct soap*);
 static int soap_isxdigit(int);
-static soap_wchar soap_char(struct soap*);
-static soap_wchar soap_getchunkchar(struct soap*);
-static void soap_update_ptrs(struct soap*, char*, char*, long);
+static void *fplugin(struct soap*, const char*);
+#ifndef WITH_NOIDREF
+static void soap_update_ptrs(struct soap*, char*, char*, char*, char*);
 static int soap_has_copies(struct soap*, const char*, const char*);
-static struct soap_ilist *soap_hlookup(struct soap*, const char*);
 static void soap_init_iht(struct soap*);
 static void soap_free_iht(struct soap*);
 static void soap_init_pht(struct soap*);
 static void soap_free_pht(struct soap*);
-static int soap_set_error(struct soap*, const char*, const char*, const char*, int);
+#endif
+#endif
+
+#ifndef WITH_LEAN
 static const char *soap_set_validation_fault(struct soap*, const char*, const char*);
-static int soap_copy_fault(struct soap*, const char*, const char*, const char*);
-static int soap_getattrval(struct soap*, char*, size_t, soap_wchar);
-static void soap_set_local_namespaces(struct soap*);
 static int soap_isnumeric(struct soap*, const char*);
-static void *fplugin(struct soap*, const char*);
-static const char *soap_decode(char*, size_t, const char*, const char*);
-
-#ifndef WITH_LEAN
-static time_t soap_timegm(struct tm*);
-#endif
-
-#ifdef SOAP_DEBUG
-static void soap_init_logs(struct soap*);
-static void soap_close_logfile(struct soap*, int);
-static void soap_set_logfile(struct soap*, int, const char*);
-#endif
-
-#ifdef WITH_FAST
-static int soap_append_lab(struct soap*, const char*, size_t);
+static struct soap_nlist *soap_push_ns(struct soap *soap, const char *id, const char *ns, short utilized);
+static void soap_pop_ns(struct soap *soap);
+static void soap_utilize_ns(struct soap *soap, const char *tag, size_t n);
 #endif
 
 #ifndef WITH_LEANER
+#ifndef PALM_1
 static struct soap_multipart *soap_new_multipart(struct soap*, struct soap_multipart**, struct soap_multipart**, char*, size_t);
 static int soap_putdimefield(struct soap*, const char*, size_t);
@@ -124 +159 @@
 static void soap_select_mime_boundary(struct soap*);
 static int soap_valid_mime_boundary(struct soap*);
+static void soap_resolve_attachment(struct soap*, struct soap_multipart*);
+#endif
 #endif
 
@@ -131 +168 @@
 
 #ifdef WITH_OPENSSL
+int soap_ssl_init_done = 0;
+
 static int ssl_auth_init(struct soap*);
 static int ssl_verify_callback(int, X509_STORE_CTX*);
+static int ssl_verify_callback_allow_expired_certificate(int, X509_STORE_CTX*);
 static int ssl_password(char*, int, int, void *);
-static const char *ssl_error(struct soap*, int);
-/* This callback is included for future references. It should not be deleted
+/* The callback below is included for future references:
 static DH *ssl_tmp_dh(SSL*, int, int);
 */
 #endif
 
-static const char *soap_strerror(struct soap*);
-static const char *tcp_error(struct soap*);
+#if !defined(WITH_NOHTTP) || !defined(WITH_LEANER)
+#ifndef PALM_1
+static const char *soap_decode(char*, size_t, const char*, const char*);
+#endif
+#endif
+
+#ifndef WITH_NOHTTP
+#ifndef PALM_1
+static soap_wchar soap_getchunkchar(struct soap*);
 static const char *http_error(struct soap*, int);
 static int http_post(struct soap*, const char*, const char*, int, const char*, const char*, size_t);
 static int http_get(struct soap*);
+static int http_put(struct soap*);
+static int http_del(struct soap*);
+static int http_head(struct soap*);
 static int http_send_header(struct soap*, const char*);
 static int http_post_header(struct soap*, const char*, const char*);
@@ -150 +199 @@
 static int http_parse(struct soap*);
 static int http_parse_header(struct soap*, const char*, const char*);
-#ifndef MAC_CARBON
+#endif
+#endif
+
+#ifndef WITH_NOIO
+
+#ifndef PALM_1
+static int fsend(struct soap*, const char*, size_t);
+static size_t frecv(struct soap*, char*, size_t);
+static int tcp_init(struct soap*);
+static const char *tcp_error(struct soap*);
+#ifndef WITH_LEAN
+static size_t frecv_stop(struct soap*, char*, size_t);
+#endif
+#ifndef WITH_IPV6
 static int tcp_gethost(struct soap*, const char *addr, struct in_addr *inaddr);
-static int tcp_connect(struct soap*, const char *endpoint, const char *host, int port);
-static int tcp_accept(struct soap*, int, struct sockaddr*, int*);
+#endif
+static SOAP_SOCKET tcp_connect(struct soap*, const char *endpoint, const char *host, int port);
+static SOAP_SOCKET tcp_accept(struct soap*, SOAP_SOCKET, struct sockaddr*, int*);
 static int tcp_disconnect(struct soap*);
 static int tcp_closesocket(struct soap*, SOAP_SOCKET);
 static int tcp_shutdownsocket(struct soap*, SOAP_SOCKET, int);
-static int fsend(struct soap*, const char*, size_t);
-static size_t frecv(struct soap*, char*, size_t);
-#endif
-
-/* WR[ */
-#ifdef VXWORKS
-static int vx_nonblocking = TRUE; /* ioctl argument */
-#endif
-/* ]WR */
+static const char *soap_strerror(struct soap*);
+#endif
+
+#if defined(WIN32)
+  #define SOAP_SOCKBLOCK(fd) \
+  { u_long blocking = 0; \
+    ioctlsocket(fd, FIONBIO, &blocking); \
+  }
+  #define SOAP_SOCKNONBLOCK(fd) \
+  { u_long nonblocking = 1; \
+    ioctlsocket(fd, FIONBIO, &nonblocking); \
+  }
+#elif defined(VXWORKS)
+  #define SOAP_SOCKBLOCK(fd) \
+  { u_long blocking = 0; \
+    ioctl(fd, FIONBIO, (int)(&blocking)); \
+  }
+  #define SOAP_SOCKNONBLOCK(fd) \
+  { u_long nonblocking = 1; \
+    ioctl(fd, FIONBIO, (int)(&nonblocking)); \
+  }
+#elif defined(PALM)
+  #define SOAP_SOCKBLOCK(fd) fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0)&~O_NONBLOCK);
+  #define SOAP_SOCKNONBLOCK(fd) fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0)|O_NONBLOCK);
+#elif defined(SYMBIAN)
+  #define SOAP_SOCKBLOCK(fd) \
+  { long blocking = 0; \
+    ioctl(fd, 0/*FIONBIO*/, &blocking); \
+  }
+  #define SOAP_SOCKNONBLOCK(fd) \
+  { long nonblocking = 1; \
+    ioctl(fd, 0/*FIONBIO*/, &nonblocking); \
+  }
+#else
+  #define SOAP_SOCKBLOCK(fd) fcntl(fd, F_SETFL, fcntl(fd, F_GETFL)&~O_NONBLOCK);
+  #define SOAP_SOCKNONBLOCK(fd) fcntl(fd, F_SETFL, fcntl(fd, F_GETFL)|O_NONBLOCK);
+#endif
+
+#endif
 
 #if defined(PALM) && !defined(PALM_2)
@@ -185 +278 @@
 #endif
 
-static const char soap_padding[3] = "\0\0";
+#ifndef WITH_LEAN
+static const char soap_indent[11] = "\n\t\t\t\t\t\t\t\t\t";
+/* Alternative indentation form for SOAP_XML_INDENT:
+static const char soap_indent[21] = "\n                   ";
+*/
+#endif
+
+#ifndef SOAP_CANARY
+# define SOAP_CANARY (0xC0DE)
+#endif
+
+static const char soap_padding[4] = "\0\0\0";
 #define SOAP_STR_PADDING (soap_padding)
 #define SOAP_STR_EOS (soap_padding)
+#define SOAP_NON_NULL (soap_padding)
 
 #ifndef WITH_LEAN
@@ -291 +396 @@
 #endif
 
+#ifndef WITH_NOIO
 #ifndef WITH_LEAN
 static const struct soap_code_map h_error_codes[] =
@@ -312 +418 @@
 };
 #endif
-
+#endif
+
+#ifndef WITH_NOHTTP
 #ifndef WITH_LEAN
 static const struct soap_code_map h_http_error_codes[] =
-{ { 201, "Created" },
+{ { 200, "OK" },
+  { 201, "Created" },
   { 202, "Accepted" },
   { 203, "Non-Authoritative Information" },
@@ -355 +464 @@
 };
 #endif
+#endif
 
 #ifdef WITH_OPENSSL
@@ -388 +498 @@
 #endif
 
-/******************************************************************************/
-#ifndef MAC_CARBON
+#if defined(HP_UX) && defined(HAVE_GETHOSTBYNAME_R)
+extern int h_errno;
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOIO
 #ifndef PALM_1
 static int
 fsend(struct soap *soap, const char *s, size_t n)
-{ register int nwritten;
+{ register int nwritten, err;
 #if defined(__cplusplus) && !defined(WITH_LEAN)
   if (soap->os)
-  { soap->os->write(s, n);
+  { soap->os->write(s, (std::streamsize)n);
     if (soap->os->good())
       return SOAP_OK;
+    soap->errnum = 0;
     return SOAP_EOF;
   }
@@ -407 +522 @@
 #ifndef WITH_LEAN
       if (soap->send_timeout)
-      { struct timeval timeout;
-        fd_set fd;
-        if (soap->send_timeout > 0)
-        { timeout.tv_sec = soap->send_timeout;
-          timeout.tv_usec = 0;
-        }
-        else
-        { timeout.tv_sec = -soap->send_timeout/1000000;
-          timeout.tv_usec = -soap->send_timeout%1000000;
-        }
-        FD_ZERO(&fd);
-        FD_SET((SOAP_SOCKET)soap->socket, &fd);
+      {
+#ifndef WIN32
+        if ((int)soap->socket >= (int)FD_SETSIZE)
+          return SOAP_FD_EXCEEDED;      /* Hint: MUST increase FD_SETSIZE */
+#endif
         for (;;)
-        { register int r = select((SOAP_SOCKET)(soap->socket + 1), NULL, &fd, &fd, &timeout);
+        { struct timeval timeout;
+          fd_set fd;
+          register int r;
+          if (soap->send_timeout > 0)
+          { timeout.tv_sec = soap->send_timeout;
+            timeout.tv_usec = 0;
+          }
+          else
+          { timeout.tv_sec = -soap->send_timeout/1000000;
+            timeout.tv_usec = -soap->send_timeout%1000000;
+          }
+          FD_ZERO(&fd);
+          FD_SET(soap->socket, &fd);
+#ifdef WITH_OPENSSL
+          if (soap->ssl)
+            r = select((int)soap->socket + 1, &fd, &fd, &fd, &timeout);
+          else
+#endif
+          r = select((int)soap->socket + 1, NULL, &fd, &fd, &timeout);
           if (r > 0)
             break;
@@ -427 +553 @@
             return SOAP_EOF;
           }
-          if (soap_socket_errno != SOAP_EINTR)
-          { soap->errnum = soap_socket_errno;
+          err = soap_socket_errno(soap->socket);
+          if (err != SOAP_EINTR && err != SOAP_EAGAIN && err != SOAP_EWOULDBLOCK)
+          { soap->errnum = err;
             return SOAP_EOF;
           }
@@ -436 +563 @@
 #ifdef WITH_OPENSSL
       if (soap->ssl)
-        nwritten = SSL_write(soap->ssl, s, n);
+        nwritten = SSL_write(soap->ssl, s, (int)n);
+      else if (soap->bio)
+        nwritten = BIO_write(soap->bio, s, (int)n);
       else
 #endif
-#ifndef PALM
-        nwritten = send((SOAP_SOCKET)soap->socket, s, n, soap->socket_flags);
+#ifndef WITH_LEAN
+      if ((soap->omode & SOAP_IO_UDP))
+      { if (soap->peerlen)
+          nwritten = sendto(soap->socket, s, (SOAP_WINSOCKINT)n, soap->socket_flags, (struct sockaddr*)&soap->peer, (SOAP_WINSOCKINT)soap->peerlen);
+        else
+          nwritten = send(soap->socket, s, (SOAP_WINSOCKINT)n, soap->socket_flags);
+        /* retry and back-off algorithm */
+        /* TODO: this is not very clear from specs so verify and limit conditions under which we should loop (e.g. ENOBUFS) */
+        if (nwritten < 0)
+        { struct timeval timeout;
+          fd_set fd;
+          int udp_repeat;
+          int udp_delay;
+#ifndef WIN32
+          if ((int)soap->socket >= (int)FD_SETSIZE)
+            return SOAP_FD_EXCEEDED;    /* Hint: MUST increase FD_SETSIZE */
+#endif
+          if ((soap->connect_flags & SO_BROADCAST))
+            udp_repeat = 3; /* SOAP-over-UDP MULTICAST_UDP_REPEAT - 1 */
+          else
+            udp_repeat = 1; /* SOAP-over-UDP UNICAST_UDP_REPEAT - 1 */
+          udp_delay = (soap_random % 201) + 50; /* UDP_MIN_DELAY .. UDP_MAX_DELAY */
+          do
+          { timeout.tv_sec = 0;
+            timeout.tv_usec = 1000 * udp_delay; /* ms */
+            FD_ZERO(&fd);
+            FD_SET(soap->socket, &fd);
+            select((int)soap->socket + 1, NULL, NULL, &fd, &timeout);
+            if (soap->peerlen)
+              nwritten = sendto(soap->socket, s, (SOAP_WINSOCKINT)n, soap->socket_flags, (struct sockaddr*)&soap->peer, (SOAP_WINSOCKINT)soap->peerlen);
+            else
+              nwritten = send(soap->socket, s, (SOAP_WINSOCKINT)n, soap->socket_flags);
+            udp_delay <<= 1;
+            if (udp_delay > 500) /* UDP_UPPER_DELAY */
+              udp_delay = 500;
+          }
+          while (nwritten < 0 && --udp_repeat > 0);
+        }
+      }
+      else
+#endif
+#if !defined(PALM) && !defined(AS400)
+        nwritten = send(soap->socket, s, (int)n, soap->socket_flags);
 #else
-        nwritten = send((SOAP_SOCKET)soap->socket, (void*)s, n, soap->socket_flags);
+        nwritten = send(soap->socket, (void*)s, n, soap->socket_flags);
 #endif
       if (nwritten <= 0)
       {
+#if defined(WITH_OPENSSL) || !defined(WITH_LEAN)
+        register int r = 0;
+#endif
+        err = soap_socket_errno(soap->socket);
 #ifdef WITH_OPENSSL
-        int err;
-        if (soap->ssl && (err = SSL_get_error(soap->ssl, nwritten)) != SSL_ERROR_NONE && err != SSL_ERROR_WANT_READ && err != SSL_ERROR_WANT_WRITE)
+        if (soap->ssl && (r = SSL_get_error(soap->ssl, nwritten)) != SSL_ERROR_NONE && r != SSL_ERROR_WANT_READ && r != SSL_ERROR_WANT_WRITE)
+        { soap->errnum = err;
           return SOAP_EOF;
-#endif
-        if (soap_socket_errno != SOAP_EINTR && soap_socket_errno != SOAP_EWOULDBLOCK && soap_socket_errno != SOAP_EAGAIN)
-        { soap->errnum = soap_socket_errno;
+        }
+#endif
+        if (err == SOAP_EWOULDBLOCK || err == SOAP_EAGAIN)
+        {
+#ifndef WITH_LEAN
+          struct timeval timeout;
+          fd_set fd;
+#ifndef WIN32
+          if ((int)soap->socket >= (int)FD_SETSIZE)
+            return SOAP_FD_EXCEEDED; /* Hint: MUST increase FD_SETSIZE */
+#endif
+          if (soap->send_timeout > 0)
+          { timeout.tv_sec = soap->send_timeout;
+            timeout.tv_usec = 0;
+          }
+          else if (soap->send_timeout < 0)
+          { timeout.tv_sec = -soap->send_timeout/1000000;
+            timeout.tv_usec = -soap->send_timeout%1000000;
+          }
+          else
+          { timeout.tv_sec = 0;
+            timeout.tv_usec = 10000;
+          }
+          FD_ZERO(&fd);
+          FD_SET(soap->socket, &fd);
+#ifdef WITH_OPENSSL
+          if (soap->ssl && r == SSL_ERROR_WANT_READ)
+            r = select((int)soap->socket + 1, &fd, NULL, &fd, &timeout);
+          else
+            r = select((int)soap->socket + 1, NULL, &fd, &fd, &timeout);
+#else
+          r = select((int)soap->socket + 1, NULL, &fd, &fd, &timeout);
+#endif
+          if (r < 0 && (r = soap_socket_errno(soap->socket)) != SOAP_EINTR)
+          { soap->errnum = r;
+            return SOAP_EOF;
+          }
+#endif
+        }
+        else if (err && err != SOAP_EINTR)
+        { soap->errnum = err;
           return SOAP_EOF;
         }
@@ -467 +679 @@
       nwritten = fwrite(s, 1, n, soap->sendfd);
 #else
-/* WR[ */
 #ifdef VXWORKS
 #ifdef WMW_RPM_IO
       if (soap->rpmreqid)
-          {
-          httpBlockPut(soap->rpmreqid, s, n); 
-          nwritten = n;
-          }
+        nwritten = (httpBlockPut(soap->rpmreqid, s, n) == 0) ? n : -1; 
       else
-          {
-          nwritten = fwrite(s, sizeof(char), n, fdopen(soap->sendfd, "w"));
-          }
+#endif
+        nwritten = fwrite(s, sizeof(char), n, fdopen(soap->sendfd, "w"));
 #else
-      nwritten = fwrite(s, sizeof(char), n, fdopen(soap->sendfd, "w"));
-#endif /* WMW_RPM_IO */
+      nwritten = write(soap->sendfd, s, (unsigned int)n);
+#endif
+#endif
+#endif
+      if (nwritten <= 0)
+      { 
+#ifndef WITH_FASTCGI
+        err = soap_errno;
 #else
-/* ]WR */
-      nwritten = write((SOAP_SOCKET)soap->sendfd, s, n);
-/* WR[ */
-#endif
-/* ]WR */
-#endif
-#endif
-      if (nwritten <= 0)
-      { if (soap_errno != SOAP_EINTR && soap_errno != SOAP_EWOULDBLOCK && soap_errno != SOAP_EAGAIN)
-        { soap->errnum = soap_errno;
+        err = EOF;
+#endif
+        if (err && err != SOAP_EINTR && err != SOAP_EWOULDBLOCK && err != SOAP_EAGAIN)
+        { soap->errnum = err;
           return SOAP_EOF;
         }
@@ -504 +711 @@
 }
 #endif
-#endif
-
-/******************************************************************************/
-#ifndef PALM_1
-SOAP_FMAC1
-int
-SOAP_FMAC2
-soap_flush_raw(struct soap *soap, const char *s, size_t n)
-{ if ((soap->mode & SOAP_IO) == SOAP_IO_STORE)
-  { register char *t;
-    if (!(t = (char*)soap_push_block(soap, n)))
-      return soap->error = SOAP_EOM;
-    memcpy(t, s, n);
-    if (soap->fpreparesend)
-      return soap->fpreparesend(soap, s, n);
-    return SOAP_OK;
-  }
-  if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK)
-  { char t[16];
-    sprintf(t, "\r\n%lX\r\n" + (soap->chunksize ? 0 : 2), (unsigned long)n);
-    DBGMSG(SENT, t, strlen(t));
-    if ((soap->error = soap->fsend(soap, t, strlen(t))))
-      return soap->error;
-    soap->chunksize += n;
-  }
-  DBGMSG(SENT, s, n);
-  return soap->error = soap->fsend(soap, s, n);
-}
-#endif
-
-/******************************************************************************/
-#ifndef PALM_1
-SOAP_FMAC1
-int
-SOAP_FMAC2
-soap_flush(struct soap *soap)
-{ if (soap->bufidx)
-  {
-#ifdef WITH_ZLIB
-    if (soap->mode & SOAP_ENC_ZLIB)
-    { soap->d_stream.next_in = (Byte*)soap->buf;
-      soap->d_stream.avail_in = (unsigned int)soap->bufidx;
-#ifdef WITH_GZIP
-      soap->z_crc = crc32(soap->z_crc, (Byte*)soap->buf, (unsigned int)soap->bufidx);
-#endif
-      do
-      { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Deflating %u bytes\n", soap->d_stream.avail_in));
-        if (deflate(&soap->d_stream, Z_NO_FLUSH) != Z_OK)
-        { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unable to deflate: %s\n", soap->d_stream.msg?soap->d_stream.msg:""));
-          return soap->error = SOAP_ZLIB_ERROR;
-        }
-        if (!soap->d_stream.avail_out)
-        { if (soap_flush_raw(soap, soap->z_buf, SOAP_BUFLEN))
-            return soap->error;
-          soap->d_stream.next_out = (Byte*)soap->z_buf;
-          soap->d_stream.avail_out = SOAP_BUFLEN;
-        }
-      } while (soap->d_stream.avail_in);
-    }
-    else
-#endif
-    if (soap_flush_raw(soap, soap->buf, soap->bufidx))
-      return soap->error;
-    soap->bufidx = 0;
-  }
-  return SOAP_OK;
-}
 #endif
 
@@ -583 +723 @@
   if (soap->mode & SOAP_IO_LENGTH)
   { soap->count += n;
+#ifndef WITH_LEANER
     if (soap->fpreparesend && (soap->mode & SOAP_IO) != SOAP_IO_STORE)
-      return soap->fpreparesend(soap, s, n);
+      return soap->error = soap->fpreparesend(soap, s, n);
+#endif
     return SOAP_OK;
   }
@@ -611 +753 @@
 int
 SOAP_FMAC2
+soap_flush(struct soap *soap)
+{ register size_t n = soap->bufidx;
+  if (n)
+  { soap->bufidx = 0;
+#ifdef WITH_ZLIB
+    if (soap->mode & SOAP_ENC_ZLIB)
+    { soap->d_stream->next_in = (Byte*)soap->buf;
+      soap->d_stream->avail_in = (unsigned int)n;
+#ifdef WITH_GZIP
+      soap->z_crc = crc32(soap->z_crc, (Byte*)soap->buf, (unsigned int)n);
+#endif
+      do
+      { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Deflating %u bytes\n", soap->d_stream->avail_in));
+        if (deflate(soap->d_stream, Z_NO_FLUSH) != Z_OK)
+        { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unable to deflate: %s\n", soap->d_stream->msg?soap->d_stream->msg:SOAP_STR_EOS));
+          return soap->error = SOAP_ZLIB_ERROR;
+        }
+        if (!soap->d_stream->avail_out)
+        { if (soap_flush_raw(soap, soap->z_buf, SOAP_BUFLEN))
+            return soap->error;
+          soap->d_stream->next_out = (Byte*)soap->z_buf;
+          soap->d_stream->avail_out = SOAP_BUFLEN;
+        }
+      } while (soap->d_stream->avail_in);
+    }
+    else
+#endif
+      return soap_flush_raw(soap, soap->buf, n);
+  }
+  return SOAP_OK;
+}
+#endif
+
+/******************************************************************************/
+#ifndef PALM_1
+SOAP_FMAC1
+int
+SOAP_FMAC2
+soap_flush_raw(struct soap *soap, const char *s, size_t n)
+{ if ((soap->mode & SOAP_IO) == SOAP_IO_STORE)
+  { register char *t;
+    if (!(t = (char*)soap_push_block(soap, NULL, n)))
+      return soap->error = SOAP_EOM;
+    memcpy(t, s, n);
+#ifndef WITH_LEANER
+    if (soap->fpreparesend)
+      return soap->error = soap->fpreparesend(soap, s, n);
+#endif
+    return SOAP_OK;
+  }
+#ifndef WITH_LEANER
+  if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK)
+  { char t[16];
+    sprintf(t, "\r\n%lX\r\n" + (soap->chunksize ? 0 : 2), (unsigned long)n);
+    DBGMSG(SENT, t, strlen(t));
+    if ((soap->error = soap->fsend(soap, t, strlen(t))))
+      return soap->error;
+    soap->chunksize += n;
+  }
+  DBGMSG(SENT, s, n);
+#endif
+  return soap->error = soap->fsend(soap, s, n);
+}
+#endif
+
+/******************************************************************************/
+#ifndef PALM_1
+SOAP_FMAC1
+int
+SOAP_FMAC2
 soap_send(struct soap *soap, const char *s)
 { if (s)
@@ -619 +831 @@
 
 /******************************************************************************/
+#ifndef WITH_LEANER
 #ifndef PALM_1
 SOAP_FMAC1
@@ -629 +842 @@
 }
 #endif
-
-/******************************************************************************/
+#endif
+
+/******************************************************************************/
+#ifndef WITH_LEANER
 #ifndef PALM_1
 SOAP_FMAC1
@@ -642 +857 @@
 }
 #endif
-
-/******************************************************************************/
-#ifndef MAC_CARBON
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOIO
 #ifndef PALM_1
 static size_t
 frecv(struct soap *soap, char *s, size_t n)
 { register int r;
+#ifndef WITH_LEAN
+  register int retries = 100; /* max 100 retries with non-blocking sockets */
+#endif
   soap->errnum = 0;
 #if defined(__cplusplus) && !defined(WITH_LEAN)
   if (soap->is)
   { if (soap->is->good())
-      return soap->is->read(s, n).gcount();
+      return soap->is->read(s, (std::streamsize)n).gcount();
     return 0;
   }
@@ -660 +879 @@
   { for (;;)
     { 
+#ifdef WITH_OPENSSL
+      register int err = 0;
+#endif
 #ifndef WITH_LEAN
-      struct timeval timeout;
-      fd_set fd;
+#ifdef WITH_OPENSSL
+      if (soap->recv_timeout && !soap->ssl) /* SSL: sockets are nonblocking */
+#else
       if (soap->recv_timeout)
-      { if (soap->recv_timeout > 0)
+#endif
+      {
+#ifndef WIN32
+        if ((int)soap->socket >= (int)FD_SETSIZE)
+        { soap->error = SOAP_FD_EXCEEDED;
+          return 0;     /* Hint: MUST increase FD_SETSIZE */
+        }
+#endif
+        for (;;)
+        { struct timeval timeout;
+          fd_set fd;
+          if (soap->recv_timeout > 0)
+          { timeout.tv_sec = soap->recv_timeout;
+            timeout.tv_usec = 0;
+          }
+          else
+          { timeout.tv_sec = -soap->recv_timeout/1000000;
+            timeout.tv_usec = -soap->recv_timeout%1000000;
+          }
+          FD_ZERO(&fd);
+          FD_SET(soap->socket, &fd);
+          r = select((int)soap->socket + 1, &fd, NULL, &fd, &timeout);
+          if (r > 0)
+            break;
+          if (!r)
+          { soap->errnum = 0;
+            return 0;
+          }
+          r = soap_socket_errno(soap->socket);
+          if (r != SOAP_EINTR && r != SOAP_EAGAIN && r != SOAP_EWOULDBLOCK)
+          { soap->errnum = r;
+            return 0;
+          }
+        }
+      }
+#endif
+#ifdef WITH_OPENSSL
+      if (soap->ssl)
+      { r = SSL_read(soap->ssl, s, (int)n);
+        if (r > 0)
+          return (size_t)r;
+        err = SSL_get_error(soap->ssl, r);
+        if (err != SSL_ERROR_NONE && err != SSL_ERROR_WANT_READ && err != SSL_ERROR_WANT_WRITE)
+          return 0;
+      }
+      else if (soap->bio)
+      { r = BIO_read(soap->bio, s, (int)n);
+        if (r > 0)
+          return (size_t)r;
+        return 0;
+      }
+      else
+#endif
+      { 
+#ifndef WITH_LEAN
+        if ((soap->omode & SOAP_IO_UDP))
+        { SOAP_SOCKLEN_T k = (SOAP_SOCKLEN_T)sizeof(soap->peer);
+          memset((void*)&soap->peer, 0, sizeof(soap->peer));
+          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 */
+          soap->peerlen = (size_t)k;
+#ifndef WITH_IPV6
+          soap->ip = ntohl(soap->peer.sin_addr.s_addr);
+#endif
+        }
+        else
+#endif
+          r = recv(soap->socket, s, (int)n, soap->socket_flags);
+#ifdef PALM
+        /* CycleSyncDisplay(curStatusMsg); */
+#endif
+        if (r >= 0)
+          return (size_t)r;
+        r = soap_socket_errno(soap->socket);
+        if (r != SOAP_EINTR && r != SOAP_EAGAIN && r != SOAP_EWOULDBLOCK)
+        { soap->errnum = r;
+          return 0;
+        }
+      }
+#ifndef WITH_LEAN
+      { struct timeval timeout;
+        fd_set fd;
+        if (soap->recv_timeout > 0)
         { timeout.tv_sec = soap->recv_timeout;
           timeout.tv_usec = 0;
         }
-        else
+        else if (soap->recv_timeout < 0)
         { timeout.tv_sec = -soap->recv_timeout/1000000;
           timeout.tv_usec = -soap->recv_timeout%1000000;
         }
+        else
+        { timeout.tv_sec = 5;
+          timeout.tv_usec = 0;
+        }
+#ifndef WIN32
+        if ((int)soap->socket >= (int)FD_SETSIZE)
+        { soap->error = SOAP_FD_EXCEEDED;
+          return 0;     /* Hint: MUST increase FD_SETSIZE */
+        }
+#endif
         FD_ZERO(&fd);
-        FD_SET((SOAP_SOCKET)soap->socket, &fd);
-        for (;;)
-        { r = select((SOAP_SOCKET)(soap->socket + 1), &fd, NULL, &fd, &timeout);
-          if (r > 0)
-            break;
-          if (r == 0)
-            return 0;
-          if (soap_socket_errno != SOAP_EINTR)
-          { soap->errnum = soap_socket_errno;
+        FD_SET(soap->socket, &fd);
+#ifdef WITH_OPENSSL
+        if (soap->ssl && err == SSL_ERROR_WANT_WRITE)
+          r = select((int)soap->socket + 1, NULL, &fd, &fd, &timeout);
+        else
+          r = select((int)soap->socket + 1, &fd, NULL, &fd, &timeout);
+#else
+        r = select((int)soap->socket + 1, &fd, NULL, &fd, &timeout);
+#endif
+        if (!r && soap->recv_timeout)
+        { soap->errnum = 0;
+          return 0;
+        }
+        if (r < 0)
+        { r = soap_socket_errno(soap->socket);
+          if (r != SOAP_EINTR && r != SOAP_EAGAIN && r != SOAP_EWOULDBLOCK)
+          { soap->errnum = r;
             return 0;
           }
         }
-      }
-#endif
-#ifdef WITH_OPENSSL
-      if (soap->ssl)
-      { int err;
-        r = SSL_read(soap->ssl, s, n);
-        if ((err = SSL_get_error(soap->ssl, r)) == SSL_ERROR_NONE)
-          return (size_t)r;
-        if (err != SSL_ERROR_WANT_READ && err != SSL_ERROR_WANT_WRITE)
-          return 0;
-      }
-      else
-#endif
-      { r = recv((SOAP_SOCKET)soap->socket, s, n, soap->socket_flags);
-        if (r >= 0)
-          return (size_t)r;
-        if (soap_socket_errno != SOAP_EINTR && soap_socket_errno != SOAP_EAGAIN)
-        { soap->errnum = soap_socket_errno;
+        if (retries-- <= 0)
+        { soap->errnum = soap_socket_errno(soap->socket);
           return 0;
         }
       }
-#ifndef WITH_LEAN
-      { struct timeval timeout;
-        fd_set fd;
-        timeout.tv_sec = 0;
-        timeout.tv_usec = 10000;
-        FD_ZERO(&fd);
-        FD_SET((SOAP_SOCKET)soap->socket, &fd);
-        r = select((SOAP_SOCKET)(soap->socket + 1), &fd, NULL, &fd, &timeout);
-        if (r < 0 && soap_socket_errno != SOAP_EINTR)
-        { soap->errnum = soap_socket_errno;
-          return 0;
-        }
+#endif
+#ifdef PALM
+      r = soap_socket_errno(soap->socket);
+      if (r != SOAP_EINTR && retries-- <= 0)
+      { soap->errnum = r;
+        return 0;
       }
 #endif
@@ -728 +1028 @@
   return fread(s, 1, n, soap->recvfd);
 #else
-/* WR[ */
 #ifdef WMW_RPM_IO
   if (soap->rpmreqid)
     r = httpBlockRead(soap->rpmreqid, s, n);
   else
-    r = read(soap->recvfd, s, n);
-  if (r >= 0)
-    return r;
-  return 0;
-#else
-/* ]WR */
-  r = read((SOAP_SOCKET)soap->recvfd, s, n);
+#endif
+    r = read(soap->recvfd, s, (unsigned int)n);
   if (r >= 0)
     return (size_t)r;
   soap->errnum = soap_errno;
   return 0;
-/* WR[ */
-#endif
-/* ]WR */
-#endif
-#endif
-}
-#endif
-#endif
-
-/******************************************************************************/
+#endif
+#endif
+}
+#endif
+#endif
+
+/******************************************************************************/
+#ifndef WITH_LEAN
+#ifndef WITH_NOIO
+#ifndef PALM_1
+static size_t
+frecv_stop(struct soap *soap, char *s, size_t n)
+{ return 0;
+}
+#endif
+#endif
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOHTTP
 #ifndef PALM_1
 static soap_wchar
@@ -761 +1065 @@
   soap->bufidx = 0;
   soap->buflen = soap->chunkbuflen = soap->frecv(soap, soap->buf, SOAP_BUFLEN);
-  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Read %u bytes\n", (unsigned int)soap->buflen));
+  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Read %u bytes from socket %d\n", (unsigned int)soap->buflen, soap->socket));
   DBGMSG(RECV, soap->buf, soap->buflen);
   if (soap->buflen)
@@ -768 +1072 @@
 }
 #endif
+#endif
 
 /******************************************************************************/
@@ -773 +1078 @@
 static int
 soap_isxdigit(int c)
-{ switch (c)
-  { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
-    case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
-    case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
-      return 1;
-  }
-  return 0;
+{ return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f');
 }
 #endif
@@ -792 +1091 @@
 #ifdef WITH_ZLIB
   if (soap->mode & SOAP_ENC_ZLIB)
-  { if (soap->d_stream.next_out == Z_NULL)
+  { if (soap->d_stream->next_out == Z_NULL)
       return EOF;
-    if (soap->d_stream.avail_in || !soap->d_stream.avail_out)
+    if (soap->d_stream->avail_in || !soap->d_stream->avail_out)
     { register int r;
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflating\n"));
-      soap->d_stream.next_out = (Byte*)soap->buf;
-      soap->d_stream.avail_out = SOAP_BUFLEN;
-      r = inflate(&soap->d_stream, Z_NO_FLUSH);
+      soap->d_stream->next_out = (Byte*)soap->buf;
+      soap->d_stream->avail_out = SOAP_BUFLEN;
+      r = inflate(soap->d_stream, Z_NO_FLUSH);
       if (r == Z_OK || r == Z_STREAM_END)
       { soap->bufidx = 0;
-        soap->buflen = SOAP_BUFLEN - soap->d_stream.avail_out;
+        ret = soap->buflen = SOAP_BUFLEN - soap->d_stream->avail_out;
         if (soap->zlib_in == SOAP_ZLIB_GZIP)
-          soap->z_crc = crc32(soap->z_crc, (Byte*)soap->buf, (unsigned int)soap->buflen);
+          soap->z_crc = crc32(soap->z_crc, (Byte*)soap->buf, (unsigned int)ret);
         if (r == Z_STREAM_END)
-        { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflated %lu->%lu bytes\n", soap->d_stream.total_in, soap->d_stream.total_out));
-          soap->z_ratio_in = (float)soap->d_stream.total_in / (float)soap->d_stream.total_out;
-          soap->d_stream.next_out = Z_NULL;
+        { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflated %lu->%lu bytes\n", soap->d_stream->total_in, soap->d_stream->total_out));
+          soap->z_ratio_in = (float)soap->d_stream->total_in / (float)soap->d_stream->total_out;
+          soap->d_stream->next_out = Z_NULL;
         }
-        if (soap->buflen)
-        { soap->count += soap->buflen;
+        if (ret)
+        { soap->count += ret;
+          DBGLOG(RECV, SOAP_MESSAGE(fdebug, "\n---- decompressed ----\n"));
+          DBGMSG(RECV, soap->buf, ret);
+          DBGLOG(RECV, SOAP_MESSAGE(fdebug, "\n----\n"));
           return SOAP_OK;
         }
       }
       else if (r != Z_BUF_ERROR)
-      { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflate error: %s\n", soap->d_stream.msg?soap->d_stream.msg:""));
-        soap->d_stream.next_out = Z_NULL;
+      { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflate error: %s\n", soap->d_stream->msg?soap->d_stream->msg:SOAP_STR_EOS));
+        soap->d_stream->next_out = Z_NULL;
+        soap->error = SOAP_ZLIB_ERROR;
         return EOF;
       }
@@ -826 +1129 @@
       soap->buflen = soap->z_buflen;
     }
-  }
-#endif
+    DBGLOG(RECV, SOAP_MESSAGE(fdebug, "\n---- compressed ----\n"));
+  }
+#endif
+#ifndef WITH_NOHTTP
   if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK) /* read HTTP chunked transfer */
-  { 
-chunk_again:
-    if (soap->chunksize)
-    { soap->buflen = ret = soap->frecv(soap, soap->buf, soap->chunksize > SOAP_BUFLEN ? SOAP_BUFLEN : soap->chunksize);
-      DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Getting chunk: read %u bytes\n", (unsigned int)ret));
-      DBGMSG(RECV, soap->buf, ret);
-      soap->bufidx = 0;
-      soap->chunksize -= ret;
-    }
-    else
+  { for (;;)
     { register soap_wchar c;
       char *t, tmp[8];
+      if (soap->chunksize)
+      { soap->buflen = ret = soap->frecv(soap, soap->buf, soap->chunksize > SOAP_BUFLEN ? SOAP_BUFLEN : soap->chunksize);
+        DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Getting chunk: read %u bytes\n", (unsigned int)ret));
+        DBGMSG(RECV, soap->buf, ret);
+        soap->bufidx = 0;
+        soap->chunksize -= ret;
+        break;
+      }
       t = tmp;
       if (!soap->chunkbuflen)
       { soap->chunkbuflen = ret = soap->frecv(soap, soap->buf, SOAP_BUFLEN);
-        DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Read %u bytes\n", (unsigned int)ret));
+        DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Read %u bytes (chunked) from socket %d\n", (unsigned int)ret, soap->socket));
         DBGMSG(RECV, soap->buf, ret);
         soap->bufidx = 0;
         if (!ret)
-          return EOF;
+          return soap->ahead = EOF;
       }
       else
         soap->bufidx = soap->buflen;
       soap->buflen = soap->chunkbuflen;
-      DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Getting chunk size (%u %u)\n", (unsigned int)soap->bufidx, (unsigned int)soap->buflen));
+      DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Getting chunk size (idx=%u len=%u)\n", (unsigned int)soap->bufidx, (unsigned int)soap->buflen));
       while (!soap_isxdigit((int)(c = soap_getchunkchar(soap))))
-        if ((int)c == EOF)
-          return EOF;
+      { if ((int)c == EOF)
+          return soap->ahead = EOF;
+      }
       do
         *t++ = (char)c;
@@ -863 +1168 @@
         c = soap_getchunkchar(soap);
       if ((int)c == EOF)
-        return EOF;
+        return soap->ahead = EOF;
       *t = '\0';
+      DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Chunk size = %s (hex)\n", tmp));
       soap->chunksize = soap_strtoul(tmp, &t, 16);
       if (!soap->chunksize)
       { soap->chunkbuflen = 0;
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End of chunked message\n"));
-        while ((int)c != EOF && c != '\n')
+        while ((int)c != EOF && c != '\n')
           c = soap_getchunkchar(soap);
-        return EOF;
+        ret = 0;
+        soap->ahead = EOF;
+        break;
       }
       soap->buflen = soap->bufidx + soap->chunksize;
-      DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Moving buf len to %u (%u %s)\n", (unsigned int)soap->buflen, (unsigned int)soap->bufidx, tmp));
+      DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Moving buf len to idx=%u len=%u (%s)\n", (unsigned int)soap->bufidx, (unsigned int)soap->buflen, tmp));
       if (soap->buflen > soap->chunkbuflen)
       { soap->buflen = soap->chunkbuflen;
         soap->chunksize -= soap->buflen - soap->bufidx;
         soap->chunkbuflen = 0;
-        DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Passed end of buffer for chunked HTTP (%lu bytes left)\n", (unsigned long)(soap->buflen - soap->bufidx)));
+        DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Passed end of buffer for chunked HTTP (%u bytes left)\n", (unsigned int)(soap->buflen - soap->bufidx)));
       }
       else if (soap->chunkbuflen)
         soap->chunksize = 0;
       ret = soap->buflen - soap->bufidx;
-      if (!ret)
-        goto chunk_again;
+      if (ret)
+        break;
     }
   }
   else
+#endif
   { soap->bufidx = 0;
     soap->buflen = ret = soap->frecv(soap, soap->buf, SOAP_BUFLEN);
-    DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Read %u bytes\n", (unsigned int)ret));
+    DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Read %u bytes from socket %d\n", (unsigned int)ret, soap->socket));
     DBGMSG(RECV, soap->buf, ret);
   }
+#ifndef WITH_LEANER
   if (soap->fpreparerecv && (soap->error = soap->fpreparerecv(soap, soap->buf, ret)))
     return soap->error;
+#endif
 #ifdef WITH_ZLIB
   if (soap->mode & SOAP_ENC_ZLIB)
   { register int r;
     memcpy(soap->z_buf, soap->buf, SOAP_BUFLEN);
-    soap->d_stream.next_in = (Byte*)(soap->z_buf + soap->bufidx);
-    soap->d_stream.avail_in = (unsigned int)ret;
-    soap->d_stream.next_out = (Byte*)soap->buf;
-    soap->d_stream.avail_out = SOAP_BUFLEN;
-    r = inflate(&soap->d_stream, Z_NO_FLUSH);
+    soap->d_stream->next_in = (Byte*)(soap->z_buf + soap->bufidx);
+    soap->d_stream->avail_in = (unsigned int)ret;
+    soap->d_stream->next_out = (Byte*)soap->buf;
+    soap->d_stream->avail_out = SOAP_BUFLEN;
+    r = inflate(soap->d_stream, Z_NO_FLUSH);
     if (r == Z_OK || r == Z_STREAM_END)
     { soap->bufidx = 0;
       soap->z_buflen = soap->buflen;
-      soap->buflen = ret = SOAP_BUFLEN - soap->d_stream.avail_out;
+      soap->buflen = SOAP_BUFLEN - soap->d_stream->avail_out;
       if (soap->zlib_in == SOAP_ZLIB_GZIP)
         soap->z_crc = crc32(soap->z_crc, (Byte*)soap->buf, (unsigned int)soap->buflen);
-      DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflated %u bytes\n", (unsigned int)ret));
-      if (!ret)
+      DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflated %u bytes\n", (unsigned int)soap->buflen));
+      if (ret && !soap->buflen)
         goto zlib_again;
+      ret = soap->buflen;
       if (r == Z_STREAM_END)
-      { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflated %lu->%lu bytes\n", soap->d_stream.total_in, soap->d_stream.total_out));
-        soap->z_ratio_in = (float)soap->d_stream.total_in / (float)soap->d_stream.total_out;
-        soap->d_stream.next_out = Z_NULL;
-      }
+      { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflated total %lu->%lu bytes\n", soap->d_stream->total_in, soap->d_stream->total_out));
+        soap->z_ratio_in = (float)soap->d_stream->total_in / (float)soap->d_stream->total_out;
+        soap->d_stream->next_out = Z_NULL;
+      }
+      DBGLOG(RECV, SOAP_MESSAGE(fdebug, "\n---- decompressed ----\n"));
+      DBGMSG(RECV, soap->buf, ret);
     }
     else
-    { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unable to inflate: (%d) %s\n", r, soap->d_stream.msg?soap->d_stream.msg:""));
-      soap->d_stream.next_out = Z_NULL;
+    { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unable to inflate: (%d) %s\n", r, soap->d_stream->msg?soap->d_stream->msg:SOAP_STR_EOS));
+      soap->d_stream->next_out = Z_NULL;
+      soap->error = SOAP_ZLIB_ERROR;
       return EOF;
     }
@@ -1012 +1327 @@
 soap_getchar(struct soap *soap)
 { register soap_wchar c;
-  if (soap->ahead)
-  { c = soap->ahead;
-    soap->ahead = 0;
+  c = soap->ahead;
+  if (c)
+  { if (c != EOF)
+      soap->ahead = 0;
     return c;
   }
@@ -1026 +1342 @@
 const struct soap_code_map*
 SOAP_FMAC2
-soap_code(const struct soap_code_map *map, const char *str)
-{ while (map->string)
-  { if (!strcmp(str, map->string)) /* case sensitive */
-      return map;
-    map++;
+soap_code(const struct soap_code_map *code_map, const char *str)
+{ if (code_map && str)
+  { while (code_map->string)
+    { if (!strcmp(str, code_map->string)) /* case sensitive */
+        return code_map;
+      code_map++;
+    }
   }
   return NULL;
@@ -1041 +1359 @@
 long
 SOAP_FMAC2
-soap_int_code(const struct soap_code_map *map, const char *str, long other)
-{ while (map->string)
-  { if (!soap_tag_cmp(str, map->string)) /* case insensitive */
-      return map->code;
-    map++;
+soap_code_int(const struct soap_code_map *code_map, const char *str, long other)
+{ if (code_map)
+  { while (code_map->string)
+    { if (!soap_tag_cmp(str, code_map->string)) /* case insensitive */
+        return code_map->code;
+      code_map++;
+    }
   }
   return other;
@@ -1056 +1376 @@
 const char*
 SOAP_FMAC2
-soap_str_code(const struct soap_code_map *map, long code)
-{ while (map->code != code && map->string)
-    map++;
-  return map->string;
+soap_code_str(const struct soap_code_map *code_map, long code)
+{ if (!code_map)
+    return NULL;
+  while (code_map->code != code && code_map->string)
+    code_map++;
+  return code_map->string;
+}
+#endif
+
+/******************************************************************************/
+#ifndef PALM_1
+SOAP_FMAC1
+long
+SOAP_FMAC2
+soap_code_bits(const struct soap_code_map *code_map, const char *str)
+{ register long bits = 0;
+  if (code_map)
+  { while (str && *str)
+    { const struct soap_code_map *p;
+      for (p = code_map; p->string; p++)
+      { register size_t n = strlen(p->string);
+        if (!strncmp(p->string, str, n) && soap_blank(str[n]))
+        { bits |= p->code;
+          str += n;
+          while (*str > 0 && *str <= 32)
+            str++;
+          break;
+        }
+      }
+      if (!p->string)
+        return 0;
+    }
+  }
+  return bits;
+}
+#endif
+
+/******************************************************************************/
+#ifndef PALM_1
+SOAP_FMAC1
+const char*
+SOAP_FMAC2
+soap_code_list(struct soap *soap, const struct soap_code_map *code_map, long code)
+{ register char *t = soap->tmpbuf;
+  if (code_map)
+  { while (code_map->string)
+    { if (code_map->code & code)
+      { register const char *s = code_map->string;
+        if (t != soap->tmpbuf)
+          *t++ = ' ';
+        while (*s && t < soap->tmpbuf + sizeof(soap->tmpbuf) - 1)
+          *t++ = *s++;
+        if (t == soap->tmpbuf + sizeof(soap->tmpbuf) - 1)
+          break;
+      }
+      code_map++;
+    }
+  }
+  *t = '\0';
+  return soap->tmpbuf;
 }
 #endif
@@ -1094 +1470 @@
     return '\'';
 #ifndef WITH_LEAN
-  return (soap_wchar)soap_int_code(html_entity_codes, tmp, SOAP_UNKNOWN_CHAR);
+  return (soap_wchar)soap_code_int(html_entity_codes, tmp, SOAP_UNKNOWN_CHAR);
 #else
   return SOAP_UNKNOWN_CHAR; /* use this to represent unknown code */
 #endif
 }
+#endif
+
+/******************************************************************************/
+#ifdef WITH_LEAN
+#ifndef PALM_1
+soap_wchar
+soap_get0(struct soap *soap)
+{ if (soap->bufidx >= soap->buflen && soap_recv(soap))
+    return EOF;
+  return (unsigned char)soap->buf[soap->bufidx];
+}
+#endif
+#endif
+
+/******************************************************************************/
+#ifdef WITH_LEAN
+#ifndef PALM_1
+soap_wchar
+soap_get1(struct soap *soap)
+{ if (soap->bufidx >= soap->buflen && soap_recv(soap))
+    return EOF;
+  return (unsigned char)soap->buf[soap->bufidx++];
+}
+#endif
 #endif
 
@@ -1110 +1510 @@
   c = soap->ahead;
   if (c)
-    soap->ahead = 0;
+  { if ((int)c != EOF)
+      soap->ahead = 0;
+  }
   else
     c = soap_get1(soap);
-  for (;;)
+  while ((int)c != EOF)
   { if (soap->cdata)
     { if (c == ']')
       { c = soap_get1(soap);
         if (c == ']')
-        { soap->cdata = 0;
-          soap_get1(soap); /* skip > */
-          c = soap_get1(soap);
+        { c = soap_get0(soap);
+          if (c == '>')
+          { soap->cdata = 0;
+            soap_get1(soap);
+            c = soap_get1(soap);
+          }
+          else
+          { soap_unget(soap, ']');
+            return ']';
+          }
         }
-        else
+        else
         { soap_revget1(soap);
           return ']';
@@ -1135 +1544 @@
         while (soap_blank(c));
         if (c == '!' || c == '?' || c == '%')
-        { if (c == '!')
+        { register int k = 1;
+          if (c == '!')
           { c = soap_get1(soap);
             if (c == '[')
@@ -1144 +1554 @@
               soap->cdata = 1;
               c = soap_get1(soap);
-              continue;
+              continue;
             }
             if (c == '-' && (c = soap_get1(soap)) == '-')
@@ -1154 +1564 @@
             }
           }
-          while ((int)c != EOF && c != '>')
+          else if (c == '?')
+            c = soap_get_pi(soap);
+          while ((int)c != EOF)
+          { if (c == '<')
+              k++;
+            else if (c == '>')
+            { if (--k <= 0)
+                break;
+            }
             c = soap_get1(soap);
-          if ((int)c == EOF)
-            break;
+          }
+          if ((int)c == EOF)
+            break;
           c = soap_get1(soap);
           continue;
@@ -1182 +1601 @@
 /******************************************************************************/
 #ifndef PALM_1
-SOAP_FMAC1
-soap_wchar
-SOAP_FMAC2
-soap_advance(struct soap *soap)
-{ register soap_wchar c;
-  while ((int)((c = soap_get(soap)) != EOF) && c != SOAP_LT && c != SOAP_TT)
-    ;
-  return c;
-}
-#endif
-
-/******************************************************************************/
-#ifndef PALM_1
-SOAP_FMAC1
-soap_wchar
-SOAP_FMAC2
-soap_skip(struct soap *soap)
-{ register soap_wchar c;
-  do c = soap_get(soap);
-  while (soap_blank(c));
+static soap_wchar
+soap_get_pi(struct soap *soap)
+{ char buf[64];
+  register char *s = buf;
+  register int i = sizeof(buf);
+  register soap_wchar c = soap_getchar(soap);
+  /* This is a quick way to parse XML PI and we could use a callback instead to
+   * enable applications to intercept processing instructions */
+  while ((int)c != EOF && c != '?')
+  { if (--i > 0)
+    { if (soap_blank(c))
+        c = ' ';
+      *s++ = (char)c;
+    }
+    c = soap_getchar(soap);
+  }
+  *s = '\0';
+  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "XML PI <?%s?>\n", buf));
+  if (!strncmp(buf, "xml ", 4))
+  { s = strstr(buf, " encoding=");
+    if (s && s[10])
+    { if (!soap_tag_cmp(s + 11, "iso-8859-1*")
+       || !soap_tag_cmp(s + 11, "latin1*"))
+      { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Switching to latin1 encoding\n"));
+        soap->mode |= SOAP_ENC_LATIN;
+      }
+      else if (!soap_tag_cmp(s + 11, "utf-8*"))
+      { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Switching to utf-8 encoding\n"));
+        soap->mode &= ~SOAP_ENC_LATIN;
+      }
+    }
+  }
+  if ((int)c != EOF)
+    c = soap_getchar(soap);
   return c;
 }
@@ -1241 +1674 @@
 soap_pututf8(struct soap *soap, register unsigned long c)
 { char tmp[16];
-  if (c > 0 && c < 0x80)
+  if (c < 0x80 && c > 0)
   { *tmp = (char)c;
     return soap_send_raw(soap, tmp, 1);
   }
 #ifndef WITH_LEAN
-  if (soap->mode & SOAP_XML_CANONICAL)
+  if (c >= 0x80)
   { register char *t = tmp;
     if (c < 0x0800)
@@ -1272 +1705 @@
     *t = '\0';
   }
-  else
-#endif
-    sprintf(tmp, "&#%lu;", c);
+#else
+  sprintf(tmp, "&#%lu;", c);
+#endif
   return soap_send(soap, tmp);
 }
@@ -1286 +1719 @@
 soap_getutf8(struct soap *soap)
 { register soap_wchar c, c1, c2, c3, c4;
+  c = soap->ahead;
+  if (c > 0xFF)
+  { soap->ahead = 0;
+    return c;
+  }
+again:
   c = soap_get(soap);
   if (c < 0x80 || (soap->mode & SOAP_ENC_LATIN))
     return c;
-  c1 = soap_get(soap);
+  c1 = soap_get1(soap);
   if (c1 < 0x80)
-  { soap_unget(soap, c1);
+  { soap_revget1(soap); /* doesn't look like this is UTF8 */
     return c;
   }
@@ -1298 +1737 @@
     return ((soap_wchar)(c & 0x1F) << 6) | c1;
   c2 = (soap_wchar)soap_get1(soap) & 0x3F;
+  if (c == 0xEF && c1 == 0x3B && c2 == 0x3F)    /* ignore UTF-8 BOM */
+    goto again;
   if (c < 0xF0)
     return ((soap_wchar)(c & 0x0F) << 12) | (c1 << 6) | c2;
@@ -1316 +1757 @@
 SOAP_FMAC2
 soap_puthex(struct soap *soap, const unsigned char *s, int n)
-{ /* TODO: serialize to DOM (as an option) using new soap_s2hex() */
-  char d[2];
+{ char d[2];
   register int i;
+#ifdef WITH_DOM
+  if ((soap->mode & SOAP_XML_DOM) && soap->dom)
+  { if (!(soap->dom->data = soap_s2hex(soap, s, NULL, n)))
+      return soap->error;
+    return SOAP_OK;
+  }
+#endif
   for (i = 0; i < n; i++)
   { register int m = *s++;
@@ -1338 +1785 @@
 soap_gethex(struct soap *soap, int *n)
 {
+#ifdef WITH_DOM
+  if ((soap->mode & SOAP_XML_DOM) && soap->dom)
+  { soap->dom->data = soap_string_in(soap, 0, -1, -1);
+    return (unsigned char*)soap_hex2s(soap, soap->dom->data, NULL, 0, n);
+  }
+#endif
 #ifdef WITH_FAST
   soap->labidx = 0;
   for (;;)
   { register char *s;
-    register int i, k;
+    register size_t i, k;
     if (soap_append_lab(soap, NULL, 0))
       return NULL;
@@ -1355 +1808 @@
       { d1 = (char)c;
         c = soap_get(soap); 
-        if (soap_isxdigit(c))
+        if (soap_isxdigit(c))
           d2 = (char)c;
         else 
@@ -1366 +1819 @@
         soap_unget(soap, c);
         if (n)
-          *n = (int)(soap->lablen - k + i);
-        p = (unsigned char*)soap_malloc(soap, soap->lablen - k + i);
-        if (p)
-          memcpy(p, soap->labbuf, soap->lablen - k + i);
+          *n = (int)(soap->lablen + i - k);
+        p = (unsigned char*)soap_malloc(soap, soap->lablen + i - k);
+        if (p)
+          memcpy(p, soap->labbuf, soap->lablen + i - k);
         return p;
       }
@@ -1376 +1829 @@
   }
 #else
-  if (soap_new_block(soap))
+  if (soap_new_block(soap) == NULL)
     return NULL;
   for (;;)
   { register int i;
-    register char *s = (char*)soap_push_block(soap, SOAP_BLKLEN);
+    register char *s = (char*)soap_push_block(soap, NULL, SOAP_BLKLEN);
     if (!s)
-    { soap_end_block(soap);
+    { soap_end_block(soap, NULL);
       return NULL;
     }
@@ -1391 +1844 @@
       { d1 = (char)c;
         c = soap_get(soap); 
-        if (soap_isxdigit(c))
+        if (soap_isxdigit(c))
           d2 = (char)c;
         else 
-        { soap_end_block(soap);
-          soap->error = SOAP_TYPE;
+        { soap_end_block(soap, NULL);
+          soap->error = SOAP_TYPE;
           return NULL;
         }
@@ -1403 +1856 @@
         soap_unget(soap, c);
         if (n)
-          *n = soap_size_block(soap, i);
+          *n = (int)soap_size_block(soap, NULL, i);
         p = (unsigned char*)soap_save_block(soap, NULL, 0);
         return p;
@@ -1427 +1880 @@
 #ifdef WITH_DOM
   if ((soap->mode & SOAP_XML_DOM) && soap->dom)
-  { if (!(soap->dom->data = soap_s2base64(soap, s, soap->dom->data, n)))
+  { if (!(soap->dom->data = soap_s2base64(soap, s, NULL, n)))
       return soap->error;
     return SOAP_OK;
@@ -1465 +1918 @@
 soap_getbase64(struct soap *soap, int *n, int malloc_flag)
 { 
+#ifdef WITH_DOM
+  if ((soap->mode & SOAP_XML_DOM) && soap->dom)
+  { soap->dom->data = soap_string_in(soap, 0, -1, -1);
+    return (unsigned char*)soap_base642s(soap, soap->dom->data, NULL, 0, n);
+  }
+#endif
 #ifdef WITH_FAST
   soap->labidx = 0;
   for (;;)
-  { register int i, k;
+  { register size_t i, k;
     register char *s;
     if (soap_append_lab(soap, NULL, 2))
       return NULL;
     s = soap->labbuf + soap->labidx;
-    k = 3 * ((soap->lablen - soap->labidx) / 3);
+    k = soap->lablen - soap->labidx;
     soap->labidx = 3 * (soap->lablen / 3);
     if (!s)
       return NULL;
-    for (i = 0; i < k; i += 3)
-    { register unsigned long m = 0;
-      register int j = 0;
-      do
-      { register soap_wchar c = soap_get(soap);
-        if (c == '=' || c < 0)
-        { unsigned char *p;
-          switch (j)
-          { case 2:
-              *s++ = (char)((m >> 4) & 0xFF);
-              i++;
-              break;
-            case 3:
-              *s++ = (char)((m >> 10) & 0xFF);
-              *s++ = (char)((m >> 2) & 0xFF);
-              i += 2;
+    if (k > 2)
+    { for (i = 0; i < k - 2; i += 3)
+      { register unsigned long m = 0;
+        register int j = 0;
+        do
+        { register soap_wchar c = soap_get(soap);
+          if (c == '=' || c < 0)
+          { unsigned char *p;
+            switch (j)
+            { case 2:
+                *s++ = (char)((m >> 4) & 0xFF);
+                i++;
+                break;
+              case 3:
+                *s++ = (char)((m >> 10) & 0xFF);
+                *s++ = (char)((m >> 2) & 0xFF);
+                i += 2;
+            }
+            if (n)
+              *n = (int)(soap->lablen + i - k);
+            p = (unsigned char*)soap_malloc(soap, soap->lablen + i - k);
+            if (p)
+              memcpy(p, soap->labbuf, soap->lablen + i - k);
+            if (c >= 0)
+            { while ((int)((c = soap_get(soap)) != EOF) && c != SOAP_LT && c != SOAP_TT)
+                ;
+            }
+            soap_unget(soap, c);
+            return p;
           }
-          if (n)
-            *n = (int)(soap->lablen - k + i);
-          p = (unsigned char*)soap_malloc(soap, soap->lablen - k + i);
-          if (p)
-            memcpy(p, soap->labbuf, soap->lablen - k + i);
-          if (c >= 0)
-          { while ((int)((c = soap_get(soap)) != EOF) && c != SOAP_LT && c != SOAP_TT)
-              ;
-          }
-          soap_unget(soap, c);
-          return p;
-        }
-        c -= '+';
-        if (c >= 0 && c <= 79)
-        { m = (m << 6) + soap_base64i[c];
-          j++;
-        }
-      } while (j < 4);
-      *s++ = (char)((m >> 16) & 0xFF);
-      *s++ = (char)((m >> 8) & 0xFF);
-      *s++ = (char)(m & 0xFF);
+          c -= '+';
+          if (c >= 0 && c <= 79)
+          { register int b = soap_base64i[c];
+            if (b >= 64)
+            { soap->error = SOAP_TYPE;
+              return NULL;  
+            }
+            m = (m << 6) + b;
+            j++;
+          }
+          else if (!soap_blank(c + '+'))
+          { soap->error = SOAP_TYPE;
+            return NULL;  
+          }
+        } while (j < 4);
+        *s++ = (char)((m >> 16) & 0xFF);
+        *s++ = (char)((m >> 8) & 0xFF);
+        *s++ = (char)(m & 0xFF);
+      }
     }
   }
 #else
-  if (soap_new_block(soap))
+  if (soap_new_block(soap) == NULL)
     return NULL;
   for (;;)
   { register int i;
-    register char *s = (char*)soap_push_block(soap, 3 * SOAP_BLKLEN); /* must be multiple of 3 */
+    register char *s = (char*)soap_push_block(soap, NULL, 3 * SOAP_BLKLEN); /* must be multiple of 3 */
     if (!s)
-    { soap_end_block(soap);
+    { soap_end_block(soap, NULL);
       return NULL;
     }
@@ -1546 +2016 @@
           }
           if (n)
-            *n = (int)soap_size_block(soap, i);
+            *n = (int)soap_size_block(soap, NULL, i);
           p = (unsigned char*)soap_save_block(soap, NULL, 0);
           if (c >= 0)
           { while ((int)((c = soap_get(soap)) != EOF) && c != SOAP_LT && c != SOAP_TT)
               ;
-          }
+          }
           soap_unget(soap, c);
           return p;
@@ -1557 +2027 @@
         c -= '+';
         if (c >= 0 && c <= 79)
-        { m = (m << 6) + soap_base64i[c];
+        { int b = soap_base64i[c];
+          if (b >= 64)
+          { soap->error = SOAP_TYPE;
+            return NULL;  
+          }
+          m = (m << 6) + b;
           j++;
+        }
+        else if (!soap_blank(c))
+        { soap->error = SOAP_TYPE;
+          return NULL;  
         }
       } while (j < 4);
@@ -1571 +2050 @@
 
 /******************************************************************************/
+#ifndef WITH_LEANER
+#ifndef PALM_1
+SOAP_FMAC1
+int
+SOAP_FMAC2
+soap_xop_forward(struct soap *soap, unsigned char **ptr, int *size, char **id, char **type, char **options)
+{ /* Check MTOM xop:Include element (within hex/base64Binary) */
+  /* TODO: this code to be obsoleted with new import/xop.h conventions */
+  int body = soap->body; /* should save type too? */
+  if (!soap_peek_element(soap))
+  { if (!soap_element_begin_in(soap, "xop:Include", 0, NULL) && *soap->href)
+    { if (soap_dime_forward(soap, ptr, size, id, type, options))
+        return soap->error;
+    }
+    if (soap->body && soap_element_end_in(soap, NULL))
+      return soap->error;
+  }
+  soap->body = body;
+  return SOAP_OK;
+}
+#endif
+#endif
+
+/******************************************************************************/
+#ifndef WITH_LEANER
+#ifndef PALM_1
+SOAP_FMAC1
+int
+SOAP_FMAC2
+soap_dime_forward(struct soap *soap, unsigned char **ptr, int *size, char **id, char **type, char **options)
+{ struct soap_xlist *xp;
+  *ptr = NULL;
+  *size = 0;
+  *id = NULL;
+  *type = NULL;
+  *options = NULL;
+  if (!*soap->href)
+    return SOAP_OK;
+  *id = soap_strdup(soap, soap->href);
+  xp = (struct soap_xlist*)SOAP_MALLOC(soap, sizeof(struct soap_xlist));
+  if (!xp)
+    return soap->error = SOAP_EOM;
+  xp->next = soap->xlist;
+  xp->ptr = ptr;
+  xp->size = size;
+  xp->id = *id;
+  xp->type = type;
+  xp->options = options;
+  soap->xlist = xp;
+  return SOAP_OK;
+}
+#endif
+#endif
+
+/******************************************************************************/
 #ifndef PALM_1
 SOAP_FMAC1
@@ -1586 +2120 @@
 #ifndef PALM_1
 SOAP_FMAC1
-int
+wchar_t *
+SOAP_FMAC2
+soap_wstrdup(struct soap *soap, const wchar_t *s)
+{ wchar_t *t = NULL;
+  if (s)
+  { size_t n = 0;
+    while (s[n])
+      n++;
+    if ((t = (wchar_t*)soap_malloc(soap, sizeof(wchar_t)*(n+1))))
+      memcpy(t, s, sizeof(wchar_t)*(n+1));
+  }
+  return t;
+}
+#endif
+
+/******************************************************************************/
+#ifndef PALM_1
+SOAP_FMAC1
+struct soap_blist*
 SOAP_FMAC2
 soap_new_block(struct soap *soap)
 { struct soap_blist *p;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "New block sequence (prev=%p)\n", soap->blist));
-  if (!(p = (struct soap_blist*)SOAP_MALLOC(sizeof(struct soap_blist))))
-    return SOAP_EOM;   
+  if (!(p = (struct soap_blist*)SOAP_MALLOC(soap, sizeof(struct soap_blist))))
+  { soap->error = SOAP_EOM;   
+    return NULL;
+  }
   p->next = soap->blist; 
   p->ptr = NULL;
   p->size = 0;
   soap->blist = p;
-  return SOAP_OK;
+  return p;
 }
 #endif
@@ -1606 +2160 @@
 void*
 SOAP_FMAC2
-soap_push_block(struct soap *soap, size_t n)
+soap_push_block(struct soap *soap, struct soap_blist *b, size_t n)
 { char *p;
-  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Push block of %u bytes (%u bytes total)\n", (unsigned int)n, (unsigned int)soap->blist->size + (unsigned int)n));
-  if (!(p = (char*)SOAP_MALLOC(n + sizeof(char*) + sizeof(size_t))))
+  if (!b)
+    b = soap->blist;
+  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Push block of %u bytes (%u bytes total)\n", (unsigned int)n, (unsigned int)b->size + (unsigned int)n));
+  if (!(p = (char*)SOAP_MALLOC(soap, n + sizeof(char*) + sizeof(size_t))))
   { soap->error = SOAP_EOM;
     return NULL;
   }
-  *(char**)p = soap->blist->ptr;
+  *(char**)p = b->ptr;
   *(size_t*)(p + sizeof(char*)) = n;
-  soap->blist->ptr = p;
-  soap->blist->size += n;
+  b->ptr = p;
+  b->size += n;
   return p + sizeof(char*) + sizeof(size_t);
 }
@@ -1626 +2182 @@
 void
 SOAP_FMAC2
-soap_pop_block(struct soap *soap)
+soap_pop_block(struct soap *soap, struct soap_blist *b)
 { char *p;
-  if (!soap->blist->ptr)
+  if (!b)
+    b = soap->blist;
+  if (!b->ptr)
     return;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Pop block\n"));
-  p = soap->blist->ptr;
-  soap->blist->size -= *(size_t*)(p + sizeof(char*));
-  soap->blist->ptr = *(char**)p;
-  SOAP_FREE(p);
-}
-#endif
-
-/******************************************************************************/
+  p = b->ptr;
+  b->size -= *(size_t*)(p + sizeof(char*));
+  b->ptr = *(char**)p;
+  SOAP_FREE(soap, p);
+}
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOIDREF
 #ifndef PALM_1
 static void
-soap_update_ptrs(struct soap *soap, char *start, char *end, long offset)
+soap_update_ptrs(struct soap *soap, char *start, char *end, char *p1, char *p2)
 { int i;
-  register struct soap_ilist *ip;
-  register struct soap_flist *fp;
+  register struct soap_ilist *ip = NULL;
+  register struct soap_flist *fp = NULL;
+#ifndef WITH_LEANER
+  register struct soap_xlist *xp = NULL;
+#endif
   register void *p, **q;
   for (i = 0; i < SOAP_IDHASH; i++)
-    for (ip = soap->iht[i]; ip; ip = ip->next)
+  { for (ip = soap->iht[i]; ip; ip = ip->next)
     { if (ip->ptr && (char*)ip->ptr >= start && (char*)ip->ptr < end)
-      { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Update id='%s' %p -> %p\n", ip->id, ip->ptr, (char*)ip->ptr + offset));
-        ip->ptr = (char*)ip->ptr + offset;
+      { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Update id='%s' %p -> %p\n", ip->id, ip->ptr, (char*)ip->ptr + (p1-p2)));
+        ip->ptr = (char*)ip->ptr + (p1-p2);
       }
       for (q = &ip->link; q; q = (void**)p)
@@ -1656 +2218 @@
         if (p && (char*)p >= start && (char*)p < end)
         { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Link update id='%s' %p\n", ip->id, p));
-          *q = (char*)p + offset;
+          *q = (char*)p + (p1-p2);
         }
       }
@@ -1663 +2225 @@
         if (p && (char*)p >= start && (char*)p < end)
         { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy chain update id='%s' %p\n", ip->id, p));
-          *q = (char*)p + offset;
+          *q = (char*)p + (p1-p2);
         }
       }
@@ -1669 +2231 @@
       { if ((char*)fp->ptr >= start && (char*)fp->ptr < end)
         { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy list update id='%s' %p\n", ip->id, fp));
-          fp->ptr = (char*)fp->ptr + offset;
+          fp->ptr = (char*)fp->ptr + (p1-p2);
         }
       }
     }
-}
-#endif
-
-/******************************************************************************/
+  }
+#ifndef WITH_LEANER
+  for (xp = soap->xlist; xp; xp = xp->next)
+  { if (xp->ptr && (char*)xp->ptr >= start && (char*)xp->ptr < end)
+    { 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)));
+      xp->ptr = (unsigned char**)((char*)xp->ptr + (p1-p2));
+      xp->size = (int*)((char*)xp->size + (p1-p2));
+      xp->type = (char**)((char*)xp->type + (p1-p2));
+      xp->options = (char**)((char*)xp->options + (p1-p2));
+    }
+  }
+#endif
+}
+#endif
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOIDREF
 #ifndef PALM_1
 static int
 soap_has_copies(struct soap *soap, register const char *start, register const char *end)
 { register int i;
-  register struct soap_ilist *ip;
-  register struct soap_flist *fp;
+  register struct soap_ilist *ip = NULL;
+  register struct soap_flist *fp = NULL;
   register const char *p;
   for (i = 0; i < SOAP_IDHASH; i++)
@@ -1691 +2267 @@
       for (fp = ip->flist; fp; fp = fp->next)
         if ((const char*)fp->ptr >= start && (const char*)fp->ptr < end)
-          return SOAP_ERR;
+          return SOAP_ERR;
     }
   }
@@ -1697 +2273 @@
 }
 #endif
-
-/******************************************************************************/
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOIDREF
 #ifndef PALM_1
 SOAP_FMAC1
@@ -1705 +2283 @@
 soap_resolve(struct soap *soap)
 { register int i;
-  register struct soap_ilist *ip;
-  register struct soap_flist *fp;
+  register struct soap_ilist *ip = NULL;
+  register struct soap_flist *fp = NULL;
   short flag;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Resolving forwarded data\n"));
@@ -1743 +2321 @@
             do
             { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "... copy %p -> %p (%u bytes)\n", ip->ptr, q, (unsigned int)ip->size));
-              p = *q;
+              p = *q;
               memcpy(q, ip->ptr, ip->size);
               q = (void**)p;
             } while (q);
-            flag = 1;
-          }
+            flag = 1;
+          }
           for (fp = ip->flist; fp; fp = ip->flist)
           { register unsigned int k = fp->level;
-            register void *p = ip->ptr;
+            register void *p = ip->ptr;
             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));
-            while (ip->level < k)
+            while (ip->level < k)
             { register void **q = (void**)soap_malloc(soap, sizeof(void*));  
-              if (!q)
-                return soap->error;
-              *q = p;
+              if (!q)
+                return soap->error;
+              *q = p;
               DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Descending one level, new location=%p holds=%p...\n", q, *q));
               p = (void*)q;
               k--;
             }
-            if (fp->fcopy)
-              fp->fcopy(soap, ip->type, fp->type, fp->ptr, p, ip->size);
-            else
-              soap_fcopy(soap, ip->type, fp->type, fp->ptr, p, ip->size);
-            ip->flist = fp->next;
-            SOAP_FREE(fp);
-            flag = 1;
-          }
+            if (fp->fcopy)
+              fp->fcopy(soap, ip->type, fp->type, fp->ptr, fp->len, p, ip->size);
+            else
+              soap_fcopy(soap, ip->type, fp->type, fp->ptr, fp->len, p, ip->size);
+            ip->flist = fp->next;
+            SOAP_FREE(soap, fp);
+            flag = 1;
+          }
         }
       }
@@ -1787 +2365 @@
 }
 #endif
+#endif
 
 /******************************************************************************/
@@ -1793 +2372 @@
 size_t
 SOAP_FMAC2
-soap_size_block(struct soap *soap, size_t n)
-{ if (soap->blist->ptr)
-  { soap->blist->size -= *(size_t*)(soap->blist->ptr + sizeof(char*)) - n;
-    *(size_t*)(soap->blist->ptr + sizeof(char*)) = n;
-  }
-  return soap->blist->size;
+soap_size_block(struct soap *soap, struct soap_blist *b, size_t n)
+{ if (!b)
+    b = soap->blist;
+  if (b->ptr)
+  { b->size -= *(size_t*)(b->ptr + sizeof(char*)) - n;
+    *(size_t*)(b->ptr + sizeof(char*)) = n;
+  }
+  return b->size;
 }
 #endif
@@ -1807 +2388 @@
 char*
 SOAP_FMAC2
-soap_first_block(struct soap *soap)
+soap_first_block(struct soap *soap, struct soap_blist *b)
 { char *p, *q, *r;
-  p = soap->blist->ptr;
+  if (!b)
+    b = soap->blist;
+  p = b->ptr;
   if (!p)
     return NULL;
@@ -1820 +2403 @@
     p = q;
   } while (p);
-  soap->blist->ptr = r;
+  b->ptr = r;
   return r + sizeof(char*) + sizeof(size_t);
 }
@@ -1830 +2413 @@
 char*
 SOAP_FMAC2
-soap_next_block(struct soap *soap)
+soap_next_block(struct soap *soap, struct soap_blist *b)
 { char *p;
-  p = soap->blist->ptr;
+  if (!b)
+    b = soap->blist;
+  p = b->ptr;
   if (p)
   { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Next block\n"));
-    soap->blist->ptr = *(char**)p;
-    SOAP_FREE(p);
-    if (soap->blist->ptr)
-      return soap->blist->ptr + sizeof(char*) + sizeof(size_t);
+    b->ptr = *(char**)p;
+    SOAP_FREE(soap, p);
+    if (b->ptr)
+      return b->ptr + sizeof(char*) + sizeof(size_t);
   }
   return NULL;
@@ -1849 +2434 @@
 size_t
 SOAP_FMAC2
-soap_block_size(struct soap *soap)
-{ return *(size_t*)(soap->blist->ptr + sizeof(char*));
+soap_block_size(struct soap *soap, struct soap_blist *b)
+{ if (!b)
+    b = soap->blist;
+  return *(size_t*)(b->ptr + sizeof(char*));
 }
 #endif
@@ -1859 +2446 @@
 void
 SOAP_FMAC2
-soap_end_block(struct soap *soap)
-{ struct soap_blist *bp;
-  char *p, *q;
-  bp = soap->blist;
-  if (bp)
+soap_end_block(struct soap *soap, struct soap_blist *b)
+{ char *p, *q;
+  if (!b)
+    b = soap->blist;
+  if (b)
   { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End of block sequence, free all remaining blocks\n"));
-    for (p = bp->ptr; p; p = q)
+    for (p = b->ptr; p; p = q)
     { q = *(char**)p;
-      SOAP_FREE(p);
-    }
-    soap->blist = bp->next;
-    SOAP_FREE(bp);
+      SOAP_FREE(soap, p);
+    }
+    if (soap->blist == b)
+      soap->blist = b->next;
+    else
+    { struct soap_blist *bp;
+      for (bp = soap->blist; bp; bp = bp->next)
+      { if (bp->next == b)
+        { bp->next = b->next;
+          break;
+        }
+      }
+    }
+    SOAP_FREE(soap, b);
   }
   DBGLOG(TEST, if (soap->blist) SOAP_MESSAGE(fdebug, "Restore previous block sequence\n"));
@@ -1881 +2478 @@
 char*
 SOAP_FMAC2
-soap_save_block(struct soap *soap, char *p, int flag)
+soap_save_block(struct soap *soap, struct soap_blist *b, char *p, int flag)
 { register size_t n;
   register char *q, *s;
-  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Save all blocks in contiguous memory space of %u bytes (%p->%p)\n", (unsigned int)soap->blist->size, soap->blist->ptr, p));
-  if (soap->blist->size)
+  if (!b)
+    b = soap->blist;
+  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));
+  if (b->size)
   { if (!p)
-      p = (char*)soap_malloc(soap, soap->blist->size);
+      p = (char*)soap_malloc(soap, b->size);
     if (p)
-    { for (s = p, q = soap_first_block(soap); q; q = soap_next_block(soap))
-      { n = soap_block_size(soap);
+    { for (s = p, q = soap_first_block(soap, b); q; q = soap_next_block(soap, b))
+      { n = soap_block_size(soap, b);
+#ifndef WITH_NOIDREF
         if (flag)
-          soap_update_ptrs(soap, q, q + n, (long)s - (long)q); /* pointers s and q may or may not be related */
+          soap_update_ptrs(soap, q, q + n, s, q);
+#endif
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy %u bytes from %p to %p\n", (unsigned int)n, q, s));
         memcpy(s, q, n);
@@ -1901 +2502 @@
       soap->error = SOAP_EOM;
   }
-  soap_end_block(soap);
+  soap_end_block(soap, b);
   return p;
 }
@@ -2031 +2632 @@
   if (!*attr1)
     return -1;
+  if (*attr1 == '[')
+    attr1++;
   n = 1;
-  do
-  { attr1++;
-    k = (int)soap_strtol(attr1, &s, 10);
+  for (;;)
+  { k = (int)soap_strtol(attr1, &s, 10);
     n *= k;
     if (k < 0 || n > SOAP_MAXARRAYSIZE || s == attr1)
@@ -2050 +2652 @@
       attr2 = s;
     }
-  } while (attr1 && *attr1 != ']');
+    if (!attr1)
+      break;
+    attr1++;
+  }
   return n - *j;
 }
@@ -2064 +2669 @@
   if (!*attr)
     return -1;
-  i = strlen(attr);
+  i = (int)strlen(attr);
   n = 1;
   do
@@ -2109 +2714 @@
 { register struct soap_nlist *np;
   register struct Namespace *p;
-  np = (struct soap_nlist*)SOAP_MALLOC(sizeof(struct soap_nlist) + strlen(id));
+  register short i = -1;
+  register size_t n, k;
+  n = strlen(id);
+  k = strlen(ns) + 1;
+  p = soap->local_namespaces;
+  if (p)
+  { for (i = 0; p->id; p++, i++)
+    { if (p->ns && !strcmp(ns, p->ns))
+      { if (p->out)
+        { SOAP_FREE(soap, p->out);
+          p->out = NULL;
+        }
+        break;
+      }
+      if (p->out)
+      { if (!strcmp(ns, p->out))
+          break;
+      }
+      else if (p->in)
+      { if (!soap_tag_cmp(ns, p->in))
+        { if ((p->out = (char*)SOAP_MALLOC(soap, k)))
+            strcpy(p->out, ns);
+          break;
+        }
+      }
+    }
+    if (!p || !p->id)
+      i = -1;
+  }
+  if (i >= 0)
+    k = 0;
+  np = (struct soap_nlist*)SOAP_MALLOC(soap, sizeof(struct soap_nlist) + n + k);
   if (!np)
     return soap->error = SOAP_EOM;
   np->next = soap->nlist;
   soap->nlist = np;
+  np->level = soap->level;
+  np->index = i;
   strcpy(np->id, id);
-  np->level = soap->level;
-  np->index = -1;
-  np->ns = NULL;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Push namespace binding (level=%u) '%s' '%s'\n", soap->level, id, ns));
-  p = soap->local_namespaces;
-  if (p)
-  { register short i = 0;
-    for (; p->id; p++, i++)
-    { if (p->ns && !strcmp(ns, p->ns))
-      { if (p->out)
-        { SOAP_FREE(p->out);
-          p->out = NULL;
-        }
-        break;
-      }
-      if (p->out)
-      { if (!SOAP_STRCMP(ns, p->out))
-          break;
-      }
-      else if (p->in)
-      { if (!soap_tag_cmp(ns, p->in))
-        { if ((p->out = (char*)SOAP_MALLOC(strlen(ns) + 1)))
-            strcpy(p->out, ns);
-          break;
-        }
-      }
-    }
-    if (p && p->id)
-    { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Push OK ('%s' matches '%s' in namespace table)\n", id, p->id));
-      np->index = i;
-    }
-  }
-  if (!p || !p->id)
-  { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Push NOT OK: no match found for '%s' in namespace mapping table (added to stack anyway)\n", ns));
-    np->ns = (char*)SOAP_MALLOC(strlen(ns) + 1);
-    if (!np->ns)
-      return soap->error = SOAP_EOM;
+  if (i < 0)
+  { np->ns = np->id + n + 1;
     strcpy(np->ns, ns);
+    DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Push NOT OK: no match found for '%s' in namespace mapping table (added to stack anyway)\n", ns));
+  }
+  else
+  { np->ns = NULL;
+    DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Push OK ('%s' matches '%s' in namespace table)\n", id, p->id));
   }
   return SOAP_OK;
@@ -2164 +2773 @@
 SOAP_FMAC2
 soap_pop_namespace(struct soap *soap)
-{ register struct soap_nlist *np;
-  while (soap->nlist && soap->nlist->level >= soap->level)
-  { np = soap->nlist->next;
-    DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Popped namespace binding (level=%u) '%s'\n", soap->level, soap->nlist->id));
-    if (soap->nlist->ns)
-      SOAP_FREE(soap->nlist->ns);
-    SOAP_FREE(soap->nlist);
-    soap->nlist = np;
-  }
+{ register struct soap_nlist *np, *nq;
+  for (np = soap->nlist; np && np->level >= soap->level; np = nq)
+  { nq = np->next;
+    DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Pop namespace binding (level=%u) '%s'\n", soap->level, np->id));
+    SOAP_FREE(soap, np);
+  }
+  soap->nlist = np;
 }
 #endif
@@ -2181 +2788 @@
 int
 SOAP_FMAC2
-soap_match_namespace(struct soap *soap, const char *id1, const char *id2, int n1, int n2) 
+soap_match_namespace(struct soap *soap, const char *id1, const char *id2, size_t n1, size_t n2) 
 { register struct soap_nlist *np = soap->nlist;
   while (np && (strncmp(np->id, id1, n1) || np->id[n1]))
     np = np->next;
   if (np)
-  { if (np->index < 0 || (np->index >= 0 && soap->local_namespaces[np->index].id && (strncmp(soap->local_namespaces[np->index].id, id2, n2) || soap->local_namespaces[np->index].id[n2])))
+  { if (np->index < 0
+     || (soap->local_namespaces[np->index].id
+      && (strncmp(soap->local_namespaces[np->index].id, id2, n2)
+       || soap->local_namespaces[np->index].id[n2])))
       return SOAP_NAMESPACE;
     return SOAP_OK;
   }
-  if (n1 == 3 && n1 == n2 && !strcmp(id1, "xml") && !strcmp(id1, id2))
+  if (n1 == 3 && n1 == n2 && !strncmp(id1, "xml", 3) && !strncmp(id1, id2, 3))
     return SOAP_OK;
-  return SOAP_SYNTAX_ERROR; 
+  return soap->error = SOAP_SYNTAX_ERROR; 
+}
+#endif
+
+/******************************************************************************/
+#ifndef PALM_2
+SOAP_FMAC1
+const char*
+SOAP_FMAC2
+soap_current_namespace(struct soap *soap, const char *tag)
+{ register struct soap_nlist *np;
+  register const char *s;
+  if (!tag || !strncmp(tag, "xml", 3))
+    return NULL;
+  np = soap->nlist;
+  if (!(s = strchr(tag, ':')))
+  { while (np && *np->id) /* find default namespace, if present */
+      np = np->next;
+  }
+  else
+  { while (np && (strncmp(np->id, tag, s - tag) || np->id[s - tag]))
+      np = np->next;
+    if (!np)
+      soap->error = SOAP_NAMESPACE;
+  }
+  if (np)
+  { if (np->index >= 0)
+      return soap->namespaces[np->index].ns;
+    if (np->ns)
+      return soap_strdup(soap, np->ns);
+  }
+  return NULL;
 }
 #endif
@@ -2217 +2858 @@
       { if (c2 != '*')
           return 1;
-        c2 = *++t;
+        c2 = *++t;
         if (!c2)
-          return 0;
+          return 0;
         if (c2 >= 'A' && c2 <= 'Z')
           c2 += 'a' - 'A';
         for (;;)
         { c1 = *s;
-          if (!c1 || c1 == '"')
-            break;
-          if (c1 >= 'A' && c1 <= 'Z')
+          if (!c1 || c1 == '"')
+            break;
+          if (c1 >= 'A' && c1 <= 'Z')
             c1 += 'a' - 'A';
-          if (c1 == c2)
-            if (!soap_tag_cmp(s + 1, t + 1))
-              return 0;
-          s++;
+          if (c1 == c2 && !soap_tag_cmp(s + 1, t + 1))
+            return 0;
+          s++;
         }
         break;
@@ -2252 +2892 @@
 soap_match_tag(struct soap *soap, const char *tag1, const char *tag2)
 { register const char *s, *t;
+  register int err;
   if (!tag1 || !tag2 || !*tag2)
     return SOAP_OK;
@@ -2260 +2901 @@
     { if (t[1] && SOAP_STRCMP(s + 1, t + 1))
         return SOAP_TAG_MISMATCH;
-      if (t != tag2 && soap_match_namespace(soap, tag1, tag2, s - tag1, t - tag2))
+      if (t != tag2 && (err = soap_match_namespace(soap, tag1, tag2, s - tag1, t - tag2)))
       { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Tags '%s' and '%s' match but namespaces differ\n", tag1, tag2));
-        return SOAP_TAG_MISMATCH;
+        if (err == SOAP_NAMESPACE)
+          return SOAP_TAG_MISMATCH;
+        return err;
       }
     } 
     else if (SOAP_STRCMP(tag1, t + 1))
-      return SOAP_TAG_MISMATCH;
-    else if (t != tag2 && soap_match_namespace(soap, tag1, tag2, 0, t - tag2))
+    { return SOAP_TAG_MISMATCH;
+    }
+    else if (t != tag2 && (err = soap_match_namespace(soap, tag1, tag2, 0, t - tag2)))
     { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Tags '%s' and '%s' match but namespaces differ\n", tag1, tag2));
-      return SOAP_TAG_MISMATCH;
+      if (err == SOAP_NAMESPACE)
+        return SOAP_TAG_MISMATCH;
+      return err;
     }
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Tags and (default) namespaces match: '%s' '%s'\n", tag1, tag2));
@@ -2303 +2949 @@
 #endif
 
-/******************************************************************************/
+/******************************************************************************\
+ *
+ *      SSL
+ *
+\******************************************************************************/
 
 #ifdef WITH_OPENSSL
+/******************************************************************************/
+#ifndef PALM_2
+SOAP_FMAC1
+int
+SOAP_FMAC2
+soap_rand()
+{ unsigned char buf[4];
+  if (!soap_ssl_init_done)
+    soap_ssl_init();
+  RAND_pseudo_bytes(buf, 4);
+  return *(int*)buf;
+}
+#endif
+
 /******************************************************************************/
 #ifndef PALM_2
@@ -2317 +2981 @@
   soap->cafile = cafile;
   soap->capath = capath;
-  if (dhfile)
-  { soap->dhfile = dhfile;
-    soap->rsa = 0;
-  }
-  else
-  { soap->dhfile = NULL;
-    soap->rsa = 1;
-  }
+  soap->dhfile = dhfile;
   soap->randfile = randfile;
-  soap->require_client_auth = (flags & SOAP_SSL_REQUIRE_CLIENT_AUTHENTICATION);
+  soap->ssl_flags = flags | (dhfile == NULL ? SOAP_SSL_RSA : 0);
   if (!(err = soap->fsslauth(soap)))
-    if (sid)
-      SSL_CTX_set_session_id_context(soap->ctx, (unsigned char*)sid, strlen(sid));
+  { if (sid)
+      SSL_CTX_set_session_id_context(soap->ctx, (unsigned char*)sid, (unsigned int)strlen(sid));
+  }
   return err; 
 }
@@ -2345 +3003 @@
   soap->capath = capath;
   soap->dhfile = NULL;
-  soap->rsa = 0;
+  soap->ssl_flags = flags;
   soap->randfile = randfile;
-  soap->require_server_auth = (flags & SOAP_SSL_REQUIRE_SERVER_AUTHENTICATION);
+  soap->fsslverify = (flags & SOAP_SSL_ALLOW_EXPIRED_CERTIFICATE) == 0 ? ssl_verify_callback : ssl_verify_callback_allow_expired_certificate;
   return soap->fsslauth(soap);
 }
@@ -2354 +3012 @@
 /******************************************************************************/
 #ifndef PALM_2
-static void
-ssl_init()
-{ static int done = 0;
-  if (!done)
-  { done = 1;
+SOAP_FMAC1
+void
+SOAP_FMAC2
+soap_ssl_init()
+{ /* Note: for MT systems, the main program MUST call soap_ssl_init() before any threads are started */
+  if (!soap_ssl_init_done)
+  { soap_ssl_init_done = 1;
     SSL_library_init();
 #ifndef WITH_LEAN
@@ -2364 +3024 @@
 #endif
     if (!RAND_load_file("/dev/urandom", 1024))
-    { int r;
-#ifdef HAVE_RAND_R
-      unsigned int s = (unsigned int)time(NULL);
-#endif
-      char buf[SOAP_BUFLEN];
+    { char buf[1024];
       RAND_seed(buf, sizeof(buf));
       while (!RAND_status())
-      {
-#ifdef HAVE_RAND_R
-        r = rand_r(&s);
-#else
-        r = rand();
-#endif
+      { int r = rand();
         RAND_seed(&r, sizeof(int));
       }
@@ -2386 +3037 @@
 /******************************************************************************/
 #ifndef PALM_1
-static const char *
-ssl_error(struct soap *soap, int ret)
+SOAP_FMAC1
+const char *
+SOAP_FMAC2
+soap_ssl_error(struct soap *soap, int ret)
 { int err = SSL_get_error(soap->ssl, ret);
-  const char *msg = soap_str_code(h_ssl_error_codes, err);
+  const char *msg = soap_code_str(h_ssl_error_codes, err);
   if (msg)
     strcpy(soap->msgbuf, msg);
@@ -2420 +3073 @@
 { if (num < (int)strlen((char*)userdata) + 1)
     return 0;
-  return strlen(strcpy(buf, (char*)userdata));
+  return (int)strlen(strcpy(buf, (char*)userdata));
 }
 #endif
@@ -2458 +3111 @@
 #endif
 */
+
 /******************************************************************************/
 #ifndef PALM_1
 static int
 ssl_auth_init(struct soap *soap)
-{ ssl_init();
+{ long flags;
+  int mode;
+  if (!soap_ssl_init_done)
+    soap_ssl_init();
+  ERR_clear_error();
   if (!soap->ctx)
-    if (!(soap->ctx = SSL_CTX_new(SSLv23_method())))
+  { if (!(soap->ctx = SSL_CTX_new(SSLv23_method())))
       return soap_set_receiver_error(soap, "SSL error", "Can't setup context", SOAP_SSL_ERROR);
+    /* Alters the behavior of SSL read/write:
+    SSL_CTX_set_mode(soap->ctx, SSL_MODE_ENABLE_PARTIAL_WRITE | SSL_MODE_AUTO_RETRY);
+    */
+  }
   if (soap->randfile)
   { if (!RAND_load_file(soap->randfile, -1))
@@ -2471 +3133 @@
   }
   if (soap->cafile || soap->capath)
-    if (!SSL_CTX_load_verify_locations(soap->ctx, soap->cafile, soap->capath))
-      return soap_set_receiver_error(soap, "SSL error", "Can't read CA file and/or directory", SOAP_SSL_ERROR);
+  { if (!SSL_CTX_load_verify_locations(soap->ctx, soap->cafile, soap->capath))
+      return soap_set_receiver_error(soap, "SSL error", "Can't read CA file and directory", SOAP_SSL_ERROR);
+    if (soap->cafile && (soap->ssl_flags & SOAP_SSL_REQUIRE_CLIENT_AUTHENTICATION))
+      SSL_CTX_set_client_CA_list(soap->ctx, SSL_load_client_CA_file(soap->cafile));
+  }
   if (!SSL_CTX_set_default_verify_paths(soap->ctx))
     return soap_set_receiver_error(soap, "SSL error", "Can't read default CA file and/or directory", SOAP_SSL_ERROR);
+/* This code assumes a typical scenario, see alternative code below */
   if (soap->keyfile)
   { if (!SSL_CTX_use_certificate_chain_file(soap->ctx, soap->keyfile))
@@ -2481 +3147 @@
     { SSL_CTX_set_default_passwd_cb_userdata(soap->ctx, (void*)soap->password);
       SSL_CTX_set_default_passwd_cb(soap->ctx, ssl_password);
+    }
+    if (!SSL_CTX_use_PrivateKey_file(soap->ctx, soap->keyfile, SSL_FILETYPE_PEM))
+      return soap_set_receiver_error(soap, "SSL error", "Can't read key file", SOAP_SSL_ERROR);
+  }
+/* Suggested alternative approach to check the key file for certs (cafile=NULL):
+  if (soap->password)
+  { SSL_CTX_set_default_passwd_cb_userdata(soap->ctx, (void*)soap->password);
+    SSL_CTX_set_default_passwd_cb(soap->ctx, ssl_password);
+  }
+  if (!soap->cafile || !SSL_CTX_use_certificate_chain_file(soap->ctx, soap->cafile))
+  { if (soap->keyfile)
+    { if (!SSL_CTX_use_certificate_chain_file(soap->ctx, soap->keyfile))
+        return soap_set_receiver_error(soap, "SSL error", "Can't read certificate or key file", SOAP_SSL_ERROR);
       if (!SSL_CTX_use_PrivateKey_file(soap->ctx, soap->keyfile, SSL_FILETYPE_PEM))
         return soap_set_receiver_error(soap, "SSL error", "Can't read key file", SOAP_SSL_ERROR);
     }
   }
-  if (soap->rsa)
-  { RSA *rsa = RSA_generate_key(512, RSA_F4, NULL, NULL);
+*/
+  if ((soap->ssl_flags & SOAP_SSL_RSA))
+  { RSA *rsa = RSA_generate_key(1024, RSA_F4, NULL, NULL);
     if (!SSL_CTX_set_tmp_rsa(soap->ctx, rsa))
     { if (rsa)
@@ -2509 +3189 @@
     DH_free(dh);
   }
-  SSL_CTX_set_options(soap->ctx, SSL_OP_ALL | SSL_OP_NO_SSLv2);
-  SSL_CTX_set_verify(soap->ctx, soap->require_client_auth ? (SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT) : soap->require_server_auth ? SSL_VERIFY_PEER : SSL_VERIFY_NONE, soap->fsslverify);
+  flags = (SSL_OP_ALL | SSL_OP_NO_SSLv2);
+  if ((soap->ssl_flags & SOAP_SSLv3))
+    flags |= SSL_OP_NO_TLSv1;
+  if ((soap->ssl_flags & SOAP_TLSv1))
+    flags |= SSL_OP_NO_SSLv3;
+  SSL_CTX_set_options(soap->ctx, flags);
+  if ((soap->ssl_flags & SOAP_SSL_REQUIRE_CLIENT_AUTHENTICATION))
+    mode = (SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT);
+  else if ((soap->ssl_flags & SOAP_SSL_REQUIRE_SERVER_AUTHENTICATION))
+    mode = SSL_VERIFY_PEER;
+  else
+    mode = SSL_VERIFY_NONE;
+  SSL_CTX_set_verify(soap->ctx, mode, soap->fsslverify);
 #if (OPENSSL_VERSION_NUMBER < 0x00905100L)
   SSL_CTX_set_verify_depth(soap->ctx, 1); 
@@ -2529 +3220 @@
   { char data[256];
     X509 *cert = X509_STORE_CTX_get_current_cert(store);
-    fprintf(stderr, "SSL Verify error 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)));
+    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)));
     X509_NAME_oneline(X509_get_issuer_name(cert), data, sizeof(data));
     fprintf(stderr, "certificate issuer %s\n", data);
@@ -2536 +3227 @@
   }
 #endif
-  /* return 1 to always continue, but unsafe progress will be terminated by SSL */
+  /* Note: return 1 to continue, but unsafe progress will be terminated by SSL */
   return ok;
 }
@@ -2543 +3234 @@
 /******************************************************************************/
 #ifndef PALM_1
+static int
+ssl_verify_callback_allow_expired_certificate(int ok, X509_STORE_CTX *store)
+{ ok = ssl_verify_callback(ok, store);
+  if (ok == 0 && X509_STORE_CTX_get_error(store) == X509_V_ERR_CERT_HAS_EXPIRED)
+  {
+#ifdef SOAP_DEBUG
+    fprintf(stderr, "ignoring certificate expiration\n");
+#endif
+    X509_STORE_CTX_set_error(store, X509_V_OK);
+    ok = 1;
+  }
+  /* Note: return 1 to continue, but unsafe progress will be terminated by SSL */
+  return ok;
+}
+#endif
+
+/******************************************************************************/
+#ifndef PALM_1
 SOAP_FMAC1
 int
 SOAP_FMAC2
 soap_ssl_accept(struct soap *soap)
-{ int i, r;
+{ BIO *bio;
+  int retries, r, s;
   if (!soap_valid_socket(soap->socket))
     return soap_set_receiver_error(soap, "SSL error", "No socket in soap_ssl_accept()", SOAP_SSL_ERROR);
+  if (!soap->ctx && (soap->error = soap->fsslauth(soap)))
+    return SOAP_INVALID_SOCKET;
   if (!soap->ssl)
   { soap->ssl = SSL_new(soap->ctx);
@@ -2559 +3271 @@
   soap->imode |= SOAP_ENC_SSL;
   soap->omode |= SOAP_ENC_SSL;
-#ifdef WIN32
-  { u_long nonblocking = 1;
-    ioctlsocket((SOAP_SOCKET)soap->socket, FIONBIO, &nonblocking);
-  }
-#else
-  fcntl((SOAP_SOCKET)soap->socket, F_SETFL, fcntl((SOAP_SOCKET)soap->socket, F_GETFL)|O_NONBLOCK);
-#endif
-  soap->bio = BIO_new_socket((SOAP_SOCKET)soap->socket, BIO_NOCLOSE);
-  SSL_set_bio(soap->ssl, soap->bio, soap->bio);
-  i = 100; /* 100 * 0.1 ms retries */
+  /* Set SSL sockets to non-blocking */
+  SOAP_SOCKNONBLOCK(soap->socket)
+  bio = BIO_new_socket((int)soap->socket, BIO_NOCLOSE);
+  SSL_set_bio(soap->ssl, bio, bio);
+  retries = 100; /* 10 sec retries, 100 times 0.1 sec */
   while ((r = SSL_accept(soap->ssl)) <= 0)
   { int err = SSL_get_error(soap->ssl, r);
@@ -2574 +3281 @@
     { struct timeval timeout;
       fd_set fd;
-      if (i-- <= 0)
-        break;
+#ifndef WIN32
+      if ((int)soap->socket >= (int)FD_SETSIZE)
+        return SOAP_FD_EXCEEDED;        /* Hint: MUST increase FD_SETSIZE */
+#endif
       timeout.tv_sec = 0;
       timeout.tv_usec = 100000;
       FD_ZERO(&fd);
-      FD_SET((SOAP_SOCKET)soap->socket, &fd);
-      r = select((SOAP_SOCKET)(soap->socket + 1), &fd, NULL, &fd, &timeout);
-      if (r < 0 && soap_socket_errno != SOAP_EINTR)
-      { soap->errnum = soap_socket_errno;
-        return SOAP_EOF;
+      FD_SET(soap->socket, &fd);
+      if (err == SSL_ERROR_WANT_READ)
+        s = select((int)soap->socket + 1, &fd, NULL, &fd, &timeout);
+      else
+        s = select((int)soap->socket + 1, NULL, &fd, &fd, &timeout);
+      if (s < 0 && (s = soap_socket_errno(soap->socket)) != SOAP_EINTR)
+      { soap->errnum = s;
+        break;
       }
     }
@@ -2590 +3302 @@
       break;
     }
-  }
-#ifdef WIN32
-  { u_long blocking = 0;
-    ioctlsocket((SOAP_SOCKET)soap->socket, FIONBIO, &blocking);
-  }
-#else
-  fcntl((SOAP_SOCKET)soap->socket, F_SETFL, fcntl((SOAP_SOCKET)soap->socket, F_GETFL)&~O_NONBLOCK);
-#endif
+    if (retries-- <= 0)
+      break;
+  }
   if (r <= 0)
-  { soap_set_receiver_error(soap, ssl_error(soap, r), "SSL_accept() failed in soap_ssl_accept()", SOAP_SSL_ERROR);
+  { soap_set_receiver_error(soap, soap_ssl_error(soap, r), "SSL_accept() failed in soap_ssl_accept()", SOAP_SSL_ERROR);
     soap_closesock(soap);
     return SOAP_SSL_ERROR;
   }
-  if (soap->require_client_auth)
+  if ((soap->ssl_flags & SOAP_SSL_REQUIRE_CLIENT_AUTHENTICATION))
   { X509 *peer;
     int err;
@@ -2625 +3332 @@
 
 /******************************************************************************/
+#ifndef WITH_NOIO
 #ifndef PALM_1
 static int
@@ -2642 +3350 @@
 }
 #endif
+#endif
 
 /******************************************************************************/
@@ -2653 +3362 @@
   int i;
 #endif
-  soap_free(soap);
+  if (soap_check_state(soap))
+    return;
+  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Done with context\n"));
+  soap_free_temp(soap);
   while (soap->clist)
   { struct soap_clist *p = soap->clist->next;
-    SOAP_FREE(soap->clist);
+    SOAP_FREE(soap, soap->clist);
     soap->clist = p;
   }
@@ -2667 +3379 @@
   { register struct soap_plugin *p = soap->plugins->next;
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Removing plugin '%s'\n", soap->plugins->id));
-    if (soap->plugins->fcopy || !soap->copy)
+    if (soap->plugins->fcopy || soap->state == SOAP_INIT)
       soap->plugins->fdelete(soap, soap->plugins);
-    SOAP_FREE(soap->plugins);
+    SOAP_FREE(soap, soap->plugins);
     soap->plugins = p;
   }
   soap->fplugin = fplugin;
+  soap->fmalloc = NULL;
+#ifndef WITH_NOHTTP
   soap->fpost = http_post;
   soap->fget = http_get;
+  soap->fput = http_put;
+  soap->fdel = http_del;
+  soap->fhead = http_head;
+  soap->fform = NULL;
   soap->fposthdr = http_post_header;
   soap->fresponse = http_response;
   soap->fparse = http_parse;
   soap->fparsehdr = http_parse_header;
-#ifndef MAC_CARBON
+#endif
+  soap->fheader = NULL;
+#ifndef WITH_NOIO
 #ifndef WITH_IPV6
   soap->fresolve = tcp_gethost;
@@ -2694 +3414 @@
   soap->fpoll = soap_poll;
 #else
+  soap->fopen = NULL;
+  soap->fclose = NULL;
   soap->fpoll = NULL;
 #endif
+#ifndef WITH_LEANER
   soap->fprepareinit = NULL;
   soap->fpreparesend = NULL;
   soap->fpreparerecv = NULL;
+  soap->fpreparefinal = NULL;
+#endif
+  soap->fseterror = NULL;
   soap->fignore = NULL;
   soap->fserveloop = NULL;
@@ -2707 +3433 @@
   }
 #endif
-  if (!soap->copy)
+  if (soap->state == SOAP_INIT)
   { if (soap_valid_socket(soap->master))
-    { soap->fclosesocket(soap, (SOAP_SOCKET)soap->master);
+    { soap->fclosesocket(soap, soap->master);
       soap->master = SOAP_INVALID_SOCKET;
     }
+  }
 #ifdef WITH_OPENSSL
-    if (soap->ctx)
+  if (soap->ssl)
+  { SSL_free(soap->ssl);
+    soap->ssl = NULL;
+  }
+  if (soap->state == SOAP_INIT)
+  { if (soap->ctx)
     { SSL_CTX_free(soap->ctx);
       soap->ctx = NULL;
     }
-#endif
-  }
+  }
+#endif
+#ifdef WITH_OPENSSL
+  ERR_remove_state(0);
+#endif
+#ifdef WITH_C_LOCALE
+  freelocale(soap->c_locale);
+#endif
+#ifdef WITH_ZLIB
+  if (soap->d_stream)
+  { SOAP_FREE(soap, (void*)soap->d_stream);
+    soap->d_stream = NULL;
+  }
+  if (soap->z_buf)
+  { SOAP_FREE(soap, (void*)soap->z_buf);
+    soap->z_buf = NULL;
+  }
+#endif
 #ifdef SOAP_DEBUG
+  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free logfiles\n"));
   for (i = 0; i < SOAP_MAXLOGS; i++)
-  { soap_close_logfile(soap, i);
-    if (soap->logfile[i])
-    { SOAP_FREE((void*)soap->logfile[i]);
+  { if (soap->logfile[i])
+    { SOAP_FREE(soap, (void*)soap->logfile[i]);
       soap->logfile[i] = NULL;
     }
-  }
-#endif
-}
-#endif
-
-/******************************************************************************/
+    soap_close_logfile(soap, i);
+  }
+  soap->state = SOAP_NONE;
+#endif
+#ifdef SOAP_MEM_DEBUG
+  soap_free_mht(soap);
+#endif
+}
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOIO
 #ifndef PALM_2
 SOAP_FMAC1
@@ -2746 +3500 @@
 }
 #endif
-
-/******************************************************************************/
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOIO
 #ifndef PALM_1
 static const char*
@@ -2762 +3518 @@
     {
 #ifndef WITH_LEAN
-      msg = soap_str_code(h_error_codes, soap->errnum);
+      msg = soap_code_str(h_error_codes, soap->errnum);
       if (!msg)
 #endif
-      { sprintf(soap->msgbuf, "TCP error %d", soap->errnum);
+      { sprintf(soap->msgbuf, "TCP/UDP IP error %d", soap->errnum);
         msg = soap->msgbuf;
       }
@@ -2773 +3529 @@
 }
 #endif
-
-/******************************************************************************/
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOHTTP
 #ifndef PALM_1
 static const char*
 http_error(struct soap *soap, int status)
-{ register const char *msg = NULL;
+{ register const char *msg = SOAP_STR_EOS;
 #ifndef WITH_LEAN
-  msg = soap_str_code(h_http_error_codes, status);
+  msg = soap_code_str(h_http_error_codes, status);
   if (!msg)
-#endif
-  { sprintf(soap->msgbuf, "HTTP error %d", status);
-    msg = soap->msgbuf;
-  }
+    msg = SOAP_STR_EOS;
+#endif
   return msg;
 }
 #endif
-
-/******************************************************************************/
-/* WR[ */
+#endif
+
+/******************************************************************************/
 #ifndef WITH_IPV6
-/* ]WR */
-#ifndef MAC_CARBON
+#ifndef WITH_NOIO
 #ifndef PALM_1
 static int
 tcp_gethost(struct soap *soap, const char *addr, struct in_addr *inaddr)
-{ unsigned long iadd;
+{ soap_int32 iadd = -1;
   struct hostent hostent, *host = &hostent;
-/* WR[ */
 #ifdef VXWORKS
   int hostint;
-  char *addrcopy = (char*)malloc(strlen(addr) + 1); /*copy of addr. */
   /* inet_addr(), and hostGetByName() expect "char *"; addr is a "const char *". */
-  strncpy(addrcopy, addr, strlen(addr)+1);
-  iadd = inet_addr(addrcopy);
+  iadd = inet_addr((char*)addr);
 #else
-/* ]WR */
-#if defined(_AIXVERSION_431) || defined(TRU64)
+#if defined(_AIX43) || ((defined(TRU64) || defined(HP_UX)) && defined(HAVE_GETHOSTBYNAME_R))
   struct hostent_data ht_data;
 #endif
+#ifdef AS400
+  iadd = inet_addr((void*)addr);
+#else
   iadd = inet_addr(addr);
-/* WR[ */
-#endif
-/* ]WR */
-  if ((int)iadd != -1)
+#endif
+#endif
+  if (iadd != -1)
   { memcpy(inaddr, &iadd, sizeof(iadd));
-/* WR[ */
-#ifdef VXWORKS
-    free(addrcopy);
-#endif
-/* ]WR */
     return SOAP_OK;
   }
-#if defined(__GLIBC__)
+#if defined(__GLIBC__) || (defined(HAVE_GETHOSTBYNAME_R) && (defined(FREEBSD) || defined(__FreeBSD__)))
   if (gethostbyname_r(addr, &hostent, soap->buf, SOAP_BUFLEN, &host, &soap->errnum) < 0)
     host = NULL;
-#elif defined(_AIXVERSION_431) || defined(TRU64)
+#elif defined(_AIX43) || ((defined(TRU64) || defined(HP_UX)) && defined(HAVE_GETHOSTBYNAME_R))
   memset((void*)&ht_data, 0, sizeof(ht_data));
   if (gethostbyname_r(addr, &hostent, &ht_data) < 0)
@@ -2836 +3584 @@
 #elif defined(HAVE_GETHOSTBYNAME_R)
   host = gethostbyname_r(addr, &hostent, soap->buf, SOAP_BUFLEN, &soap->errnum);
-/* WR[ */
 #elif defined(VXWORKS)
   /* If the DNS resolver library resolvLib has been configured in the vxWorks
    * image, a query for the host IP address is sent to the DNS server, if the
    * name was not found in the local host table. */
-  hostint = hostGetByName(addrcopy);
+  hostint = hostGetByName((char*)addr);
   if (hostint == ERROR)
   { host = NULL;
     soap->errnum = soap_errno; 
   }
-  free(addrcopy);  /*free() is placed after the error checking to assure that
-                    * errno captured is that from hostGetByName() */
-/* ]WR */
+#else
+#ifdef AS400
+  if (!(host = gethostbyname((void*)addr)))
+    soap->errnum = h_errno;
 #else
   if (!(host = gethostbyname(addr)))
     soap->errnum = h_errno;
 #endif
+#endif
   if (!host)
   { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Host name not found\n"));
     return SOAP_ERR;
   }
-/* WR[ */
 #ifdef VXWORKS
   inaddr->s_addr = hostint;
 #else
-/* ]WR */
   memcpy(inaddr, host->h_addr, host->h_length);
-/* WR[ */
-#endif
-/* ]WR */
+#endif
   return SOAP_OK;
 }
 #endif
 #endif
-/* WR[ */
-#endif /* WITH_IPV6 */
-/* ]WR */
-
-/******************************************************************************/
-#ifndef MAC_CARBON
-#ifndef PALM_1
-static int
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOIO
+#ifndef PALM_1
+static SOAP_SOCKET
 tcp_connect(struct soap *soap, const char *endpoint, const char *host, int port)
-{ struct sockaddr_in sockaddr;
-/* WR[ */
+{
 #ifdef WITH_IPV6
-  struct addrinfo *addrinfo;
-  struct addrinfo hints;
-  struct addrinfo resaddr;
-  struct sockaddr_storage addrstorage;
-  int err;
-#endif /* WITH_IPV6 */
-/* ]WR */
-  register int fd;
+  struct addrinfo hints, *res, *ressave;
+#endif
+  SOAP_SOCKET fd;
+  int err = 0;
 #ifndef WITH_LEAN
+  int retry = 10;
   int len = SOAP_BUFLEN;
   int set = 1;
 #endif
   if (soap_valid_socket(soap->socket))
-    soap->fclosesocket(soap, (SOAP_SOCKET)soap->socket);
+    soap->fclosesocket(soap, soap->socket);
   soap->socket = SOAP_INVALID_SOCKET;
   if (tcp_init(soap))
-  { soap_set_sender_error(soap, tcp_error(soap), "TCP initialization failed in tcp_connect()", SOAP_TCP_ERROR);
-    return -1;
+  { soap->errnum = 0;
+    soap_set_sender_error(soap, tcp_error(soap), "TCP init failed in tcp_connect()", SOAP_TCP_ERROR);
+    return SOAP_INVALID_SOCKET;
   }
   soap->errmode = 0;
-/* WR[ */
 #ifdef WITH_IPV6
   memset((void*)&hints, 0, sizeof(hints));
   hints.ai_family = PF_UNSPEC;
-  hints.ai_socktype = SOCK_STREAM;
+#ifndef WITH_LEAN
+  if ((soap->omode & SOAP_IO_UDP))
+    hints.ai_socktype = SOCK_DGRAM;
+  else
+#endif
+    hints.ai_socktype = SOCK_STREAM;
   soap->errmode = 2;
   if (soap->proxy_host)
-    err = getaddrinfo(soap->proxy_host, soap_int2s(soap, soap->proxy_port), &hints, &addrinfo);
+    err = getaddrinfo(soap->proxy_host, soap_int2s(soap, soap->proxy_port), &hints, &res);
   else
-    err = getaddrinfo(host, soap_int2s(soap, port), &hints, &addrinfo);
-  if (addrinfo)
-  { resaddr = *addrinfo;
-    addrstorage = *((struct sockaddr_storage*)addrinfo->ai_addr);
-    resaddr.ai_addr = (struct sockaddr*)&addrstorage;
-    freeaddrinfo(addrinfo);
-  }
+    err = getaddrinfo(host, soap_int2s(soap, port), &hints, &res);
   if (err)
-  { soap_set_sender_error(soap, gai_strerror(err), 
-    "TCP getaddrinfo on proxy host failed in tcp_connect()", SOAP_TCP_ERROR);
-    return -1;
-  }
-  fd = (int)socket(resaddr.ai_family, resaddr.ai_socktype, resaddr.ai_protocol); /* modified to use fd */
+  { soap_set_sender_error(soap, SOAP_GAI_STRERROR(err), "getaddrinfo failed in tcp_connect()", SOAP_TCP_ERROR);
+    return SOAP_INVALID_SOCKET;
+  }
+  ressave = res;
+again:
+  fd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
   soap->errmode = 0;
-#else /* WITH_IPV6 */
-/* ]WR */
-  fd = (int)socket(AF_INET, SOCK_STREAM, 0);
-/* WR[ */
-#endif /* WITH_IPV6 */
-/* ]WR */
-  if (fd < 0)
-  { soap->errnum = soap_socket_errno;
-    soap_set_sender_error(soap, tcp_error(soap), "TCP socket failed in tcp_connect()", SOAP_TCP_ERROR);
-    return -1;
+#else
+#ifndef WITH_LEAN
+again:
+#endif
+#ifndef WITH_LEAN
+  if ((soap->omode & SOAP_IO_UDP))
+    fd = socket(AF_INET, SOCK_DGRAM, 0);
+  else
+#endif
+    fd = socket(AF_INET, SOCK_STREAM, 0);
+#endif
+  if (!soap_valid_socket(fd))
+  {
+#ifdef WITH_IPV6
+    if (res->ai_next)
+    { res = res->ai_next;
+      goto again;
+    }
+#endif
+    soap->errnum = soap_socket_errno(fd);
+    soap_set_sender_error(soap, tcp_error(soap), "socket failed in tcp_connect()", SOAP_TCP_ERROR);
+#ifdef WITH_IPV6
+    freeaddrinfo(ressave);
+#endif
+    return SOAP_INVALID_SOCKET;
   }
 #ifdef SOCKET_CLOSE_ON_EXEC
@@ -2942 +3696 @@
 #endif
 #else
-  fcntl (fd, F_SETFD, 1);
+  fcntl(fd, F_SETFD, 1);
 #endif
 #endif
 #ifndef WITH_LEAN
-  if (soap->connect_flags & SO_LINGER)
+  if (soap->connect_flags == SO_LINGER)
   { struct linger linger;
     memset((void*)&linger, 0, sizeof(linger));
     linger.l_onoff = 1;
-    linger.l_linger = 0;
-    if (setsockopt((SOAP_SOCKET)fd, SOL_SOCKET, SO_LINGER, (char*)&linger, sizeof(struct linger)))
-    { soap->errnum = soap_socket_errno;
-      soap_set_sender_error(soap, tcp_error(soap), "TCP setsockopt SO_LINGER failed in tcp_connect()", SOAP_TCP_ERROR);
-      soap->fclosesocket(soap, (SOAP_SOCKET)fd);
-      return -1;
-    }
-  }
-  if ((soap->connect_flags & ~SO_LINGER) && setsockopt((SOAP_SOCKET)fd, SOL_SOCKET, soap->connect_flags & ~SO_LINGER, (char*)&set, sizeof(int)))
-  { soap->errnum = soap_socket_errno;
-    soap_set_sender_error(soap, tcp_error(soap), "TCP setsockopt failed in tcp_connect()", SOAP_TCP_ERROR);
+    linger.l_linger = soap->linger_time;
+    if (setsockopt(fd, SOL_SOCKET, SO_LINGER, (char*)&linger, sizeof(struct linger)))
+    { soap->errnum = soap_socket_errno(fd);
+      soap_set_sender_error(soap, tcp_error(soap), "setsockopt SO_LINGER failed in tcp_connect()", SOAP_TCP_ERROR);
+      soap->fclosesocket(soap, fd);
+#ifdef WITH_IPV6
+      freeaddrinfo(ressave);
+#endif
+      return SOAP_INVALID_SOCKET;
+    }
+  }
+  else if (soap->connect_flags && setsockopt(fd, SOL_SOCKET, soap->connect_flags, (char*)&set, sizeof(int)))
+  { soap->errnum = soap_socket_errno(fd);
+    soap_set_sender_error(soap, tcp_error(soap), "setsockopt failed in tcp_connect()", SOAP_TCP_ERROR);
+    soap->fclosesocket(soap, fd);
+#ifdef WITH_IPV6
+    freeaddrinfo(ressave);
+#endif
+    return SOAP_INVALID_SOCKET;
+  }
+  if ((soap->keep_alive || soap->tcp_keep_alive) && setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (char*)&set, sizeof(int)))
+  { soap->errnum = soap_socket_errno(fd);
+    soap_set_sender_error(soap, tcp_error(soap), "setsockopt SO_KEEPALIVE failed in tcp_connect()", SOAP_TCP_ERROR);
+    soap->fclosesocket(soap, fd);
+#ifdef WITH_IPV6
+    freeaddrinfo(ressave);
+#endif
+    return SOAP_INVALID_SOCKET;
+  }
+  if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (char*)&len, sizeof(int)))
+  { soap->errnum = soap_socket_errno(fd);
+    soap_set_sender_error(soap, tcp_error(soap), "setsockopt SO_SNDBUF failed in tcp_connect()", SOAP_TCP_ERROR);
+    soap->fclosesocket(soap, fd);
+#ifdef WITH_IPV6
+    freeaddrinfo(ressave);
+#endif
+    return SOAP_INVALID_SOCKET;
+  }
+  if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, (char*)&len, sizeof(int)))
+  { soap->errnum = soap_socket_errno(fd);
+    soap_set_sender_error(soap, tcp_error(soap), "setsockopt SO_RCVBUF failed in tcp_connect()", SOAP_TCP_ERROR);
+    soap->fclosesocket(soap, fd);
+#ifdef WITH_IPV6
+    freeaddrinfo(ressave);
+#endif
+    return SOAP_INVALID_SOCKET;
+  }
+#ifdef TCP_KEEPIDLE
+  if (soap->tcp_keep_idle && setsockopt((SOAP_SOCKET)fd, IPPROTO_TCP, TCP_KEEPIDLE, (unsigned int*)&(soap->tcp_keep_idle), sizeof(int)))
+  { soap->errnum = soap_socket_errno(fd);
+    soap_set_sender_error(soap, tcp_error(soap), "setsockopt TCP_KEEPIDLE failed in tcp_connect()", SOAP_TCP_ERROR);
     soap->fclosesocket(soap, (SOAP_SOCKET)fd);
-    return -1;
-  }
-  if (soap->keep_alive && setsockopt((SOAP_SOCKET)fd, SOL_SOCKET, SO_KEEPALIVE, (char*)&set, sizeof(int)))
-  { soap->errnum = soap_socket_errno;
-    soap_set_sender_error(soap, tcp_error(soap), "TCP setsockopt SO_KEEPALIVE failed in tcp_connect()", SOAP_TCP_ERROR);
+#ifdef WITH_IPV6
+    freeaddrinfo(ressave);
+#endif
+    return SOAP_INVALID_SOCKET;
+  }
+#endif
+#ifdef TCP_KEEPINTVL
+  if (soap->tcp_keep_intvl && setsockopt((SOAP_SOCKET)fd, IPPROTO_TCP, TCP_KEEPINTVL, (unsigned int*)&(soap->tcp_keep_intvl), sizeof(int)))
+  { soap->errnum = soap_socket_errno(fd);
+    soap_set_sender_error(soap, tcp_error(soap), "setsockopt TCP_KEEPINTVL failed in tcp_connect()", SOAP_TCP_ERROR);
     soap->fclosesocket(soap, (SOAP_SOCKET)fd);
-    return -1;
-  }
-  if (setsockopt((SOAP_SOCKET)fd, SOL_SOCKET, SO_SNDBUF, (char*)&len, sizeof(int)))
-  { soap->errnum = soap_socket_errno;
-    soap_set_sender_error(soap, tcp_error(soap), "TCP setsockopt SO_SNDBUF failed in tcp_connect()", SOAP_TCP_ERROR);
+#ifdef WITH_IPV6
+    freeaddrinfo(ressave);
+#endif
+    return SOAP_INVALID_SOCKET;
+  }
+#endif
+#ifdef TCP_KEEPCNT
+  if (soap->tcp_keep_cnt && setsockopt((SOAP_SOCKET)fd, IPPROTO_TCP, TCP_KEEPCNT, (unsigned int*)&(soap->tcp_keep_cnt), sizeof(int)))
+  { soap->errnum = soap_socket_errno(fd);
+    soap_set_sender_error(soap, tcp_error(soap), "setsockopt TCP_KEEPCNT failed in tcp_connect()", SOAP_TCP_ERROR);
     soap->fclosesocket(soap, (SOAP_SOCKET)fd);
-    return -1;
-  }
-  if (setsockopt((SOAP_SOCKET)fd, SOL_SOCKET, SO_RCVBUF, (char*)&len, sizeof(int)))
-  { soap->errnum = soap_socket_errno;
-    soap_set_sender_error(soap, tcp_error(soap), "TCP setsockopt SO_RCVBUF failed in tcp_connect()", SOAP_TCP_ERROR);
-    soap->fclosesocket(soap, (SOAP_SOCKET)fd);
-    return -1;
-  }
+#ifdef WITH_IPV6
+    freeaddrinfo(ressave);
+#endif
+    return SOAP_INVALID_SOCKET;
+  }
+#endif
 #ifdef TCP_NODELAY
-  if (setsockopt((SOAP_SOCKET)fd, IPPROTO_TCP, TCP_NODELAY, (char*)&set, sizeof(int)))
-  { soap->errnum = soap_socket_errno;
-    soap_set_sender_error(soap, tcp_error(soap), "TCP setsockopt TCP_NODELAY failed in tcp_connect()", SOAP_TCP_ERROR);
-    soap->fclosesocket(soap, (SOAP_SOCKET)fd);
-    return -1;
-  }
-#endif
-#endif
-/* WR[ */
+  if (!(soap->omode & SOAP_IO_UDP) && setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char*)&set, sizeof(int)))
+  { soap->errnum = soap_socket_errno(fd);
+    soap_set_sender_error(soap, tcp_error(soap), "setsockopt TCP_NODELAY failed in tcp_connect()", SOAP_TCP_ERROR);
+    soap->fclosesocket(soap, fd);
+#ifdef WITH_IPV6
+    freeaddrinfo(ressave);
+#endif
+    return SOAP_INVALID_SOCKET;
+  }
+#endif
+#ifdef WITH_IPV6
+  if ((soap->omode & SOAP_IO_UDP) && soap->ipv6_multicast_if)
+  { struct sockaddr_in6 *in6addr = (struct sockaddr_in6*)res->ai_addr;
+    in6addr->sin6_scope_id = soap->ipv6_multicast_if;
+  }
+#else
+  if ((soap->omode & SOAP_IO_UDP) && soap->ipv4_multicast_if)
+  { if (soap->ipv4_multicast_ttl > 0)
+    { char ttl = (char)(soap->ipv4_multicast_ttl);
+      if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl)))
+      { soap->errnum = soap_socket_errno(fd);
+        soap_set_sender_error(soap, tcp_error(soap), "setsockopt IP_MULTICAST_TTL failed in tcp_connect()", SOAP_TCP_ERROR);
+        soap->fclosesocket(soap, fd);
+        return SOAP_INVALID_SOCKET;
+      }
+    }
+#ifndef WINDOWS
+    if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF, soap->ipv4_multicast_if, sizeof(struct in_addr))) 
+    { soap->errnum = soap_socket_errno(fd);
+      soap_set_sender_error(soap, tcp_error(soap), "setsockopt IP_MULTICAST_IF failed in tcp_connect()", SOAP_TCP_ERROR);
+      soap->fclosesocket(soap, fd);
+      return SOAP_INVALID_SOCKET;
+    }
+#else
+#ifndef IP_MULTICAST_IF
+#define IP_MULTICAST_IF 2
+#endif
+    if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF, soap->ipv4_multicast_if, sizeof(struct in_addr))) 
+    { soap->errnum = soap_socket_errno(fd);
+      soap_set_sender_error(soap, tcp_error(soap), "setsockopt IP_MULTICAST_IF failed in tcp_connect()", SOAP_TCP_ERROR);
+      soap->fclosesocket(soap, fd);
+      return SOAP_INVALID_SOCKET;
+    }
+#endif
+  }
+#endif
+#endif
+  DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Opening socket %d to host='%s' port=%d\n", fd, host, port));
 #ifndef WITH_IPV6
-/* ]WR */
-  memset((void*)&sockaddr, 0, sizeof(sockaddr));
-  sockaddr.sin_family = AF_INET;
-  DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Open socket %d to host='%s'\n", fd, host));
+  soap->peerlen = sizeof(soap->peer);
+  memset((void*)&soap->peer, 0, sizeof(soap->peer));
+  soap->peer.sin_family = AF_INET;
   soap->errmode = 2;
   if (soap->proxy_host)
-  { if (soap->fresolve(soap, soap->proxy_host, &sockaddr.sin_addr))
-    { soap_set_sender_error(soap, tcp_error(soap), "TCP get proxy host by name failed in tcp_connect()", SOAP_TCP_ERROR);
-      soap->fclosesocket(soap, (SOAP_SOCKET)fd);
-      return -1;
-    }
-    sockaddr.sin_port = htons((short)soap->proxy_port);
+  { if (soap->fresolve(soap, soap->proxy_host, &soap->peer.sin_addr))
+    { soap_set_sender_error(soap, tcp_error(soap), "get proxy host by name failed in tcp_connect()", SOAP_TCP_ERROR);
+      soap->fclosesocket(soap, fd);
+#ifdef WITH_IPV6
+      freeaddrinfo(ressave);
+#endif
+      return SOAP_INVALID_SOCKET;
+    }
+    soap->peer.sin_port = htons((short)soap->proxy_port);
   }
   else
-  { if (soap->fresolve(soap, host, &sockaddr.sin_addr))
-    { soap_set_sender_error(soap, tcp_error(soap), "TCP get host by name failed in tcp_connect()", SOAP_TCP_ERROR);
-      soap->fclosesocket(soap, (SOAP_SOCKET)fd);
-      return -1;
-    }
-    sockaddr.sin_port = htons((short)port);
+  { if (soap->fresolve(soap, host, &soap->peer.sin_addr))
+    { soap_set_sender_error(soap, tcp_error(soap), "get host by name failed in tcp_connect()", SOAP_TCP_ERROR);
+      soap->fclosesocket(soap, fd);
+#ifdef WITH_IPV6
+      freeaddrinfo(ressave);
+#endif
+      return SOAP_INVALID_SOCKET;
+    }
+    soap->peer.sin_port = htons((short)port);
   }
   soap->errmode = 0;
-/* WR[ */
-#endif /* WITH_IPV6 */
-/* ]WR */
+#ifndef WITH_LEAN
+  if ((soap->omode & SOAP_IO_UDP))
+  {
+#ifdef WITH_IPV6
+    freeaddrinfo(ressave);
+#endif
+    return fd;
+  }
+#endif
+#endif
 #ifndef WITH_LEAN
   if (soap->connect_timeout)
-#if defined(WIN32)
-  { u_long nonblocking = 1;
-    ioctlsocket((SOAP_SOCKET)fd, FIONBIO, &nonblocking);
-  }
-/* WR[ */
-#elif defined(VXWORKS)
-  { vx_nonblocking = TRUE;
-    ioctl((SOAP_SOCKET)fd, FIONBIO, (int)(&vx_nonblocking)); /* modified to use fd */
-  }
-/* ]WR */
-#else
-    fcntl((SOAP_SOCKET)fd, F_SETFL, fcntl((SOAP_SOCKET)fd, F_GETFL)|O_NONBLOCK);
-#endif
+    SOAP_SOCKNONBLOCK(fd)
   else
-#if defined(WIN32)
-  { u_long blocking = 0;
-    ioctlsocket((SOAP_SOCKET)fd, FIONBIO, &blocking);
-  }
-/* WR[ */
-#elif defined(VXWORKS)
-  { vx_nonblocking = FALSE;
-    ioctl((SOAP_SOCKET)fd, FIONBIO, (int)(&vx_nonblocking)); /* modified to use fd */
-  }
-/* ]WR */
-#else
-    fcntl((SOAP_SOCKET)fd, F_SETFL, fcntl((SOAP_SOCKET)fd, F_GETFL)&~O_NONBLOCK);
-#endif
+    SOAP_SOCKBLOCK(fd)
 #endif
   for (;;)
   { 
-/* WR[ */
 #ifdef WITH_IPV6
-    if (connect((SOAP_SOCKET)fd, resaddr.ai_addr, resaddr.ai_addrlen)) /* modified to use fd */
-#else /* WITH_IPV6 */
-    if (connect((SOAP_SOCKET)fd, (struct sockaddr*)&sockaddr, sizeof(sockaddr)))
-#endif /* WITH_IPV6 */
-/* ]WR */
-    { 
+    if (connect(fd, res->ai_addr, (int)res->ai_addrlen))
+#else
+    if (connect(fd, (struct sockaddr*)&soap->peer, sizeof(soap->peer)))
+#endif
+    { err = soap_socket_errno(fd);
 #ifndef WITH_LEAN
-      if (soap->connect_timeout && (soap_socket_errno == SOAP_EINPROGRESS || soap_socket_errno == SOAP_EWOULDBLOCK))
-      { struct timeval timeout;
-#if defined(SOCKLEN_T)
-        SOCKLEN_T n = sizeof(struct sockaddr_in);
-#elif defined(__socklen_t_defined) || defined(_SOCKLEN_T) || defined(CYGWIN)
-        socklen_t n = sizeof(struct sockaddr_in);
-#elif defined(WIN32) || defined(__APPLE__) || defined(HP_UX) || defined(SUN_OS) || defined(OPENSERVER) || defined(TRU64) || defined(VXWORKS)
-        int n = sizeof(struct sockaddr_in);
-#else
-        size_t n = sizeof(struct sockaddr_in);
-#endif
-        fd_set fds;
-        if (soap->connect_timeout > 0)
-        { timeout.tv_sec = soap->connect_timeout;
-          timeout.tv_usec = 0;
+      if (err == SOAP_EADDRINUSE)
+      { soap->fclosesocket(soap, fd);
+        if (retry-- > 0)
+          goto again;
+      }
+      else if (soap->connect_timeout && (err == SOAP_EINPROGRESS || err == SOAP_EAGAIN || err == SOAP_EWOULDBLOCK))
+      {
+        SOAP_SOCKLEN_T k;
+#ifndef WIN32
+        if ((int)soap->socket >= (int)FD_SETSIZE)
+        { soap->error = SOAP_FD_EXCEEDED;
+#ifdef WITH_IPV6
+          freeaddrinfo(ressave);
+#endif
+          return SOAP_INVALID_SOCKET;   /* Hint: MUST increase FD_SETSIZE */
         }
-        else
-        { timeout.tv_sec = -soap->connect_timeout/1000000;
-          timeout.tv_usec = -soap->connect_timeout%1000000;
-        }
-        FD_ZERO(&fds);
-        FD_SET((SOAP_SOCKET)fd, &fds);
+#endif
         for (;;)
-        { int r = select((SOAP_SOCKET)(fd + 1), NULL, &fds, NULL, &timeout);
-          if (r > 0)
-            break;
-          if (!r)
-          { soap->errnum = 0;
-            DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Connect timeout\n"));
-            soap_set_sender_error(soap, "Timeout", "TCP connect failed in tcp_connect()", SOAP_TCP_ERROR);
-            soap->fclosesocket(soap, (SOAP_SOCKET)fd);
-            return -1;
-          }
-          if (soap_socket_errno != SOAP_EINTR)
-          { soap->errnum = soap_socket_errno;
-            DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not connect to host\n"));
-            soap_set_sender_error(soap, tcp_error(soap), "TCP connect failed in tcp_connect()", SOAP_TCP_ERROR);
-            soap->fclosesocket(soap, (SOAP_SOCKET)fd);
-            return -1;
-          }
-        }
-        n = sizeof(soap->errnum);
-        if (!getsockopt((SOAP_SOCKET)fd, SOL_SOCKET, SO_ERROR, (char*)&soap->errnum, &n) && !soap->errnum)
-          break;
-        DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not connect to host\n"));
-        soap_set_sender_error(soap, tcp_error(soap), "TCP connect failed in tcp_connect()", SOAP_TCP_ERROR);
-        soap->fclosesocket(soap, (SOAP_SOCKET)fd);
-        return -1;
-      }
-      else
-#endif
-      if (soap_socket_errno != SOAP_EINTR)
-      { soap->errnum = soap_socket_errno;
-        DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not connect to host\n"));
-        soap_set_sender_error(soap, tcp_error(soap), "TCP connect failed in tcp_connect()", SOAP_TCP_ERROR);
-        soap->fclosesocket(soap, (SOAP_SOCKET)fd);
-        return -1;
-      }
-    }  
-    else
-      break;
-  }
-#ifndef WITH_LEAN
-  if (soap->connect_timeout)
-#if defined(WIN32)
-  { u_long blocking = 0;
-    ioctlsocket((SOAP_SOCKET)fd, FIONBIO, &blocking);
-  }
-/* WR[ */
-#elif defined(VXWORKS)
-  { vx_nonblocking = FALSE;
-    ioctl((SOAP_SOCKET)fd, FIONBIO, (int)(&vx_nonblocking)); /* modified to use fd */
-  }
-/* ]WR */
-#else
-    fcntl((SOAP_SOCKET)fd, F_SETFL, fcntl((SOAP_SOCKET)fd, F_GETFL)&~O_NONBLOCK);
-#endif
-#endif
-  soap->socket = fd;
-#ifdef WITH_OPENSSL
-  soap->imode &= ~SOAP_ENC_SSL;
-  soap->omode &= ~SOAP_ENC_SSL;
-  if (!strncmp(endpoint, "https:", 6))
-  { int r;
-    if (soap->proxy_host)
-    { unsigned int k = soap->omode; /* make sure we only parse HTTP */
-      size_t n = soap->count; /* save the content length */
-      soap->omode &= ~0xFF; /* mask IO and ENC */
-      soap->omode |= SOAP_IO_BUFFER;
-      soap_begin_send(soap);
-      DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Connecting to proxy server\n"));
-      sprintf(soap->tmpbuf, "CONNECT %s:%d HTTP/%s", host, port, soap->http_version);
-      if ((soap->error = soap->fposthdr(soap, soap->tmpbuf, NULL)))
-        return -1;
-#ifndef WITH_LEAN
-      if (soap->proxy_userid && soap->proxy_passwd && strlen(soap->proxy_userid) + strlen(soap->proxy_passwd) < 761)
-      { sprintf(soap->tmpbuf + 262, "%s:%s", soap->proxy_userid, soap->proxy_passwd);
-        strcpy(soap->tmpbuf, "Basic ");
-        soap_s2base64(soap, (const unsigned char*)(soap->tmpbuf + 262), soap->tmpbuf + 6, strlen(soap->tmpbuf + 262));
-        if ((soap->error = soap->fposthdr(soap, "Proxy-Authorization", soap->tmpbuf)))
-          return soap->error;
-      }
-#endif
-      if ((soap->error = soap->fposthdr(soap, NULL, NULL))
-       || soap_flush(soap))
-        return -1;
-      soap->omode = k;
-      k = soap->imode;
-      soap->imode &= ~0xFF; /* mask IO and ENC */
-      if (soap_begin_recv(soap))
-        return -1;
-      soap->imode = k;
-      soap->count = n;
-      soap_begin_send(soap);
-    }
-    if (!soap->ctx && (soap->error = soap->fsslauth(soap)))
-    { soap_set_sender_error(soap, "SSL error", "SSL authentication failed in tcp_connect(): check password, key file, and ca file.", SOAP_SSL_ERROR);
-      return -1;
-    }
-    soap->ssl = SSL_new(soap->ctx);
-    if (!soap->ssl)
-    { soap->error = SOAP_SSL_ERROR;
-      return -1;
-    }
-    if (soap->session)
-    { if (!strcmp(soap->session_host, host) && soap->session_port == port)
-        SSL_set_session(soap->ssl, soap->session);
-      SSL_SESSION_free(soap->session);
-      soap->session = NULL;
-    }
-    soap->imode |= SOAP_ENC_SSL;
-    soap->omode |= SOAP_ENC_SSL;
-    soap->bio = BIO_new_socket((SOAP_SOCKET)fd, BIO_NOCLOSE);
-    SSL_set_bio(soap->ssl, soap->bio, soap->bio);
-#ifndef WITH_LEAN
-    if (soap->connect_timeout)
-#ifdef WIN32
-    { u_long nonblocking = 1;
-      ioctlsocket((SOAP_SOCKET)fd, FIONBIO, &nonblocking);
-    }
-#else
-      fcntl((SOAP_SOCKET)fd, F_SETFL, fcntl((SOAP_SOCKET)fd, F_GETFL)|O_NONBLOCK);
-#endif
-#endif
-    for (;;)
-    { if ((r = SSL_connect(soap->ssl)) <= 0)
-      { int err = SSL_get_error(soap->ssl, r);
-        if (err != SSL_ERROR_NONE && err != SSL_ERROR_WANT_READ && err != SSL_ERROR_WANT_WRITE)
-        { soap_set_sender_error(soap, ssl_error(soap, r), "SSL connect failed in tcp_connect()", SOAP_SSL_ERROR);
-          return -1;
-        }
-        if (soap->connect_timeout)
         { struct timeval timeout;
           fd_set fds;
+          register int r;
           if (soap->connect_timeout > 0)
           { timeout.tv_sec = soap->connect_timeout;
@@ -3222 +3916 @@
           }
           FD_ZERO(&fds);
-          FD_SET((SOAP_SOCKET)(soap->socket), &fds);
+          FD_SET(fd, &fds);
+          r = select((int)fd + 1, NULL, &fds, NULL, &timeout);
+          if (r > 0)
+            break;
+          if (!r)
+          { soap->errnum = 0;
+            DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Connect timeout\n"));
+            soap_set_sender_error(soap, "Timeout", "connect failed in tcp_connect()", SOAP_TCP_ERROR);
+            soap->fclosesocket(soap, fd);
+#ifdef WITH_IPV6
+            freeaddrinfo(ressave);
+#endif
+            return SOAP_INVALID_SOCKET;
+          }
+          r = soap_socket_errno(fd);
+          if (r != SOAP_EINTR)
+          { soap->errnum = r;
+            DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not connect to host\n"));
+            soap_set_sender_error(soap, tcp_error(soap), "connect failed in tcp_connect()", SOAP_TCP_ERROR);
+            soap->fclosesocket(soap, fd);
+#ifdef WITH_IPV6
+            freeaddrinfo(ressave);
+#endif
+            return SOAP_INVALID_SOCKET;
+          }
+        }
+        k = (SOAP_SOCKLEN_T)sizeof(soap->errnum);
+        if (!getsockopt(fd, SOL_SOCKET, SO_ERROR, (char*)&soap->errnum, &k) && !soap->errnum)   /* portability note: see SOAP_SOCKLEN_T definition in stdsoap2.h */
+          break;
+        DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not connect to host\n"));
+        if (!soap->errnum)
+          soap->errnum = soap_socket_errno(fd);
+        soap_set_sender_error(soap, tcp_error(soap), "connect failed in tcp_connect()", SOAP_TCP_ERROR);
+        soap->fclosesocket(soap, fd);
+#ifdef WITH_IPV6
+        freeaddrinfo(ressave);
+#endif
+        return SOAP_INVALID_SOCKET;
+      }
+#endif
+#ifdef WITH_IPV6
+      if (res->ai_next)
+      { res = res->ai_next;
+        soap->fclosesocket(soap, fd);
+        goto again;
+      }
+#endif
+      if (err && err != SOAP_EINTR)
+      { soap->errnum = err;
+        DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not connect to host\n"));
+        soap_set_sender_error(soap, tcp_error(soap), "connect failed in tcp_connect()", SOAP_TCP_ERROR);
+        soap->fclosesocket(soap, fd);
+#ifdef WITH_IPV6
+        freeaddrinfo(ressave);
+#endif
+        return SOAP_INVALID_SOCKET;
+      }
+    }  
+    else
+      break;
+  }
+#ifdef WITH_IPV6
+  soap->peerlen = 0; /* IPv6: already connected so use send() */
+  freeaddrinfo(ressave);
+#endif
+#ifndef WITH_LEAN
+  if (soap->recv_timeout || soap->send_timeout)
+    SOAP_SOCKNONBLOCK(fd)
+  else
+    SOAP_SOCKBLOCK(fd)
+#endif
+  soap->socket = fd;
+  soap->imode &= ~SOAP_ENC_SSL;
+  soap->omode &= ~SOAP_ENC_SSL;
+  if (!soap_tag_cmp(endpoint, "https:*"))
+  {
+#ifdef WITH_OPENSSL
+    BIO *bio;
+    int r;
+    if (soap->proxy_host)
+    { soap_mode m = soap->omode; /* make sure we only parse HTTP */
+      size_t n = soap->count; /* save the content length */
+      char *userid, *passwd;
+      soap->omode &= ~SOAP_ENC; /* mask IO and ENC */
+      soap->omode |= SOAP_IO_BUFFER;
+      DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Connecting to %s proxy server\n", soap->proxy_http_version));
+      sprintf(soap->tmpbuf, "CONNECT %s:%d HTTP/%s", host, port, soap->proxy_http_version);
+      if (soap_begin_send(soap)
+       || (soap->error = soap->fposthdr(soap, soap->tmpbuf, NULL)))
+      { soap->fclosesocket(soap, fd);
+        return SOAP_INVALID_SOCKET;
+      }
+#ifndef WITH_LEAN
+      if (soap->proxy_userid && soap->proxy_passwd && strlen(soap->proxy_userid) + strlen(soap->proxy_passwd) < 761)
+      { sprintf(soap->tmpbuf + 262, "%s:%s", soap->proxy_userid, soap->proxy_passwd);
+        strcpy(soap->tmpbuf, "Basic ");
+        soap_s2base64(soap, (const unsigned char*)(soap->tmpbuf + 262), soap->tmpbuf + 6, (int)strlen(soap->tmpbuf + 262));
+        if ((soap->error = soap->fposthdr(soap, "Proxy-Authorization", soap->tmpbuf)))
+        { soap->fclosesocket(soap, fd);
+          return soap->error;
+        }
+      }
+#endif
+      if ((soap->error = soap->fposthdr(soap, NULL, NULL))
+       || soap_flush(soap))
+      { soap->fclosesocket(soap, fd);
+        return SOAP_INVALID_SOCKET;
+      }
+      soap->omode = m;
+      m = soap->imode;
+      soap->imode &= ~SOAP_ENC; /* mask IO and ENC */
+      userid = soap->userid; /* preserve */
+      passwd = soap->passwd; /* preserve */
+      if ((soap->error = soap->fparse(soap)))
+      { soap->fclosesocket(soap, fd);
+        return SOAP_INVALID_SOCKET;
+      }
+      soap->userid = userid; /* restore */
+      soap->passwd = passwd; /* restore */
+      soap->imode = m; /* restore */
+      soap->count = n; /* restore */
+      if (soap_begin_send(soap))
+      { soap->fclosesocket(soap, fd);
+        return SOAP_INVALID_SOCKET;
+      }
+      if (endpoint)
+        strncpy(soap->endpoint, endpoint, sizeof(soap->endpoint)-1); /* restore */
+    }
+    if (!soap->ctx && (soap->error = soap->fsslauth(soap)))
+    { soap_set_sender_error(soap, "SSL error", "SSL authentication failed in tcp_connect(): check password, key file, and ca file.", SOAP_SSL_ERROR);
+      soap->fclosesocket(soap, fd);
+      return SOAP_INVALID_SOCKET;
+    }
+    if (!soap->ssl)
+    { soap->ssl = SSL_new(soap->ctx);
+      if (!soap->ssl)
+      { soap->fclosesocket(soap, fd);
+        soap->error = SOAP_SSL_ERROR;
+        return SOAP_INVALID_SOCKET;
+      }
+    }
+    else
+      SSL_clear(soap->ssl);
+    if (soap->session)
+    { if (!strcmp(soap->session_host, host) && soap->session_port == port)
+        SSL_set_session(soap->ssl, soap->session);
+      SSL_SESSION_free(soap->session);
+      soap->session = NULL;
+    }
+    soap->imode |= SOAP_ENC_SSL;
+    soap->omode |= SOAP_ENC_SSL;
+    bio = BIO_new_socket((int)fd, BIO_NOCLOSE);
+    SSL_set_bio(soap->ssl, bio, bio);
+#ifndef WITH_LEAN
+    /* Connect timeout: set SSL sockets to non-blocking */
+    if (soap->connect_timeout)
+      SOAP_SOCKNONBLOCK(fd)
+    else
+      SOAP_SOCKBLOCK(fd)
+    /* Try connecting until success or timeout */
+    do
+    { if ((r = SSL_connect(soap->ssl)) <= 0)
+      { int err;
+        if ((err = SSL_get_error(soap->ssl, r)) == SSL_ERROR_NONE)
+          break;
+        if (err != SSL_ERROR_WANT_READ && err != SSL_ERROR_WANT_WRITE)
+        { soap_set_sender_error(soap, soap_ssl_error(soap, r), "SSL connect failed in tcp_connect()", SOAP_SSL_ERROR);
+          soap->fclosesocket(soap, fd);
+          return SOAP_INVALID_SOCKET;
+        }
+        if (soap->connect_timeout)
+        {
+#ifndef WIN32
+          if ((int)soap->socket >= (int)FD_SETSIZE)
+          { soap->error = SOAP_FD_EXCEEDED;
+            return SOAP_INVALID_SOCKET; /* Hint: MUST increase FD_SETSIZE */
+          }
+#endif
           for (;;)
-          { int r = select((SOAP_SOCKET)(soap->socket + 1), &fds, NULL, &fds, &timeout);
-            if (r > 0)
+          { struct timeval timeout;
+            fd_set fds;
+            register int r;
+            if (soap->connect_timeout > 0)
+            { timeout.tv_sec = soap->connect_timeout;
+              timeout.tv_usec = 0;
+            }
+            else
+            { timeout.tv_sec = -soap->connect_timeout/1000000;
+              timeout.tv_usec = -soap->connect_timeout%1000000;
+            }
+            FD_ZERO(&fds);
+            FD_SET(fd, &fds);
+            if (err == SSL_ERROR_WANT_READ)
+              r = select((int)fd + 1, &fds, NULL, NULL, &timeout);
+            else
+              r = select((int)fd + 1, NULL, &fds, NULL, &timeout);
+            if (r >= 1)
+            { r = 1;
               break;
-            if (!r)
+            }
+            else
             { soap->errnum = 0;
               DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Connect timeout\n"));
-              soap_set_sender_error(soap, "Timeout", "TCP connect failed in tcp_connect()", SOAP_TCP_ERROR);
-              return -1;
+              soap_set_sender_error(soap, "Timeout", "connect failed in tcp_connect()", SOAP_TCP_ERROR);
+              soap->fclosesocket(soap, fd);
+              return SOAP_INVALID_SOCKET;
             }
           }
-          continue;
+          continue;
         }
       }
       break;
-    }
-#ifndef WITH_LEAN
-    if (soap->connect_timeout)
-#ifdef WIN32
-    { u_long blocking = 0;
-      ioctlsocket((SOAP_SOCKET)fd, FIONBIO, &blocking);
-    }
-#else
-      fcntl((SOAP_SOCKET)fd, F_SETFL, fcntl((SOAP_SOCKET)fd, F_GETFL)&~O_NONBLOCK);
-#endif
-#endif
-    if (soap->require_server_auth)
-    { X509 *peer;
-      int err;
+    } while (r == 1 && !SSL_is_init_finished(soap->ssl));
+    /* Set SSL sockets to nonblocking */
+    SOAP_SOCKNONBLOCK(fd)
+#endif
+    /* Check server credentials when required */
+    if ((soap->ssl_flags & SOAP_SSL_REQUIRE_SERVER_AUTHENTICATION))
+    { int err;
       if ((err = SSL_get_verify_result(soap->ssl)) != X509_V_OK)
       { 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);
-        return -1;
-      }
-      peer = SSL_get_peer_certificate(soap->ssl);
-      if (!peer)
-      { soap_set_sender_error(soap, "SSL error", "No SSL certificate was presented by the peer in tcp_connect()", SOAP_SSL_ERROR);
-        return -1;
-      }
-      X509_NAME_get_text_by_NID(X509_get_subject_name(peer), NID_commonName, soap->msgbuf, sizeof(soap->msgbuf));
-      X509_free(peer);
-      if (soap_tag_cmp(soap->msgbuf, host))
-      { soap_set_sender_error(soap, "SSL error", "SSL certificate host name mismatch in tcp_connect()", SOAP_SSL_ERROR);
-        return -1;
-      }
-    }
-  }
-#endif
+        soap->fclosesocket(soap, fd);
+        return SOAP_INVALID_SOCKET;
+      }
+      if (!(soap->ssl_flags & SOAP_SSL_SKIP_HOST_CHECK))
+      { X509_NAME *subj;
+        int ext_count;
+        int ok = 0;
+        X509 *peer;
+        peer = SSL_get_peer_certificate(soap->ssl);
+        if (!peer)
+        { soap_set_sender_error(soap, "SSL error", "No SSL certificate was presented by the peer in tcp_connect()", SOAP_SSL_ERROR);
+          soap->fclosesocket(soap, fd);
+          return SOAP_INVALID_SOCKET;
+        }
+        ext_count = X509_get_ext_count(peer);
+        if (ext_count > 0)
+        { int i;
+          for (i = 0; i < ext_count; i++)
+          { X509_EXTENSION *ext = X509_get_ext(peer, i);
+            const char *ext_str = OBJ_nid2sn(OBJ_obj2nid(X509_EXTENSION_get_object(ext)));
+            if (ext_str && !strcmp(ext_str, "subjectAltName"))
+            { X509V3_EXT_METHOD *meth = X509V3_EXT_get(ext);
+              void *ext_data;
+#if (OPENSSL_VERSION_NUMBER >= 0x0090800fL)
+              const unsigned char *data;
+#else
+              unsigned char *data;
+#endif
+              STACK_OF(CONF_VALUE) *val;
+              int j;
+              if (!meth)
+                break;
+              data = ext->value->data;
+#if (OPENSSL_VERSION_NUMBER > 0x00907000L)
+              if (meth->it) 
+                ext_data = ASN1_item_d2i(NULL, &data, ext->value->length, ASN1_ITEM_ptr(meth->it));
+              else
+              { /* OpenSSL not perfectly portable at this point (?):
+                   Some compilers appear to prefer
+                   meth->d2i(NULL, (const unsigned char**)&data, ...
+                   or
+                   meth->d2i(NULL, &data, ext->value->length);
+                */
+                ext_data = meth->d2i(NULL, &data, ext->value->length);
+              }
+#else
+              ext_data = meth->d2i(NULL, &data, ext->value->length);
+#endif
+              val = meth->i2v(meth, ext_data, NULL);
+              for (j = 0; j < sk_CONF_VALUE_num(val); j++)
+              { CONF_VALUE *nval = sk_CONF_VALUE_value(val, j);
+                if (nval && !strcmp(nval->name, "DNS") && !strcmp(nval->value, host))
+                { ok = 1;
+                  break;
+                }
+              }
+            }
+            if (ok)
+              break;
+          }
+        }
+        if (!ok && (subj = X509_get_subject_name(peer)))
+        { int i = -1;
+          do
+          { ASN1_STRING *name;
+            i = X509_NAME_get_index_by_NID(subj, NID_commonName, i);
+            if (i == -1)
+              break;
+            name = X509_NAME_ENTRY_get_data(X509_NAME_get_entry(subj, i));
+            if (name)
+            { if (!soap_tag_cmp(host, (const char*)name))
+                ok = 1;
+              else
+              { unsigned char *tmp = NULL;
+                ASN1_STRING_to_UTF8(&tmp, name);
+                if (tmp)
+                { if (!soap_tag_cmp(host, (const char*)tmp))
+                    ok = 1;
+                  OPENSSL_free(tmp);
+                }
+              }
+            }
+          } while (!ok);
+        }
+        X509_free(peer);
+        if (!ok)
+        { soap_set_sender_error(soap, "SSL error", "SSL certificate host name mismatch in tcp_connect()", SOAP_SSL_ERROR);
+          soap->fclosesocket(soap, fd);
+          return SOAP_INVALID_SOCKET;
+        }
+      }
+    }
+#else
+    soap->fclosesocket(soap, fd);
+    soap->error = SOAP_SSL_ERROR;
+    return SOAP_INVALID_SOCKET;
+#endif
+  }
   return fd;
 }
@@ -3276 +4241 @@
 
 /******************************************************************************/
-#ifndef MAC_CARBON
-#ifndef PALM_1
-SOAP_FMAC1
-int
+#ifndef WITH_NOIO
+#ifndef PALM_1
+SOAP_FMAC1
+SOAP_SOCKET
 SOAP_FMAC2
 soap_bind(struct soap *soap, const char *host, int port, int backlog)
-{ struct sockaddr_in sockaddr;
-/* WR[ */
+{
 #ifdef WITH_IPV6
-  struct addrinfo *addrinfo;
+  struct addrinfo *addrinfo = NULL;
   struct addrinfo hints;
-  struct addrinfo resaddr;
-  struct sockaddr_storage addrstorage;
+  struct addrinfo res;
   int err;
-#endif /* WITH_IPV6 */
-/* ]WR */
+#endif
 #ifndef WITH_LEAN
   int len = SOAP_BUFLEN;
@@ -3297 +4259 @@
 #endif
   if (soap_valid_socket(soap->master))
-  { soap->fclosesocket(soap, (SOAP_SOCKET)soap->master);
+  { soap->fclosesocket(soap, soap->master);
     soap->master = SOAP_INVALID_SOCKET;
   }
@@ -3304 +4266 @@
   if (tcp_init(soap))
   { soap_set_receiver_error(soap, tcp_error(soap), "TCP init failed in soap_bind()", SOAP_TCP_ERROR);
-    return -1;
-  }
-/* WR[ */
+    return SOAP_INVALID_SOCKET;
+  }
 #ifdef WITH_IPV6
   memset((void*)&hints, 0, sizeof(hints));
   hints.ai_family = PF_UNSPEC;
-  hints.ai_socktype = SOCK_STREAM;
+#ifndef WITH_LEAN
+  if ((soap->omode & SOAP_IO_UDP))
+    hints.ai_socktype = SOCK_DGRAM;
+  else
+#endif
+    hints.ai_socktype = SOCK_STREAM;
   hints.ai_flags = AI_PASSIVE;
   soap->errmode = 2;
-  if (host)
-    err = getaddrinfo(host, soap_int2s(soap, port), &hints, &addrinfo);
+  err = getaddrinfo(host, soap_int2s(soap, port), &hints, &addrinfo);
+  if (addrinfo)
+  { res = *addrinfo;
+    memcpy(&soap->peer, addrinfo->ai_addr, addrinfo->ai_addrlen);
+    soap->peerlen = addrinfo->ai_addrlen;
+    res.ai_addr = (struct sockaddr*)&soap->peer;
+    res.ai_addrlen = soap->peerlen;
+    freeaddrinfo(addrinfo);
+  }
+  if (err || !addrinfo)
+  { soap_set_receiver_error(soap, SOAP_GAI_STRERROR(err), "getaddrinfo failed in soap_bind()", SOAP_TCP_ERROR);
+    return SOAP_INVALID_SOCKET;
+  }
+  soap->master = (int)socket(res.ai_family, res.ai_socktype, res.ai_protocol);
+#else
+#ifndef WITH_LEAN
+  if ((soap->omode & SOAP_IO_UDP))
+    soap->master = (int)socket(AF_INET, SOCK_DGRAM, 0);
   else
-    err = getaddrinfo(NULL, soap_int2s(soap, port), &hints, &addrinfo);
-  if (NULL != addrinfo)
-  {
-    resaddr = *addrinfo;
-    addrstorage = *((struct sockaddr_storage *) addrinfo->ai_addr);
-    resaddr.ai_addr = (struct sockaddr *) &addrstorage;
-    freeaddrinfo(addrinfo);
-  }
-  if (err)
-  { soap_set_receiver_error(soap, gai_strerror(err), "TCP getaddrinfo failed in soap_bind()", SOAP_TCP_ERROR);
-    return -1;
-  }
+#endif
+    soap->master = (int)socket(AF_INET, SOCK_STREAM, 0);
+#endif
   soap->errmode = 0;
-  if ((soap->master = socket(resaddr.ai_family, resaddr.ai_socktype, resaddr.ai_protocol)) < 0)
-  { soap->errnum = soap_socket_errno;
-    soap_set_receiver_error(soap, tcp_error(soap), "TCP socket failed in soap_bind()", SOAP_TCP_ERROR);
-    return -1;
-  }
-#else /* WITH_IPV6 */
-/* ]WR */
-  soap->errmode = 0;
-  if ((soap->master = (int)socket(AF_INET, SOCK_STREAM, 0)) < 0)
-  { soap->errnum = soap_socket_errno;
-    soap_set_receiver_error(soap, tcp_error(soap), "TCP socket failed in soap_bind()", SOAP_TCP_ERROR);
-    return -1;
-  }
-/* WR[ */
-#endif /* WITH_IPV6 */
-/* ]WR */
+  if (!soap_valid_socket(soap->master))
+  { soap->errnum = soap_socket_errno(soap->master);
+    soap_set_receiver_error(soap, tcp_error(soap), "socket failed in soap_bind()", SOAP_TCP_ERROR);
+    return SOAP_INVALID_SOCKET;
+  }
+#ifndef WITH_LEAN
+  if ((soap->omode & SOAP_IO_UDP))
+    soap->socket = soap->master;
+#endif
 #ifdef SOCKET_CLOSE_ON_EXEC
 #ifdef WIN32
@@ -3351 +4317 @@
 #endif
 #else
-  fcntl (soap->master, F_SETFD, 1);
+  fcntl(soap->master, F_SETFD, 1);
 #endif
 #endif
 #ifndef WITH_LEAN
-  if (soap->bind_flags && setsockopt((SOAP_SOCKET)soap->master, SOL_SOCKET, soap->bind_flags, (char*)&set, sizeof(int)))
-  { soap->errnum = soap_socket_errno;
-    soap_set_receiver_error(soap, tcp_error(soap), "TCP setsockopt failed in soap_bind()", SOAP_TCP_ERROR);
-    return -1;
-  }
-  if (soap->keep_alive && setsockopt((SOAP_SOCKET)soap->master, SOL_SOCKET, SO_KEEPALIVE, (char*)&set, sizeof(int)))
-  { soap->errnum = soap_socket_errno;
-    soap_set_receiver_error(soap, tcp_error(soap), "TCP setsockopt SO_KEEPALIVE failed in soap_bind()", SOAP_TCP_ERROR);
-    return -1;
-  }
-  if (setsockopt((SOAP_SOCKET)soap->master, SOL_SOCKET, SO_SNDBUF, (char*)&len, sizeof(int)))
-  { soap->errnum = soap_socket_errno;
-    soap_set_receiver_error(soap, tcp_error(soap), "TCP setsockopt SO_SNDBUF failed in soap_bind()", SOAP_TCP_ERROR);
-    return -1;
-  }
-  if (setsockopt((SOAP_SOCKET)soap->master, SOL_SOCKET, SO_RCVBUF, (char*)&len, sizeof(int)))
-  { soap->errnum = soap_socket_errno;
-    soap_set_receiver_error(soap, tcp_error(soap), "TCP setsockopt SO_RCVBUF failed in soap_bind()", SOAP_TCP_ERROR);
-    return -1;
+  if (soap->bind_flags && setsockopt(soap->master, SOL_SOCKET, soap->bind_flags, (char*)&set, sizeof(int)))
+  { soap->errnum = soap_socket_errno(soap->master);
+    soap_set_receiver_error(soap, tcp_error(soap), "setsockopt failed in soap_bind()", SOAP_TCP_ERROR);
+    return SOAP_INVALID_SOCKET;
+  }
+  if (((soap->imode | soap->omode) & SOAP_IO_KEEPALIVE) && setsockopt(soap->master, SOL_SOCKET, SO_KEEPALIVE, (char*)&set, sizeof(int)))
+  { soap->errnum = soap_socket_errno(soap->master);
+    soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_KEEPALIVE failed in soap_bind()", SOAP_TCP_ERROR);
+    return SOAP_INVALID_SOCKET;
+  }
+  if (setsockopt(soap->master, SOL_SOCKET, SO_SNDBUF, (char*)&len, sizeof(int)))
+  { soap->errnum = soap_socket_errno(soap->master);
+    soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_SNDBUF failed in soap_bind()", SOAP_TCP_ERROR);
+    return SOAP_INVALID_SOCKET;
+  }
+  if (setsockopt(soap->master, SOL_SOCKET, SO_RCVBUF, (char*)&len, sizeof(int)))
+  { soap->errnum = soap_socket_errno(soap->master);
+    soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_RCVBUF failed in soap_bind()", SOAP_TCP_ERROR);
+    return SOAP_INVALID_SOCKET;
   }
 #ifdef TCP_NODELAY
-  if (setsockopt((SOAP_SOCKET)soap->master, IPPROTO_TCP, TCP_NODELAY, (char*)&set, sizeof(int)))
-  { soap->errnum = soap_socket_errno;
-    soap_set_receiver_error(soap, tcp_error(soap), "TCP setsockopt TCP_NODELAY failed in soap_bind()", SOAP_TCP_ERROR);
-    return -1;
-  }
-#endif
-#endif
-/* WR[ */
+  if (!(soap->omode & SOAP_IO_UDP) && setsockopt(soap->master, IPPROTO_TCP, TCP_NODELAY, (char*)&set, sizeof(int)))
+  { soap->errnum = soap_socket_errno(soap->master);
+    soap_set_receiver_error(soap, tcp_error(soap), "setsockopt TCP_NODELAY failed in soap_bind()", SOAP_TCP_ERROR);
+    return SOAP_INVALID_SOCKET;
+  }
+#endif
+#endif
 #ifdef WITH_IPV6
   soap->errmode = 0;
-  if (bind(soap->master, resaddr.ai_addr, resaddr.ai_addrlen) || listen(soap->master, backlog))
-  { 
-    soap->errnum = soap_socket_errno;
+  if (bind(soap->master, res.ai_addr, (int)res.ai_addrlen))
+  { soap->errnum = soap_socket_errno(soap->master);
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not bind to host\n"));
     soap_closesock(soap);
-    soap_set_receiver_error(soap, tcp_error(soap), "TCP bind failed in soap_bind()", SOAP_TCP_ERROR);
-    return -1;
+    soap_set_receiver_error(soap, tcp_error(soap), "bind failed in soap_bind()", SOAP_TCP_ERROR);
+    return SOAP_INVALID_SOCKET;
   }  
-#else /* WITH_IPV6 */
-/* ]WR */
-  memset((void*)&sockaddr, 0, sizeof(sockaddr));
-  sockaddr.sin_family = AF_INET;
+#else
+  soap->peerlen = sizeof(soap->peer);
+  memset((void*)&soap->peer, 0, sizeof(soap->peer));
+  soap->peer.sin_family = AF_INET;
   soap->errmode = 2;
   if (host)
-  { if (soap->fresolve(soap, host, &sockaddr.sin_addr))
-    { soap_set_receiver_error(soap, tcp_error(soap), "TCP get host by name failed in soap_bind()", SOAP_TCP_ERROR);
-      return -1;
+  { if (soap->fresolve(soap, host, &soap->peer.sin_addr))
+    { soap_set_receiver_error(soap, tcp_error(soap), "get host by name failed in soap_bind()", SOAP_TCP_ERROR);
+      return SOAP_INVALID_SOCKET;
     }
   }
   else
-    sockaddr.sin_addr.s_addr = htonl(INADDR_ANY);
-  sockaddr.sin_port = htons((short)port);
+    soap->peer.sin_addr.s_addr = htonl(INADDR_ANY);
+  soap->peer.sin_port = htons((short)port);
   soap->errmode = 0;
-  if (bind((SOAP_SOCKET)soap->master, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) || listen((SOAP_SOCKET)soap->master, backlog))
-  { soap->errnum = soap_socket_errno;
+  if (bind(soap->master, (struct sockaddr*)&soap->peer, (int)soap->peerlen))
+  { soap->errnum = soap_socket_errno(soap->master);
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not bind to host\n"));
     soap_closesock(soap);
-    soap_set_receiver_error(soap, tcp_error(soap), "TCP bind failed in soap_bind()", SOAP_TCP_ERROR);
-    return -1;
+    soap_set_receiver_error(soap, tcp_error(soap), "bind failed in soap_bind()", SOAP_TCP_ERROR);
+    return SOAP_INVALID_SOCKET;
+  }
+#endif
+  if (!(soap->omode & SOAP_IO_UDP) && listen(soap->master, backlog))
+  { soap->errnum = soap_socket_errno(soap->master);
+    DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not bind to host\n"));
+    soap_closesock(soap);
+    soap_set_receiver_error(soap, tcp_error(soap), "listen failed in soap_bind()", SOAP_TCP_ERROR);
+    return SOAP_INVALID_SOCKET;
   }  
-/* WR[ */
-#endif /* WITH_IPV6 */
-/* ]WR */
-#ifdef WITH_OPENSSL
-  if (!soap->ctx && (soap->error = soap->fsslauth(soap)))
-    return -1;
-#endif
   return soap->master;
 }
@@ -3429 +4394 @@
 
 /******************************************************************************/
-#ifndef MAC_CARBON
+#ifndef WITH_NOIO
 #ifndef PALM_1
 SOAP_FMAC1
@@ -3438 +4403 @@
 #ifndef WITH_LEAN
   struct timeval timeout;
-  fd_set sfd,rfd;
-  int r;
+  fd_set rfd, sfd, xfd;
+  register int r;
+#ifndef WIN32
+  if ((int)soap->socket >= (int)FD_SETSIZE)
+    return SOAP_FD_EXCEEDED;    /* Hint: MUST increase FD_SETSIZE */
+#endif
   timeout.tv_sec = 0;
   timeout.tv_usec = 0;
   FD_ZERO(&rfd);
   FD_ZERO(&sfd);
-  if (soap->socket >= 0)
+  FD_ZERO(&xfd);
+  if (soap_valid_socket(soap->socket))
   { FD_SET(soap->socket, &rfd);
     FD_SET(soap->socket, &sfd);
-    r = select(soap->socket + 1, &rfd, &sfd, NULL, &timeout);
-  }
-  else if (soap->master >= 0)
-  { FD_SET(soap->master, &rfd);
-    r = select(soap->master + 1, &rfd, &sfd, NULL, &timeout);
+    FD_SET(soap->socket, &xfd);
+    r = select((int)soap->socket + 1, &rfd, &sfd, &xfd, &timeout);
+    if (r > 0 && FD_ISSET(soap->socket, &xfd))
+      r = -1;
+  }
+  else if (soap_valid_socket(soap->master))
+  { FD_SET(soap->master, &sfd);
+    r = select((int)soap->master + 1, NULL, &sfd, NULL, &timeout);
   }
   else
-  { FD_SET(soap->sendfd, &sfd);
-    FD_SET(soap->recvfd, &rfd);
-    r = select((soap->sendfd > soap->recvfd ? soap->sendfd : soap->recvfd) + 1, &rfd, &sfd, NULL, &timeout);
-  }
+    return SOAP_OK;
   if (r > 0)
   {
 #ifdef WITH_OPENSSL
-    if (soap->ssl)
-    { if ((soap->socket >= 0) && FD_ISSET(soap->socket, &rfd))
-      { char buf = '\0';
-        if (SSL_peek(soap->ssl, &buf, 1) <= 0)
-          return SOAP_EOF;
-      }
-    }
-#endif   
-    return SOAP_OK;
-  }
-  if (r < 0 && (soap_valid_socket(soap->master) || soap_valid_socket(soap->socket)) && soap_socket_errno != SOAP_EINTR)
-  { soap->errnum = soap_socket_errno;
-    soap_set_receiver_error(soap, tcp_error(soap), "select failed in soap_poll()", SOAP_TCP_ERROR);
-    return soap->error = SOAP_TCP_ERROR;
+    if (soap->imode & SOAP_ENC_SSL)
+    {
+      if (soap_valid_socket(soap->socket)
+       && FD_ISSET(soap->socket, &sfd)
+       && (!FD_ISSET(soap->socket, &rfd)
+        || SSL_peek(soap->ssl, soap->tmpbuf, 1) > 0))
+        return SOAP_OK;
+    }
+    else
+#endif
+      if (soap_valid_socket(soap->socket)
+       && FD_ISSET(soap->socket, &sfd)
+       && (!FD_ISSET(soap->socket, &rfd)
+        || recv(soap->socket, soap->tmpbuf, 1, MSG_PEEK) > 0))
+        return SOAP_OK;
+  }
+  else if (r < 0)
+  { soap->errnum = soap_socket_errno(soap->master);
+    if ((soap_valid_socket(soap->master) || soap_valid_socket(soap->socket)) && soap_socket_errno(soap->master) != SOAP_EINTR)
+    { soap_set_receiver_error(soap, tcp_error(soap), "select failed in soap_poll()", SOAP_TCP_ERROR);
+      return soap->error = SOAP_TCP_ERROR;
+    }
   }
   else
-    soap->errnum = soap_errno;
+    soap->errnum = 0;
+  DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Polling: other end down on socket=%d select=%d\n", soap->socket, r));
   return SOAP_EOF;
 #else
@@ -3487 +4466 @@
 
 /******************************************************************************/
-#ifndef MAC_CARBON
-#ifndef PALM_1
-static int
-tcp_accept(struct soap *soap, int s, struct sockaddr *a, int *n)
-{ int fd;
-#if defined(SOCKLEN_T)
-  fd = (int)accept((SOAP_SOCKET)s, a, (SOCKLEN_T*)n);
-#elif defined(__socklen_t_defined) || defined(_SOCKLEN_T) || defined(CYGWIN)
-  fd = (int)accept((SOAP_SOCKET)s, a, (socklen_t*)n);
-#elif defined(WIN32) || defined(__APPLE__) || defined(HP_UX) || defined(SUN_OS) || defined(OPENSERVER) || defined(TRU64) || defined(VXWORKS)
-  fd = (int)accept((SOAP_SOCKET)s, a, n);
-#else
-  fd = (int)accept((SOAP_SOCKET)s, a, (size_t*)n);
-#endif
+#ifndef WITH_NOIO
+#ifndef PALM_1
+static SOAP_SOCKET
+tcp_accept(struct soap *soap, SOAP_SOCKET s, struct sockaddr *a, int *n)
+{ SOAP_SOCKET fd;
+  fd = accept(s, a, (SOAP_SOCKLEN_T*)n);        /* portability note: see SOAP_SOCKLEN_T definition in stdsoap2.h */
 #ifdef SOCKET_CLOSE_ON_EXEC
 #ifdef WIN32
@@ -3516 +4487 @@
 
 /******************************************************************************/
-#ifndef MAC_CARBON
-#ifndef PALM_1
-SOAP_FMAC1
-int
+#ifndef WITH_NOIO
+#ifndef PALM_1
+SOAP_FMAC1
+SOAP_SOCKET
 SOAP_FMAC2
 soap_accept(struct soap *soap)
-{ 
-/* WR[ */
-#ifdef WITH_IPV6
-  struct sockaddr_storage sockaddr;
-#else /* WITH_IPV6 */
-/* ]WR */
-  struct sockaddr_in sockaddr;
-/* WR[ */
-#endif
-/* ]WR */
-  int n = (int)sizeof(sockaddr);
+{ int n = (int)sizeof(soap->peer);
 #ifndef WITH_LEAN
   int len = SOAP_BUFLEN;
@@ -3538 +4499 @@
 #endif
   soap->error = SOAP_OK;
-  memset((void*)&sockaddr, 0, sizeof(sockaddr));
+#ifndef WITH_LEAN
+  if ((soap->omode & SOAP_IO_UDP))
+    return soap->socket = soap->master;
+#endif
+  memset((void*)&soap->peer, 0, sizeof(soap->peer));
   soap->socket = SOAP_INVALID_SOCKET;
   soap->errmode = 0;
+  soap->keep_alive = 0;
   if (soap_valid_socket(soap->master))
-  { for (;;)
+  { register int err;
+    for (;;)
     { 
 #ifndef WITH_LEAN
-      if (soap->accept_timeout)
-      { struct timeval timeout;
-        fd_set fd;
-        if (soap->accept_timeout > 0)
-        { timeout.tv_sec = soap->accept_timeout;
-          timeout.tv_usec = 0;
+      if (soap->accept_timeout || soap->send_timeout || soap->recv_timeout)
+      {
+#ifndef WIN32
+        if ((int)soap->socket >= (int)FD_SETSIZE)
+        { soap->error = SOAP_FD_EXCEEDED;
+          return SOAP_INVALID_SOCKET;   /* Hint: MUST increase FD_SETSIZE */
         }
-        else
-        { timeout.tv_sec = -soap->accept_timeout/1000000;
-          timeout.tv_usec = -soap->accept_timeout%1000000;
-        }
-        FD_ZERO(&fd);
-        FD_SET((SOAP_SOCKET)soap->master, &fd);
+#endif
         for (;;)
-        { int r = select((SOAP_SOCKET)(soap->master + 1), &fd, &fd, NULL, &timeout);
+        { struct timeval timeout;
+          fd_set fd;
+          register int r;
+          if (soap->accept_timeout > 0)
+          { timeout.tv_sec = soap->accept_timeout;
+            timeout.tv_usec = 0;
+          }
+          else if (soap->accept_timeout < 0)
+          { timeout.tv_sec = -soap->accept_timeout/1000000;
+            timeout.tv_usec = -soap->accept_timeout%1000000;
+          }
+          else
+          { timeout.tv_sec = 60;
+            timeout.tv_usec = 0;
+          }
+          FD_ZERO(&fd);
+          FD_SET(soap->master, &fd);
+          r = select((int)soap->master + 1, &fd, &fd, &fd, &timeout);
           if (r > 0)
             break;
-          if (!r)
+          if (!r && soap->accept_timeout)
           { soap->errnum = 0;
-            soap_set_receiver_error(soap, "Timeout", "TCP accept failed in soap_accept()", SOAP_TCP_ERROR);
-            return -1;
+            soap_set_receiver_error(soap, "Timeout", "accept failed in soap_accept()", SOAP_TCP_ERROR);
+            return SOAP_INVALID_SOCKET;
           }
-          if (soap_socket_errno != SOAP_EINTR)
-          { soap->errnum = soap_socket_errno;
-            soap_closesock(soap);
-            soap_set_sender_error(soap, tcp_error(soap), "TCP accept failed in soap_accept()", SOAP_TCP_ERROR);
-            return -1;
-          }
+          if (r < 0)
+          { r = soap_socket_errno(soap->master);
+            if (r != SOAP_EINTR)
+            { soap->errnum = r;
+              soap_closesock(soap);
+              soap_set_sender_error(soap, tcp_error(soap), "accept failed in soap_accept()", SOAP_TCP_ERROR);
+              return SOAP_INVALID_SOCKET;
+            }
+          }
         }
-#if defined(WIN32)
-        { u_long nonblocking = 1;
-          ioctlsocket((SOAP_SOCKET)soap->master, FIONBIO, &nonblocking);
-        }
-#elif defined(VXWORKS)
-        { vx_nonblocking = TRUE;
-          ioctl((SOAP_SOCKET)soap->master, FIONBIO, (int)(&vx_nonblocking));
-        }
-#else
-        fcntl((SOAP_SOCKET)soap->master, F_SETFL, fcntl((SOAP_SOCKET)soap->master, F_GETFL)|O_NONBLOCK);
-#endif
-      }
+      }
+      if (soap->accept_timeout || soap->send_timeout || soap->recv_timeout)
+        SOAP_SOCKNONBLOCK(soap->master)
       else
-#if defined(WIN32)
-      { u_long blocking = 0;
-        ioctlsocket((SOAP_SOCKET)soap->master, FIONBIO, &blocking);
-      }
-/* WR[ */
-#elif defined(VXWORKS)
-      { vx_nonblocking = FALSE;
-        ioctl((SOAP_SOCKET)soap->master, FIONBIO, (int)(&vx_nonblocking));
-      }
-/* ]WR */
-#else
-        fcntl((SOAP_SOCKET)soap->master, F_SETFL, fcntl((SOAP_SOCKET)soap->master, F_GETFL)&~O_NONBLOCK);
-#endif
-#endif
-      if ((soap->socket = soap->faccept(soap, soap->master, (struct sockaddr*)&sockaddr, &n)) >= 0)
+        SOAP_SOCKBLOCK(soap->master)
+#endif
+      soap->socket = soap->faccept(soap, soap->master, (struct sockaddr*)&soap->peer, &n);
+      soap->peerlen = (size_t)n;
+      if (soap_valid_socket(soap->socket))
       {
-/* WR[ */
 #ifdef WITH_IPV6
 /* Use soap->host to store the numeric form of the remote host */
-        getnameinfo((struct sockaddr*)&sockaddr, n, soap->host, sizeof(soap->host), NULL, 0, NI_NUMERICHOST | NI_NUMERICSERV); 
+        getnameinfo((struct sockaddr*)&soap->peer, n, soap->host, sizeof(soap->host), NULL, 0, NI_NUMERICHOST | NI_NUMERICSERV); 
         DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Accept socket %d from %s\n", soap->socket, soap->host));
-        soap->ip = 0; /* info stored in soap->host */
-        soap->port = 0; /* info stored in soap->host */
-#else /* WITH_IPV6 */
-/* ]WR */
-        soap->ip = ntohl(sockaddr.sin_addr.s_addr);
-        soap->port = (int)ntohs(sockaddr.sin_port); /* does not return port number on some systems */
+        soap->ip = 0; /* info stored in soap->peer and soap->host */
+        soap->port = 0; /* info stored in soap->peer and soap->host */
+#else
+        soap->ip = ntohl(soap->peer.sin_addr.s_addr);
+        soap->port = (int)ntohs(soap->peer.sin_port); /* does not return port number on some systems */
         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));
-/* WR[ */
-#endif /* WITH_IPV6 */
-/* ]WR */
-        soap->keep_alive = ((soap->imode & SOAP_IO_KEEPALIVE) != 0);
+#endif
 #ifndef WITH_LEAN
-        if (soap->accept_flags & SO_LINGER)
+        if (soap->accept_flags == SO_LINGER)
         { struct linger linger;
           memset((void*)&linger, 0, sizeof(linger));
           linger.l_onoff = 1;
-          linger.l_linger = 0;
-          if (setsockopt((SOAP_SOCKET)soap->socket, SOL_SOCKET, SO_LINGER, (char*)&linger, sizeof(struct linger)))
-          { soap->errnum = soap_socket_errno;
-            soap_set_receiver_error(soap, tcp_error(soap), "TCP setsockopt SO_LINGER failed in soap_accept()", SOAP_TCP_ERROR);
-            return -1;
-          }
+          linger.l_linger = soap->linger_time;
+          if (setsockopt(soap->socket, SOL_SOCKET, SO_LINGER, (char*)&linger, sizeof(struct linger)))
+          { soap->errnum = soap_socket_errno(soap->socket);
+            soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_LINGER failed in soap_accept()", SOAP_TCP_ERROR);
+            soap_closesock(soap);
+            return SOAP_INVALID_SOCKET;
+          }
         }
-        if ((soap->accept_flags & ~SO_LINGER) && setsockopt((SOAP_SOCKET)soap->socket, SOL_SOCKET, soap->accept_flags & ~SO_LINGER, (char*)&set, sizeof(int)))
-        { soap->errnum = soap_socket_errno;
-          soap_set_receiver_error(soap, tcp_error(soap), "TCP setsockopt failed in soap_accept()", SOAP_TCP_ERROR);
-          return -1;
+        else if (soap->accept_flags && setsockopt(soap->socket, SOL_SOCKET, soap->accept_flags, (char*)&set, sizeof(int)))
+        { soap->errnum = soap_socket_errno(soap->socket);
+          soap_set_receiver_error(soap, tcp_error(soap), "setsockopt failed in soap_accept()", SOAP_TCP_ERROR);
+          soap_closesock(soap);
+          return SOAP_INVALID_SOCKET;
         }
-        if (soap->keep_alive && setsockopt((SOAP_SOCKET)soap->socket, SOL_SOCKET, SO_KEEPALIVE, (char*)&set, sizeof(int)))
-        { soap->errnum = soap_socket_errno;
-          soap_set_receiver_error(soap, tcp_error(soap), "TCP setsockopt SO_KEEPALIVE failed in soap_accept()", SOAP_TCP_ERROR);
-          return -1;
+        if (((soap->imode | soap->omode) & SOAP_IO_KEEPALIVE) && setsockopt(soap->socket, SOL_SOCKET, SO_KEEPALIVE, (char*)&set, sizeof(int)))
+        { soap->errnum = soap_socket_errno(soap->socket);
+          soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_KEEPALIVE failed in soap_accept()", SOAP_TCP_ERROR);
+          soap_closesock(soap);
+          return SOAP_INVALID_SOCKET;
         }
-        if (setsockopt((SOAP_SOCKET)soap->socket, SOL_SOCKET, SO_SNDBUF, (char*)&len, sizeof(int)))
-        { soap->errnum = soap_socket_errno;
-          soap_set_receiver_error(soap, tcp_error(soap), "TCP setsockopt SO_SNDBUF failed in soap_accept()", SOAP_TCP_ERROR);
-          return -1;
+        if (setsockopt(soap->socket, SOL_SOCKET, SO_SNDBUF, (char*)&len, sizeof(int)))
+        { soap->errnum = soap_socket_errno(soap->socket);
+          soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_SNDBUF failed in soap_accept()", SOAP_TCP_ERROR);
+          soap_closesock(soap);
+          return SOAP_INVALID_SOCKET;
         }
-        if (setsockopt((SOAP_SOCKET)soap->socket, SOL_SOCKET, SO_RCVBUF, (char*)&len, sizeof(int)))
-        { soap->errnum = soap_socket_errno;
-          soap_set_receiver_error(soap, tcp_error(soap), "TCP setsockopt SO_RCVBUF failed in soap_accept()", SOAP_TCP_ERROR);
-          return -1;
+        if (setsockopt(soap->socket, SOL_SOCKET, SO_RCVBUF, (char*)&len, sizeof(int)))
+        { soap->errnum = soap_socket_errno(soap->socket);
+          soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_RCVBUF failed in soap_accept()", SOAP_TCP_ERROR);
+          soap_closesock(soap);
+          return SOAP_INVALID_SOCKET;
         }
 #ifdef TCP_NODELAY
-        if (setsockopt((SOAP_SOCKET)soap->socket, IPPROTO_TCP, TCP_NODELAY, (char*)&set, sizeof(int)))
-        { soap->errnum = soap_socket_errno;
-          soap_set_receiver_error(soap, tcp_error(soap), "TCP setsockopt TCP_NODELAY failed in soap_accept()", SOAP_TCP_ERROR);
-          return -1;
+        if (!(soap->omode & SOAP_IO_UDP) && setsockopt(soap->socket, IPPROTO_TCP, TCP_NODELAY, (char*)&set, sizeof(int)))
+        { soap->errnum = soap_socket_errno(soap->socket);
+          soap_set_receiver_error(soap, tcp_error(soap), "setsockopt TCP_NODELAY failed in soap_accept()", SOAP_TCP_ERROR);
+          soap_closesock(soap);
+          return SOAP_INVALID_SOCKET;
         }
 #endif
 #endif
-        if (soap->accept_timeout)
-        {
-#if defined(WIN32)
-          u_long blocking = 0;
-          ioctlsocket((SOAP_SOCKET)soap->master, FIONBIO, &blocking);
-          ioctlsocket((SOAP_SOCKET)soap->socket, FIONBIO, &blocking);
-/* WR[ */
-#elif defined(VXWORKS)
-          vx_nonblocking = FALSE;
-          ioctl((SOAP_SOCKET)soap->master, FIONBIO, (int)(&vx_nonblocking));
-          ioctl((SOAP_SOCKET)soap->socket, FIONBIO, (int)(&vx_nonblocking));
-/* ]WR */
-#elif defined(PALM)
-          fcntl((SOAP_SOCKET)soap->master, F_SETFL, fcntl((SOAP_SOCKET)soap->master, F_GETFL,0)&~O_NONBLOCK);
-          fcntl((SOAP_SOCKET)soap->socket, F_SETFL, fcntl((SOAP_SOCKET)soap->socket, F_GETFL,0)&~O_NONBLOCK);
-#elif defined(SYMBIAN)
-          long blocking = 0;
-          ioctl((SOAP_SOCKET)soap->master, 0/*FIONBIO*/, &blocking);
-#else
-          fcntl((SOAP_SOCKET)soap->master, F_SETFL, fcntl((SOAP_SOCKET)soap->master, F_GETFL)&~O_NONBLOCK);
-          fcntl((SOAP_SOCKET)soap->socket, F_SETFL, fcntl((SOAP_SOCKET)soap->socket, F_GETFL)&~O_NONBLOCK);
-#endif
-        }
+        soap->keep_alive = (((soap->imode | soap->omode) & SOAP_IO_KEEPALIVE) != 0);
         return soap->socket;
       }
-      if (soap_socket_errno != SOAP_EINTR && soap_socket_errno != SOAP_EAGAIN)
-      { soap->errnum = soap_socket_errno;
-        soap_set_receiver_error(soap, tcp_error(soap), "TCP accept failed in soap_accept()", SOAP_TCP_ERROR);
-        return -1;
+      err = soap_socket_errno(soap->socket);
+      if (err != 0 && err != SOAP_EINTR && err != SOAP_EAGAIN && err != SOAP_EWOULDBLOCK)
+      { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Accept failed from %s\n", soap->host));
+        soap->errnum = err;
+        soap_set_receiver_error(soap, tcp_error(soap), "accept failed in soap_accept()", SOAP_TCP_ERROR);
+        soap_closesock(soap);
+        return SOAP_INVALID_SOCKET;
       }
     }
   }
   else
-  { soap_set_receiver_error(soap, tcp_error(soap), "TCP no master socket in soap_accept()", SOAP_TCP_ERROR);
-    return -1;
-  }
-}
-#endif
-#endif
-
-/******************************************************************************/
-#ifndef MAC_CARBON
+  { soap->errnum = 0;
+    soap_set_receiver_error(soap, tcp_error(soap), "no master socket in soap_accept()", SOAP_TCP_ERROR);
+    return SOAP_INVALID_SOCKET;
+  }
+}
+#endif
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOIO
 #ifndef PALM_1
 static int
@@ -3709 +4655 @@
   { int r, s = 0;
     if (soap->session)
-      SSL_SESSION_free(soap->session);
+    { SSL_SESSION_free(soap->session);
+      soap->session = NULL;
+    }
     if (*soap->host)
     { soap->session = SSL_get1_session(soap->ssl);
@@ -3718 +4666 @@
     }
     r = SSL_shutdown(soap->ssl);
+    if (r == 0)
+    { if (soap_valid_socket(soap->socket))
+      { struct timeval timeout;
+        fd_set fd;
+        if (soap->fshutdownsocket(soap, soap->socket, 1))
+        { /*
+          wait up to 10 seconds for close_notify to be sent by peer (if peer not
+          present, this avoids calling SSL_shutdown() which has a lengthy return
+          timeout)
+          */
+#ifndef WIN32
+          if ((int)soap->socket < (int)FD_SETSIZE)
+          {
+#endif
+            timeout.tv_sec = 10;
+            timeout.tv_usec = 0;
+            FD_ZERO(&fd);
+            FD_SET(soap->socket, &fd);
+            r = select((int)soap->socket + 1, &fd, NULL, &fd, &timeout);
+            if (r <= 0 && soap_socket_errno(soap->socket) != SOAP_EINTR)
+            { soap->errnum = 0;
+              DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Connection lost...\n"));
+              soap->fclosesocket(soap, soap->socket);
+              soap->socket = SOAP_INVALID_SOCKET;
+              ERR_remove_state(0);
+              return SOAP_OK;
+            }
+#ifndef WIN32
+          }
+#endif
+        }
+      }
+      r = SSL_shutdown(soap->ssl);
+    }
     if (r != 1)
     { s = ERR_get_error();
       if (s)
-      { if (soap_valid_socket(soap->socket))
-        { soap->fshutdownsocket(soap, (SOAP_SOCKET)soap->socket, 1);
+      { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Shutdown failed: %d\n", SSL_get_error(soap->ssl, r)));
+        if (soap_valid_socket(soap->socket) && !(soap->omode & SOAP_IO_UDP))
+        { soap->fclosesocket(soap, soap->socket);
           soap->socket = SOAP_INVALID_SOCKET;
         }
-        r = SSL_shutdown(soap->ssl);
-      }
-    }
-    DBGLOG(TEST, if (s) SOAP_MESSAGE(fdebug, "Shutdown failed: %d\n", SSL_get_error(soap->ssl, r)));
+      }
+    }
     SSL_free(soap->ssl);
     soap->ssl = NULL;
@@ -3736 +4717 @@
   }
 #endif
-  if (soap_valid_socket(soap->socket))
-  { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Closing socket %d\n", soap->socket));
-    soap->fshutdownsocket(soap, (SOAP_SOCKET)soap->socket, 2);
-    soap->fclosesocket(soap, (SOAP_SOCKET)soap->socket);
+  if (soap_valid_socket(soap->socket) && !(soap->omode & SOAP_IO_UDP))
+  { soap->fshutdownsocket(soap, soap->socket, 2);
+    soap->fclosesocket(soap, soap->socket);
     soap->socket = SOAP_INVALID_SOCKET;
   }
@@ -3748 +4728 @@
 
 /******************************************************************************/
-#ifndef MAC_CARBON
+#ifndef WITH_NOIO
 #ifndef PALM_1
 static int
 tcp_closesocket(struct soap *soap, SOAP_SOCKET fd)
-{ return closesocket(fd);
-}
-#endif
-#endif
-
-/******************************************************************************/
-#ifndef MAC_CARBON
+{ DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Close socket %d\n", (int)fd));
+  return soap_closesocket(fd);
+}
+#endif
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOIO
 #ifndef PALM_1
 static int
 tcp_shutdownsocket(struct soap *soap, SOAP_SOCKET fd, int how)
-{ return shutdown(fd, how);
+{ DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Shutdown socket %d how=%d\n", (int)fd, how));
+  return shutdown(fd, how);
 }
 #endif
@@ -3774 +4756 @@
 soap_closesock(struct soap *soap)
 { register int status = soap->error;
-#ifndef MAC_CARBON
   if (status == SOAP_EOF || status == SOAP_TCP_ERROR || status == SOAP_SSL_ERROR || !soap->keep_alive)
-  { if ((soap->error = soap->fclose(soap)))
+  { if (soap->fclose && (soap->error = soap->fclose(soap)))
       return soap->error;
-    soap->socket = SOAP_INVALID_SOCKET;
-  }
-#endif
+    soap->keep_alive = 0;
+  }
 #ifdef WITH_ZLIB
   if (soap->zlib_state == SOAP_ZLIB_DEFLATE)
-    deflateEnd(&soap->d_stream);
+    deflateEnd(soap->d_stream);
   else if (soap->zlib_state == SOAP_ZLIB_INFLATE)
-    inflateEnd(&soap->d_stream);
+    inflateEnd(soap->d_stream);
   soap->zlib_state = SOAP_ZLIB_NONE;
 #endif
@@ -3793 +4773 @@
 
 /******************************************************************************/
+#ifndef WITH_NOIDREF
 #ifndef PALM_2
 SOAP_FMAC1
@@ -3804 +4785 @@
 }
 #endif
-
-/******************************************************************************/
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOIDREF
 #ifndef PALM_1
 static void
@@ -3811 +4794 @@
 { register int i;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Initializing pointer hashtable\n"));
+  soap->pblk = NULL;
+  soap->pidx = 0;
   for (i = 0; i < (int)SOAP_PTRHASH; i++)
     soap->pht[i] = NULL;
 }
 #endif
+#endif
 
 /******************************************************************************/
@@ -3821 +4807 @@
 struct soap*
 SOAP_FMAC2
+soap_new1(soap_mode mode)
+{ return soap_new2(mode, mode);
+}
+#endif
+
+/******************************************************************************/
+#ifndef PALM_1
+SOAP_FMAC1
+struct soap*
+SOAP_FMAC2
 soap_new()
-{ struct soap *soap = (struct soap*)SOAP_MALLOC(sizeof(struct soap));
-  if (soap)
-    soap_init(soap);
-  return soap;
+{ return soap_new2(SOAP_IO_DEFAULT, SOAP_IO_DEFAULT);
 }
 #endif
@@ -3834 +4827 @@
 struct soap*
 SOAP_FMAC2
-soap_new1(int mode)
-{ return soap_new2(mode, mode);
-}
-#endif
-
-/******************************************************************************/
-#ifndef PALM_1
-SOAP_FMAC1
-struct soap*
-SOAP_FMAC2
-soap_new2(int imode, int omode)
-{ struct soap *soap = (struct soap*)SOAP_MALLOC(sizeof(struct soap));
+soap_new2(soap_mode imode, soap_mode omode)
+{ struct soap *soap = (struct soap*)malloc(sizeof(struct soap));
   if (soap)
     soap_init2(soap, imode, omode);
@@ -3854 +4837 @@
 /******************************************************************************/
 #ifndef PALM_1
+SOAP_FMAC1
+void
+SOAP_FMAC2
+soap_free(struct soap *soap)
+{ soap_done(soap);
+  free(soap);
+}
+#endif
+
+/******************************************************************************/
+#ifndef PALM_1
+SOAP_FMAC1
+void
+SOAP_FMAC2
+soap_del(struct soap *soap)
+{ free(soap);
+}
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOIDREF
+#ifndef PALM_1
 static void
 soap_free_pht(struct soap *soap)
-{ register struct soap_plist *pp, *next;
+{ register struct soap_pblk *pb, *next;
   register int i;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free pointer hashtable\n"));
+  for (pb = soap->pblk; pb; pb = next)
+  { next = pb->next;
+    SOAP_FREE(soap, pb);
+  }
+  soap->pblk = NULL;
+  soap->pidx = 0;
   for (i = 0; i < (int)SOAP_PTRHASH; i++)
-  { for (pp = soap->pht[i]; pp; pp = next)
-    { next = pp->next;
-      SOAP_FREE(pp);
-    }
     soap->pht[i] = NULL;
-  }
-}
-#endif
-
-/******************************************************************************/
+}
+#endif
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOIDREF
 #ifndef PALM_2
 SOAP_FMAC1
@@ -3892 +4900 @@
 }
 #endif
-
-/******************************************************************************/
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOIDREF
 #ifndef PALM_2
 SOAP_FMAC1
@@ -3902 +4912 @@
   *ppp = NULL;
   if (p)
-    for (pp = soap->pht[soap_hash_ptr(p)]; pp; pp = pp->next)
-      if (pp->ptr == p && pp->type == type)
+  { for (pp = soap->pht[soap_hash_ptr(p)]; pp; pp = pp->next)
+    { if (pp->ptr == p && pp->type == type)
       { *ppp = pp;
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Lookup location=%p type=%d id=%d\n", p, type, pp->id));
         return pp->id;
       }
+    }
+  }
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Lookup location=%p type=%d: not found\n", p, type));
   return 0;
 }
 #endif
-
-/******************************************************************************/
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOIDREF
 #ifndef PALM_2
 SOAP_FMAC1
@@ -3919 +4933 @@
 SOAP_FMAC2
 soap_pointer_enter(struct soap *soap, const void *p, const struct soap_array *a, int n, int type, struct soap_plist **ppp)
-{ register int h;
-  register struct soap_plist *pp = *ppp = (struct soap_plist*)SOAP_MALLOC(sizeof(struct soap_plist));
-  if (!pp)
-    return 0;
+{ register size_t h;
+  register struct soap_plist *pp;
+  if (!soap->pblk || soap->pidx >= SOAP_PTRBLK)
+  { register struct soap_pblk *pb = (struct soap_pblk*)SOAP_MALLOC(soap, sizeof(struct soap_pblk));
+    if (!pb)
+    { soap->error = SOAP_EOM;
+      return 0;
+    }
+    pb->next = soap->pblk;
+    soap->pblk = pb;
+    soap->pidx = 0;
+  }
+  *ppp = pp = &soap->pblk->plist[soap->pidx++];
   if (a)
     h = soap_hash_ptr(a->__ptr);
   else
     h = soap_hash_ptr(p);
-  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Pointer enter location=%p array=%p size=%d dim=%d type=%d id=%lu\n", p, a?a->__ptr:NULL, a?a->__size:0, n, type, soap->idnum+1));
+  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));
   pp->next = soap->pht[h];
   pp->type = type;
@@ -3939 +4962 @@
 }
 #endif
-
-/******************************************************************************/
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOIDREF
 #ifndef PALM_2
 SOAP_FMAC1
@@ -3955 +4980 @@
       for (i = 0; i < n; i++)
         if (((const int*)&pp->array->__size)[i] != ((const int*)&a->__size)[i])
-          break;
+          break;
       if (i == n)
       { *ppp = pp;
@@ -3967 +4992 @@
 }
 #endif
-
-/******************************************************************************/
-#ifndef PALM_1
-SOAP_FMAC1
-void
+#endif
+
+/******************************************************************************/
+#ifndef PALM_1
+SOAP_FMAC1
+int
 SOAP_FMAC2
 soap_begin_count(struct soap *soap)
-{ soap_clr_attr(soap);
-  soap_set_local_namespaces(soap);
+{
 #ifndef WITH_LEANER
   if ((soap->mode & SOAP_ENC_DIME) || (soap->omode & SOAP_ENC_DIME))
@@ -3983 +5008 @@
   { soap->mode = soap->omode;
     if ((soap->mode & SOAP_IO) == SOAP_IO_STORE
-     || (((soap->mode & SOAP_IO) == SOAP_IO_CHUNK || (soap->mode & SOAP_ENC_XML)) && !soap->fpreparesend))
+     || (((soap->mode & SOAP_IO) == SOAP_IO_CHUNK || (soap->mode & SOAP_ENC_XML))
+#ifndef WITH_LEANER
+      && !soap->fpreparesend
+#endif
+      ))
       soap->mode &= ~SOAP_IO_LENGTH;
     else
       soap->mode |= SOAP_IO_LENGTH;
   }
+#ifdef WITH_ZLIB
   if ((soap->mode & SOAP_ENC_ZLIB) && (soap->mode & SOAP_IO) == SOAP_IO_FLUSH)
   { if (!(soap->mode & SOAP_ENC_DIME))
@@ -3996 +5026 @@
       soap->mode |= SOAP_IO_STORE;
   }
+#endif
   if (!soap->encodingStyle && !(soap->mode & SOAP_XML_GRAPH))
     soap->mode |= SOAP_XML_TREE;
 #ifndef WITH_LEANER
+  if ((soap->mode & SOAP_ENC_MTOM) && (soap->mode & SOAP_ENC_DIME))
+    soap->mode |= SOAP_ENC_MIME;
+  else
+    soap->mode &= ~SOAP_ENC_MTOM;
   if (soap->mode & SOAP_ENC_MIME)
     soap_select_mime_boundary(soap);
@@ -4011 +5046 @@
   soap->part = SOAP_BEGIN;
   soap->idnum = 0;
+  soap_clr_attr(soap);
+  soap_set_local_namespaces(soap);
+  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Begin count phase (socket=%d mode=0x%x count=%lu)\n", soap->socket, soap->mode, (unsigned long)soap->count));
+#ifndef WITH_LEANER
   soap->dime.count = 0; /* count # of attachments */
   soap->dime.size = 0; /* accumulate total size of attachments */
-  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Begin count phase (socket=%d mode=%x count=%lu)\n", soap->socket, soap->mode, (unsigned long)soap->count));
   if (soap->fprepareinit && (soap->mode & SOAP_IO) != SOAP_IO_STORE)
-    soap->fprepareinit(soap);   
+    return soap->error = soap->fprepareinit(soap);   
+#endif
+  return SOAP_OK;
 }
 #endif
@@ -4024 +5064 @@
 int
 SOAP_FMAC2
+soap_end_count(struct soap *soap)
+{ 
+#ifndef WITH_LEANER
+  if (soap->fpreparefinal)
+    return soap->error = soap->fpreparefinal(soap);
+#endif
+  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End of count phase\n"));
+  return SOAP_OK;
+}
+#endif
+
+/******************************************************************************/
+#ifndef PALM_1
+SOAP_FMAC1
+int
+SOAP_FMAC2
 soap_begin_send(struct soap *soap)
-{ soap->error = SOAP_OK;
-  soap_clr_attr(soap);
-  soap_set_local_namespaces(soap);
-  soap->mode = (soap->omode & ~SOAP_IO_LENGTH) | (soap->mode & SOAP_ENC_DIME);
+{ DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Initializing for output\n"));
+  soap->error = SOAP_OK;
+  soap->mode = soap->omode | (soap->mode & (SOAP_IO_LENGTH | SOAP_ENC_DIME));
+#ifdef WITH_ZLIB
   if ((soap->mode & SOAP_ENC_ZLIB) && (soap->mode & SOAP_IO) == SOAP_IO_FLUSH)
   { if (soap->mode & SOAP_ENC_XML)
@@ -4035 +5091 @@
       soap->mode |= SOAP_IO_STORE;
   }
+#endif
+#ifndef WITH_LEAN
+  if ((soap->mode & SOAP_IO_UDP))
+  { soap->mode |= SOAP_ENC_XML;
+    if (soap->count > SOAP_BUFLEN)
+      return soap->error = SOAP_UDP_ERROR;
+  }
+#endif
   if ((soap->mode & SOAP_IO) == SOAP_IO_FLUSH && soap_valid_socket(soap->socket))
-  { if (soap->count || (soap->mode & SOAP_ENC_XML))
+  { if (soap->count || (soap->mode & SOAP_IO_LENGTH) || (soap->mode & SOAP_ENC_XML))
       soap->mode |= SOAP_IO_BUFFER;
     else
       soap->mode |= SOAP_IO_STORE;
   }
+  soap->mode &= ~SOAP_IO_LENGTH;
   if ((soap->mode & SOAP_IO) == SOAP_IO_STORE)
-    soap_new_block(soap);
+    if (soap_new_block(soap) == NULL)
+      return soap->error;
   if (!(soap->mode & SOAP_IO_KEEPALIVE))
     soap->keep_alive = 0;
@@ -4048 +5114 @@
     soap->mode |= SOAP_XML_TREE;
 #ifndef WITH_LEANER
+  if ((soap->mode & SOAP_ENC_MTOM) && (soap->mode & SOAP_ENC_DIME))
+  { soap->mode |= SOAP_ENC_MIME;
+    soap->mode &= ~SOAP_ENC_DIME;
+  }
+  else
+    soap->mode &= ~SOAP_ENC_MTOM;
   if (soap->mode & SOAP_ENC_MIME)
     soap_select_mime_boundary(soap);
-#endif
 #ifdef WIN32
 #ifndef UNDER_CE
@@ -4056 +5127 @@
   if (!soap_valid_socket(soap->socket)) /* Set win32 stdout or soap->sendfd to BINARY, e.g. to support DIME */
 #ifdef __BORLANDC__
-    setmode((SOAP_SOCKET)soap->sendfd, O_BINARY);
+    setmode(soap->sendfd, O_BINARY);
 #else
-    _setmode((SOAP_SOCKET)soap->sendfd, _O_BINARY);
+    _setmode(soap->sendfd, _O_BINARY);
+#endif
 #endif
 #endif
@@ -4073 +5145 @@
   soap->mustUnderstand = 0;
   soap->encoding = 0;
-  soap->part = SOAP_BEGIN;
   soap->idnum = 0;
   soap->level = 0;
+  soap_clr_attr(soap);
+  soap_set_local_namespaces(soap);
 #ifdef WITH_ZLIB
   soap->z_ratio_out = 1.0;
   if ((soap->mode & SOAP_ENC_ZLIB) && soap->zlib_state != SOAP_ZLIB_DEFLATE)
-  {
+  { if (!soap->z_buf)
+      soap->z_buf = (char*)SOAP_MALLOC(soap, SOAP_BUFLEN);
+    soap->d_stream->next_out = (Byte*)soap->z_buf;
+    soap->d_stream->avail_out = SOAP_BUFLEN;
 #ifdef WITH_GZIP
-    memcpy(soap->z_buf, "\37\213\10\0\0\0\0\0\0\377", 10);
-    soap->d_stream.next_out = (Byte*)soap->z_buf + 10;
-    soap->d_stream.avail_out = SOAP_BUFLEN - 10;
-    soap->z_crc = crc32(0L, NULL, 0);
-    if (deflateInit2(&soap->d_stream, soap->z_level, Z_DEFLATED, -MAX_WBITS, 8, Z_DEFAULT_STRATEGY) != Z_OK)
-#else
-    soap->d_stream.next_out = (Byte*)soap->z_buf;
-    soap->d_stream.avail_out = SOAP_BUFLEN;
-    if (deflateInit(&soap->d_stream, soap->z_level) != Z_OK)
-#endif
+    if (soap->zlib_out != SOAP_ZLIB_DEFLATE)
+    { memcpy(soap->z_buf, "\37\213\10\0\0\0\0\0\0\377", 10);
+      soap->d_stream->next_out = (Byte*)soap->z_buf + 10;
+      soap->d_stream->avail_out = SOAP_BUFLEN - 10;
+      soap->z_crc = crc32(0L, NULL, 0);
+      soap->zlib_out = SOAP_ZLIB_GZIP;
+      if (deflateInit2(soap->d_stream, soap->z_level, Z_DEFLATED, -MAX_WBITS, 8, Z_DEFAULT_STRATEGY) != Z_OK)
+        return soap->error = SOAP_ZLIB_ERROR;
+    }
+    else
+#endif
+    if (deflateInit(soap->d_stream, soap->z_level) != Z_OK)
       return soap->error = SOAP_ZLIB_ERROR;
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Deflate initialized\n"));
@@ -4096 +5174 @@
   }
 #endif
-  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Begin send phase (socket=%d mode=%x count=%lu)\n", soap->socket, soap->mode, (unsigned long)soap->count));
+#ifdef WITH_OPENSSL
+  if (soap->ssl)
+    ERR_clear_error();
+#endif
+  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Begin send phase (socket=%d mode=0x%x count=%lu)\n", soap->socket, soap->mode, (unsigned long)soap->count));
+  soap->part = SOAP_BEGIN;
+#ifndef WITH_LEANER
   if (soap->fprepareinit && (soap->mode & SOAP_IO) == SOAP_IO_STORE)
     soap->fprepareinit(soap);   
+#endif
   return SOAP_OK;
 }
@@ -4104 +5189 @@
 
 /******************************************************************************/
+#ifndef WITH_NOIDREF
 #ifndef PALM_2
 SOAP_FMAC1
@@ -4117 +5203 @@
 }
 #endif
-
-/******************************************************************************/
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOIDREF
 #ifndef PALM_2
 SOAP_FMAC1
@@ -4143 +5231 @@
 }
 #endif
-
-/******************************************************************************/
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOIDREF
 #ifndef PALM_2
 SOAP_FMAC1
@@ -4152 +5242 @@
 { register int i;
   struct soap_plist *pp;
-  if (!p)
+  if (!p || !a->__ptr)
     return 1;
   i = soap_array_pointer_lookup(soap, p, a, n, t, &pp);
@@ -4171 +5261 @@
 }
 #endif
-
-/******************************************************************************/
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOIDREF
 #ifndef PALM_2
 SOAP_FMAC1
@@ -4178 +5270 @@
 SOAP_FMAC2
 soap_embedded_id(struct soap *soap, int id, const void *p, int t)
-{ struct soap_plist *pp;
-  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Embedded_id %p type=%d id=%d\n", p, t, id));
+{ struct soap_plist *pp = NULL;
   if (soap->mode & SOAP_XML_TREE)
     return id;
+  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Embedded_id %p type=%d id=%d\n", p, t, id));
   if (soap->version == 1 && soap->encodingStyle && !(soap->mode & SOAP_XML_GRAPH) && soap->part != SOAP_IN_HEADER)
   { if (id < 0)
@@ -4210 +5302 @@
 }
 #endif
-
-/******************************************************************************/
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOIDREF
 #ifndef PALM_2
 SOAP_FMAC1
@@ -4230 +5324 @@
 }
 #endif
-
-/******************************************************************************/
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOIDREF
 #ifndef PALM_2
 SOAP_FMAC1
@@ -4246 +5342 @@
 }
 #endif
-
-/******************************************************************************/
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOIDREF
 #ifndef PALM_2
 SOAP_FMAC1
@@ -4261 +5359 @@
 }
 #endif
+#endif
 
 /******************************************************************************/
@@ -4268 +5367 @@
 int
 SOAP_FMAC2
-soap_element_dime(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) 
-{ struct soap_plist *pp;
+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) 
+{
+#ifndef WITH_NOIDREF
+  struct soap_plist *pp;
+  int i;
   if (!p || !a->__ptr || (!aid && !atype))
     return soap_element_id(soap, tag, id, p, a, n, type, t);
-  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Attachment tag='%s' id='%s' (%d) type='%s'\n", tag, aid?aid:"", id, atype?atype:""));
-  if (id < 0)
-    id = soap_array_pointer_lookup(soap, p, a, n, t, &pp);
+  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));
+  i = soap_array_pointer_lookup(soap, p, a, n, t, &pp);
+  if (!i)
+  { i = soap_pointer_enter(soap, p, a, n, t, &pp);
+    if (!i)
+    { soap->error = SOAP_EOM;
+      return -1;
+    }
+  }
+  if (id <= 0)
+    id = i;
   if (!aid)
   { sprintf(soap->tmpbuf, soap->dime_id_format, id);
     aid = soap_strdup(soap, soap->tmpbuf);
   }
-  if (soap_element_href(soap, tag, 0, "href", aid))
+  /* Add MTOM xop:Include element when necessary */
+  /* TODO: this code to be obsoleted with new import/xop.h conventions */
+  if ((soap->mode & SOAP_ENC_MTOM) && strcmp(tag, "xop:Include"))
+  { if (soap_element_begin_out(soap, tag, 0, type)
+     || soap_element_href(soap, "xop:Include", 0, "href", aid)
+     || soap_element_end_out(soap, tag))
+      return soap->error;
+  }
+  else if (soap_element_href(soap, tag, 0, "href", aid))
     return soap->error;
   if (soap->mode & SOAP_IO_LENGTH)
   { if (pp->mark1 != 3)
-    { struct soap_multipart *content = soap_new_multipart(soap, &soap->dime.first, &soap->dime.last, (char*)a->__ptr, a->__size);
+    { struct soap_multipart *content;
+      if (soap->mode & SOAP_ENC_MTOM)
+        content = soap_new_multipart(soap, &soap->mime.first, &soap->mime.last, (char*)a->__ptr, a->__size);
+      else
+        content = soap_new_multipart(soap, &soap->dime.first, &soap->dime.last, (char*)a->__ptr, a->__size);
       if (!content)
-        return soap->error = SOAP_EOM;
-      content->id = aid;
+      { soap->error = SOAP_EOM;
+        return -1;
+      }
+      if (!strncmp(aid, "cid:", 4)) /* RFC 2111 */
+      { if (soap->mode & SOAP_ENC_MTOM)
+        { char *s = (char*)soap_malloc(soap, strlen(aid) - 1);
+          if (s)
+          { *s = '<';
+            strcpy(s + 1, aid + 4);
+            strcat(s, ">");
+            content->id = s;
+          }
+        }
+        else
+          content->id = aid + 4;
+      }
+      else
+        content->id = aid;
       content->type = atype;
       content->options = aoptions;
+      content->encoding = SOAP_MIME_BINARY;
       pp->mark1 = 3;
     }
@@ -4294 +5433 @@
   else
     pp->mark2 = 3;
-  return SOAP_OK;
-}
-#endif
-#endif
-
-/******************************************************************************/
+#endif
+  return -1;
+}
+#endif
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOIDREF
 #ifndef PALM_1
 static void
@@ -4309 +5450 @@
 }
 #endif
-
-/******************************************************************************/
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOIDREF
 #ifndef PALM_1
 static void
 soap_free_iht(struct soap *soap)
 { register int i;
-  register struct soap_ilist *ip, *p;
-  register struct soap_flist *fp, *fq;
+  register struct soap_ilist *ip = NULL, *p = NULL;
+  register struct soap_flist *fp = NULL, *fq = NULL;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free ID hashtable\n"));
   for (i = 0; i < SOAP_IDHASH; i++)
@@ -4322 +5465 @@
     { for (fp = ip->flist; fp; fp = fq)
       { fq = fp->next;
-        SOAP_FREE(fp);
+        SOAP_FREE(soap, fp);
       }
       p = ip->next;
-      SOAP_FREE(ip);
+      SOAP_FREE(soap, ip);
     }
     soap->iht[i] = NULL;
@@ -4331 +5474 @@
 }
 #endif
-
-/******************************************************************************/
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOIDREF
 #ifndef PALM_2
-static struct soap_ilist *
-soap_hlookup(struct soap *soap, const char *id)
-{ register struct soap_ilist *ip;
+SOAP_FMAC1
+struct soap_ilist *
+SOAP_FMAC2
+soap_lookup(struct soap *soap, const char *id)
+{ register struct soap_ilist *ip = NULL;
   for (ip = soap->iht[soap_hash(id)]; ip; ip = ip->next)
     if (!strcmp(ip->id, id))
@@ -4343 +5490 @@
 }
 #endif
-
-/******************************************************************************/
-#ifndef PALM_2
-SOAP_FMAC1
-struct soap_ilist *
-SOAP_FMAC2
-soap_lookup(struct soap *soap, const char *id)
-{ register struct soap_ilist *ip;
-  ip = soap_hlookup(soap, id);
-#ifndef WITH_LEANER
-  if (!ip && *id != '#' && !strchr(id, ':')) /* try content id "cid:" with DIME attachments */
-  { char cid[SOAP_TAGLEN];
-    strcpy(cid, "cid:");
-    strncat(cid + 4, id, sizeof(cid) - 5);
-    cid[sizeof(cid) - 1] = '\0';
-    ip = soap_hlookup(soap, cid);
-  }
-#endif
-  return ip;
-}
-#endif
-
-/******************************************************************************/
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOIDREF
 #ifndef PALM_2
 SOAP_FMAC1
@@ -4373 +5501 @@
 { register size_t h;
   register struct soap_ilist *ip;
-  ip = (struct soap_ilist*)SOAP_MALLOC(sizeof(struct soap_ilist) + strlen(id));
+  ip = (struct soap_ilist*)SOAP_MALLOC(soap, sizeof(struct soap_ilist) + strlen(id));
   if (ip)
   { h = soap_hash(id);
@@ -4379 +5507 @@
     ip->next = soap->iht[h];
     soap->iht[h] = ip;
-    return ip;
-  }
-  return NULL;
-}
+  }
+  return ip;
+}
+#endif
 #endif
 
@@ -4393 +5521 @@
 { register char *p;
   if (!n)
-    return NULL;
+    return (void*)SOAP_NON_NULL;
   if (!soap)
-    return SOAP_MALLOC(n);
-  n += (-(long)n) & 7;
-  if (!(p = (char*)SOAP_MALLOC(n + sizeof(void*) + sizeof(size_t))))
-  { soap->error = SOAP_EOM;
-    return NULL;
-  }
-  /* keep chain of alloced cells for later destruction */
+    return SOAP_MALLOC(soap, n);
+  if (soap->fmalloc)
+    p = (char*)soap->fmalloc(soap, n);
+  else
+  { n += sizeof(short);
+    n += (-(long)n) & (sizeof(void*)-1); /* align at 4-, 8- or 16-byte boundary */
+    if (!(p = (char*)SOAP_MALLOC(soap, n + sizeof(void*) + sizeof(size_t))))
+    { soap->error = SOAP_EOM;
+      return NULL;
+    }
+    /* set the canary to detect corruption */
+    *(short*)(p + n - sizeof(short)) = (short)SOAP_CANARY;
+    /* keep chain of alloced cells for destruction */
+    *(void**)(p + n) = soap->alist;
+    *(size_t*)(p + n + sizeof(void*)) = n;
+    soap->alist = p + n;
+  }
   soap->alloced = 1;
-  *(void**)(p + n) = soap->alist;
-  *(size_t*)(p + n + sizeof(void*)) = n;
-  soap->alist = p + n;
-  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Malloc %u bytes at location %p\n", (unsigned int)n, p));
   return p;
 }
@@ -4412 +5546 @@
 
 /******************************************************************************/
+#ifdef SOAP_MEM_DEBUG
+static void
+soap_init_mht(struct soap *soap)
+{ register int i;
+  for (i = 0; i < (int)SOAP_PTRHASH; i++)
+    soap->mht[i] = NULL;
+}
+#endif
+
+/******************************************************************************/
+#ifdef SOAP_MEM_DEBUG
+static void
+soap_free_mht(struct soap *soap)
+{ register int i;
+  register struct soap_mlist *mp, *mq;
+  for (i = 0; i < (int)SOAP_PTRHASH; i++)
+  { for (mp = soap->mht[i]; mp; mp = mq)
+    { mq = mp->next;
+      if (mp->live)
+        fprintf(stderr, "%s(%d): malloc() = %p not freed (memory leak or forgot to call soap_end()?)\n", mp->file, mp->line, mp->ptr);
+      free(mp);
+    }
+    soap->mht[i] = NULL;
+  }
+}
+#endif
+
+/******************************************************************************/
+#ifdef SOAP_MEM_DEBUG
+SOAP_FMAC1
+void*
+SOAP_FMAC2
+soap_track_malloc(struct soap *soap, const char *file, int line, size_t size)
+{ register void *p = malloc(size);
+  if (soap)
+  { register size_t h = soap_hash_ptr(p);
+    register struct soap_mlist *mp = (struct soap_mlist*)malloc(sizeof(struct soap_mlist));
+    if (soap->fdebug[SOAP_INDEX_TEST])
+    { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "%s(%d): malloc(%lu) = %p\n", file, line, (unsigned long)size, p));
+    }
+    mp->next = soap->mht[h];
+    mp->ptr = p;
+    mp->file = file;
+    mp->line = line;
+    mp->live = 1;
+    soap->mht[h] = mp;
+  }
+  return p;
+}
+#endif
+
+/******************************************************************************/
+#ifdef SOAP_MEM_DEBUG
+SOAP_FMAC1
+void
+SOAP_FMAC2
+soap_track_free(struct soap *soap, const char *file, int line, void *p)
+{ register size_t h = soap_hash_ptr(p);
+  register struct soap_mlist *mp;
+  for (mp = soap->mht[h]; mp; mp = mp->next)
+    if (mp->ptr == p)
+      break;
+  if (mp)
+  { if (mp->live)
+    { free(p);
+      if (soap->fdebug[SOAP_INDEX_TEST])
+      { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "%s(%d): free(%p)\n", file, line, p));
+      }
+      mp->live = 0;
+    }
+    else
+      fprintf(stderr, "%s(%d): free(%p) double free of pointer malloced at %s(%d)\n", file, line, p, mp->file, mp->line);
+  }
+  else
+    fprintf(stderr, "%s(%d): free(%p) pointer not malloced\n", file, line, p);
+}
+#endif
+
+/******************************************************************************/
+#ifdef SOAP_MEM_DEBUG
+static void
+soap_track_unlink(struct soap *soap, const void *p)
+{ register size_t h = soap_hash_ptr(p);
+  register struct soap_mlist *mp;
+  for (mp = soap->mht[h]; mp; mp = mp->next)
+    if (mp->ptr == p)
+      break;
+  if (mp)
+    mp->live = 0;
+}
+#endif
+
+/******************************************************************************/
 #ifndef PALM_2
 SOAP_FMAC1
@@ -4417 +5644 @@
 SOAP_FMAC2
 soap_dealloc(struct soap *soap, void *p)
-{ if (!soap)
+{ if (soap_check_state(soap))
     return;
   if (p)
   { register char **q;
     for (q = (char**)&soap->alist; *q; q = *(char***)q)
-    { if (p == (void*)(*q - *(size_t*)(*q + sizeof(void*))))
+    { 
+      if (*(short*)(char*)(*q - sizeof(short)) != (short)SOAP_CANARY)
+      {
+#ifdef SOAP_MEM_DEBUG
+        fprintf(stderr, "Data corruption in dynamic allocation (see logs)\n");
+#endif
+        DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Data corruption:\n"));
+        DBGHEX(TEST, *q - 200, 200);
+        DBGLOG(TEST, SOAP_MESSAGE(fdebug, "\n"));
+        soap->error = SOAP_MOE;
+        return;
+      }
+      if (p == (void*)(*q - *(size_t*)(*q + sizeof(void*))))
       { *q = **(char***)q;
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Freed data at %p\n", p));
-        SOAP_FREE(p);
+        SOAP_FREE(soap, p);
         return;
       }
@@ -4433 +5672 @@
   else
   { register char *q;
+    DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free all soap_malloc() data\n"));
     while (soap->alist)
     { q = (char*)soap->alist;
+      if (*(short*)(char*)(q - sizeof(short)) != (short)SOAP_CANARY)
+      {
+#ifdef SOAP_MEM_DEBUG
+        fprintf(stderr, "Data corruption in dynamic allocation (see logs)\n");
+#endif
+        DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Data corruption:\n"));
+        DBGHEX(TEST, q - 200, 200);
+        DBGLOG(TEST, SOAP_MESSAGE(fdebug, "\n"));
+        soap->error = SOAP_MOE;
+        return;
+      }
       soap->alist = *(void**)q;
       q -= *(size_t*)(q + sizeof(void*));
-      SOAP_FREE(q);
-    }
-    DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Dealloc all data done\n"));
-  }
-  /* we must assume these were deallocated: */
-  soap->action = NULL;
-  soap->fault = NULL;
-  soap->header = NULL;
-  soap->authrealm = NULL;
+      SOAP_FREE(soap, q);
+    }
+    /* we must assume these were deallocated: */
+    soap->action = NULL;
+    soap->fault = NULL;
+    soap->header = NULL;
+    soap->userid = NULL;
+    soap->passwd = NULL;
+    soap->authrealm = NULL;
+    soap->http_content = NULL;
 #ifndef WITH_LEANER
-  soap_clr_mime(soap);
-#endif
+    soap_clr_mime(soap);
+#endif
+  }
 }
 #endif
@@ -4458 +5711 @@
 SOAP_FMAC2
 soap_delete(struct soap *soap, void *p)
-{ register struct soap_clist **cp = &soap->clist;
+{ register struct soap_clist **cp;
+  if (soap_check_state(soap))
+    return;
+  cp = &soap->clist;
   if (p)
   { while (*cp)
@@ -4464 +5720 @@
       { register struct soap_clist *q = *cp;
         *cp = q->next;
-        q->fdelete(q);
-        SOAP_FREE(q);
+        if (q->fdelete(q))
+        { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not dealloc data %p: deletion callback failed for object type %d\n", q->ptr, q->type));
+#ifdef SOAP_MEM_DEBUG
+          fprintf(stderr, "new(object type = %d) = %p not freed: deletion callback failed\n", q->type, q->ptr);
+#endif
+        }
+        SOAP_FREE(soap, q);
         return;
       }
@@ -4476 +5737 @@
     { register struct soap_clist *q = *cp;
       *cp = q->next;
-      if (q->ptr == (void*)soap->fault)
-        soap->fault = NULL; /* this was deallocated */
-      else if (q->ptr == (void*)soap->header)
-        soap->header = NULL; /* this was deallocated */
-      q->fdelete(q);
-      SOAP_FREE(q);
-    }
-  }
+      if (q->fdelete(q))
+      { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not dealloc data %p: deletion callback failed for object type %d\n", q->ptr, q->type));
+#ifdef SOAP_MEM_DEBUG
+        fprintf(stderr, "new(object type = %d) = %p not freed: deletion callback failed\n", q->type, q->ptr);
+#endif
+      }
+      SOAP_FREE(soap, q);
+    }
+  }
+  soap->fault = NULL; /* this was possibly deallocated */
+  soap->header = NULL; /* this was possibly deallocated */
 }
 #endif
@@ -4492 +5756 @@
 struct soap_clist *
 SOAP_FMAC2
-soap_link(struct soap *soap, void *p, int t, int n, void (*fdelete)(struct soap_clist*))
+soap_link(struct soap *soap, void *p, int t, int n, int (*fdelete)(struct soap_clist*))
 { register struct soap_clist *cp;
-  if ((cp = (struct soap_clist*)SOAP_MALLOC(sizeof(struct soap_clist))))
+  if ((cp = (struct soap_clist*)SOAP_MALLOC(soap, sizeof(struct soap_clist))))
   { cp->next = soap->clist;
     cp->type = t;
@@ -4520 +5784 @@
     { *q = **(char***)q;
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unlinked data %p\n", p));
+#ifdef SOAP_MEM_DEBUG
+      soap_track_unlink(soap, p);
+#endif
       return;
     }
@@ -4528 +5795 @@
       q = (char**)*cp;
       *cp = (*cp)->next;
-      SOAP_FREE(q);
+      SOAP_FREE(soap, q);
       return;
     }
@@ -4536 +5803 @@
 
 /******************************************************************************/
+#ifndef WITH_NOIDREF
 #ifndef PALM_2
 SOAP_FMAC1
@@ -4553 +5821 @@
 }
 #endif
-
-/******************************************************************************/
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOIDREF
 #ifndef PALM_2
 SOAP_FMAC1
@@ -4562 +5832 @@
 { struct soap_ilist *ip;
   void **q;
-  if (!id || !*id)
+  if (!p || !id || !*id)
     return p;
-  soap->alloced = 0;
-  if (!p)
-    p = (void**)soap_malloc(soap, sizeof(void*));
   ip = soap_lookup(soap, id); /* lookup pointer to hash table entry for string id */
   if (!ip)
-  { ip = soap_enter(soap, id); /* new hash table entry for string id */
+  { if (!(ip = soap_enter(soap, id))) /* new hash table entry for string id */
+      return NULL;
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Forwarding first href='%s' type=%d %p (%u bytes)\n", id, t, p, (unsigned int)n));
     ip->type = t;
@@ -4585 +5853 @@
     { strcpy(soap->id, id);
       soap->error = SOAP_HREF;
-      DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Type incompatibility: id type=%d href type=%d\n", ip->type, t));
+      DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Type incompatibility: href='%s' id-type=%d href-type=%d\n", id, ip->type, t));
       return NULL;
     }
@@ -4606 +5874 @@
       while (q)
       { *r = (void*)soap_malloc(soap, sizeof(void*));
+        if (!*r)
+          return NULL;
         s = *q;
         *q = *r;
@@ -4625 +5895 @@
     while (ip->level < k)
     { q = (void**)soap_malloc(soap, sizeof(void*));  
+      if (!q)
+        return NULL;
       *p = q;
       p = q;
@@ -4637 +5909 @@
 }
 #endif
-
-/******************************************************************************/
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOIDREF
 #ifndef PALM_2
 SOAP_FMAC1
 void*
 SOAP_FMAC2
-soap_id_forward(struct soap *soap, const char *href, void *p, int st, int tt, size_t n, unsigned int k, void (*fcopy)(struct soap*, int, int, void*, const void*, size_t))
+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))
 { struct soap_ilist *ip;
   if (!p || !href || !*href)
@@ -4649 +5923 @@
   ip = soap_lookup(soap, href); /* lookup pointer to hash table entry for string id */
   if (!ip)
-  { ip = soap_enter(soap, href); /* new hash table entry for string id */
+  { if (!(ip = soap_enter(soap, href))) /* new hash table entry for string id */
+      return NULL;
     ip->type = st;
     ip->size = n;
@@ -4666 +5941 @@
   }
   if (fcopy || n < sizeof(void*) || *href != '#')
-  { register struct soap_flist *fp = (struct soap_flist*)SOAP_MALLOC(sizeof(struct soap_flist));
+  { register struct soap_flist *fp = (struct soap_flist*)SOAP_MALLOC(soap, sizeof(struct soap_flist));
     if (!fp)
     { soap->error = SOAP_EOM;
@@ -4675 +5950 @@
     fp->ptr = p;
     fp->level = k;
+    fp->len = len;
     if (fcopy)
       fp->fcopy = fcopy;
@@ -4680 +5956 @@
       fp->fcopy = soap_fcopy;
     ip->flist = fp;
-    DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Forwarding type=%d (target type=%d) size=%lu location=%p level=%u href='%s'\n", st, tt, (unsigned long)n, p, k, href));
+    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));
   }
   else
@@ -4690 +5966 @@
 }
 #endif
+#endif
 
 /******************************************************************************/
@@ -4697 +5974 @@
 SOAP_FMAC2
 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*))
-{ struct soap_ilist *ip;
+{
+#ifndef WITH_NOIDREF
+  struct soap_ilist *ip;
+#endif
   DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Enter id='%s' type=%d loc=%p size=%lu level=%u\n", id, t, p, (unsigned long)n, k));
   soap->alloced = 0;
@@ -4708 +5988 @@
       soap->alloced = 1;
   }
+#ifndef WITH_NOIDREF
   if (!id || !*id)
+#endif
     return p;
+#ifndef WITH_NOIDREF
   ip = soap_lookup(soap, id); /* lookup pointer to hash table entry for string id */
   DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Lookup entry id='%s for location=%p'\n", id, p));
   if (!ip)
-  { ip = soap_enter(soap, id); /* new hash table entry for string id */
+  { if (!(ip = soap_enter(soap, id))) /* new hash table entry for string id */
+      return NULL;
     ip->type = t;
     ip->link = NULL;
@@ -4732 +6016 @@
   { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Multiply defined id='%s'\n", id));
     strcpy(soap->id, id);
-    soap->error = SOAP_MULTI_ID;
+    soap->error = SOAP_DUPLICATE_ID;
     return NULL;
   }
@@ -4742 +6026 @@
   }
   return ip->ptr;
+#endif
 }
 #endif
@@ -4750 +6035 @@
 void
 SOAP_FMAC2
-soap_fcopy(struct soap *soap, int st, int tt, void *p, const void *q, size_t n)
+soap_fcopy(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
 { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Copying data type=%d (target type=%d) %p -> %p (%lu bytes)\n", st, tt, q, p, (unsigned long)n));
   memcpy(p, q, n);
@@ -4786 +6071 @@
     { if (soap->mode & SOAP_ENC_ZLIB && soap->zlib_state == SOAP_ZLIB_DEFLATE)
       { soap->zlib_state = SOAP_ZLIB_NONE;
-        deflateEnd(&soap->d_stream);
+        deflateEnd(soap->d_stream);
       }
       return soap->error;
@@ -4796 +6081 @@
     if (soap->mode & SOAP_ENC_ZLIB)
     { int r;
-      soap->d_stream.avail_in = 0;
+      soap->d_stream->avail_in = 0;
       do
       { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Deflating remainder\n"));
-        r = deflate(&soap->d_stream, Z_FINISH);
-        if (soap->d_stream.avail_out != SOAP_BUFLEN)
-        { if (soap_flush_raw(soap, soap->z_buf, SOAP_BUFLEN - soap->d_stream.avail_out))
+        r = deflate(soap->d_stream, Z_FINISH);
+        if (soap->d_stream->avail_out != SOAP_BUFLEN)
+        { if (soap_flush_raw(soap, soap->z_buf, SOAP_BUFLEN - soap->d_stream->avail_out))
           { soap->zlib_state = SOAP_ZLIB_NONE;
-            deflateEnd(&soap->d_stream);
+            deflateEnd(soap->d_stream);
             return soap->error;
-          }
-          soap->d_stream.next_out = (Byte*)soap->z_buf;
-          soap->d_stream.avail_out = SOAP_BUFLEN;
+          }
+          soap->d_stream->next_out = (Byte*)soap->z_buf;
+          soap->d_stream->avail_out = SOAP_BUFLEN;
         }
       } while (r == Z_OK);
-      DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Deflated %lu->%lu bytes\n", soap->d_stream.total_in, soap->d_stream.total_out));
-      soap->z_ratio_out = (float)soap->d_stream.total_out / (float)soap->d_stream.total_in;
+      DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Deflated total %lu->%lu bytes\n", soap->d_stream->total_in, soap->d_stream->total_out));
+      soap->z_ratio_out = (float)soap->d_stream->total_out / (float)soap->d_stream->total_in;
       soap->mode &= ~SOAP_ENC_ZLIB;
       soap->zlib_state = SOAP_ZLIB_NONE;
-      if (deflateEnd(&soap->d_stream) != Z_OK || r != Z_STREAM_END)
-      { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unable to end deflate: %s\n", soap->d_stream.msg?soap->d_stream.msg:""));
+      if (deflateEnd(soap->d_stream) != Z_OK || r != Z_STREAM_END)
+      { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unable to end deflate: %s\n", soap->d_stream->msg?soap->d_stream->msg:SOAP_STR_EOS));
         return soap->error = SOAP_ZLIB_ERROR;
       }
 #ifdef WITH_GZIP
-      soap->z_buf[0] = soap->z_crc & 0xFF;
-      soap->z_buf[1] = (soap->z_crc >> 8) & 0xFF;
-      soap->z_buf[2] = (soap->z_crc >> 16) & 0xFF;
-      soap->z_buf[3] = (soap->z_crc >> 24) & 0xFF;
-      soap->z_buf[4] = soap->d_stream.total_in & 0xFF;
-      soap->z_buf[5] = (soap->d_stream.total_in >> 8) & 0xFF;
-      soap->z_buf[6] = (soap->d_stream.total_in >> 16) & 0xFF;
-      soap->z_buf[7] = (soap->d_stream.total_in >> 24) & 0xFF;
-      if (soap_flush_raw(soap, soap->z_buf, 8))
-        return soap->error;
-      DBGLOG(TEST, SOAP_MESSAGE(fdebug, "gzip crc32=%lu\n", (unsigned long)soap->z_crc));
+      if (soap->zlib_out != SOAP_ZLIB_DEFLATE)
+      { soap->z_buf[0] = soap->z_crc & 0xFF;
+        soap->z_buf[1] = (soap->z_crc >> 8) & 0xFF;
+        soap->z_buf[2] = (soap->z_crc >> 16) & 0xFF;
+        soap->z_buf[3] = (soap->z_crc >> 24) & 0xFF;
+        soap->z_buf[4] = soap->d_stream->total_in & 0xFF;
+        soap->z_buf[5] = (soap->d_stream->total_in >> 8) & 0xFF;
+        soap->z_buf[6] = (soap->d_stream->total_in >> 16) & 0xFF;
+        soap->z_buf[7] = (soap->d_stream->total_in >> 24) & 0xFF;
+        if (soap_flush_raw(soap, soap->z_buf, 8))
+          return soap->error;
+        DBGLOG(TEST, SOAP_MESSAGE(fdebug, "gzip crc32=%lu\n", (unsigned long)soap->z_crc));
+      }
 #endif
     }
@@ -4835 +6122 @@
     if ((soap->mode & SOAP_IO) == SOAP_IO_STORE)
     { char *p;
+#ifndef WITH_NOHTTP
       if (!(soap->mode & SOAP_ENC_XML))
       { soap->mode--;
@@ -4846 +6134 @@
         soap->mode++;
       }
-      for (p = soap_first_block(soap); p; p = soap_next_block(soap))
-      { DBGMSG(SENT, p, soap_block_size(soap));
-        if ((soap->error = soap->fsend(soap, p, soap_block_size(soap))))
-        { soap_end_block(soap);
+#endif
+      for (p = soap_first_block(soap, NULL); p; p = soap_next_block(soap, NULL))
+      { DBGMSG(SENT, p, soap_block_size(soap, NULL));
+        if ((soap->error = soap->fsend(soap, p, soap_block_size(soap, NULL))))
+        { soap_end_block(soap, NULL);
           return soap->error;
         }
       }
-      soap_end_block(soap);
-    }
+      soap_end_block(soap, NULL);
+    }
+#ifndef WITH_LEANER
     else if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK)
     { DBGMSG(SENT, "\r\n0\r\n\r\n", 7);
@@ -4860 +6150 @@
         return soap->error;
     }
-  }
+#endif
+  }
+#ifdef WITH_TCPFIN
 #ifdef WITH_OPENSSL
-  if (!soap->ssl && soap_valid_socket(soap->socket) && !soap->keep_alive)
-    soap->fshutdownsocket(soap, (SOAP_SOCKET)soap->socket, 1); /* Send TCP FIN */
+  if (!soap->ssl && soap_valid_socket(soap->socket) && !soap->keep_alive && !(soap->omode & SOAP_IO_UDP))
+    soap->fshutdownsocket(soap, soap->socket, 1); /* Send TCP FIN */
 #else
-  if (soap_valid_socket(soap->socket) && !soap->keep_alive)
-    soap->fshutdownsocket(soap, (SOAP_SOCKET)soap->socket, 1); /* Send TCP FIN */
-#endif
-  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End of send message ok\n"));
+  if (soap_valid_socket(soap->socket) && !soap->keep_alive && !(soap->omode & SOAP_IO_UDP))
+    soap->fshutdownsocket(soap, soap->socket, 1); /* Send TCP FIN */
+#endif
+#endif
+  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End of send phase\n"));
+  soap->omode &= ~SOAP_XML_SEC;
+  soap->count = 0;
   soap->part = SOAP_END;
-  soap->count = 0;
   return SOAP_OK;
 }
@@ -4883 +6177 @@
 { soap->part = SOAP_END;
 #ifndef WITH_LEANER
-  if ((soap->mode & SOAP_ENC_MIME) && soap_getmime(soap))
+  if ((soap->mode & SOAP_ENC_DIME) && soap_getdime(soap))
+  { soap->dime.first = NULL;
+    soap->dime.last = NULL;
     return soap->error;
+  }
+  soap->dime.list = soap->dime.first;
+  soap->dime.first = NULL;
+  soap->dime.last = NULL;
+  /* Check if MIME attachments and mime-post-check flag is set, if set call soap_resolve() and return */
+  if (soap->mode & SOAP_ENC_MIME)
+  { 
+#ifndef WITH_NOIDREF
+    if (soap->mode & SOAP_MIME_POSTCHECK)
+    { soap_resolve(soap);
+      return SOAP_OK;
+    }
+#endif
+    if (soap_getmime(soap))
+      return soap->error;
+  }
   soap->mime.list = soap->mime.first;
   soap->mime.first = NULL;
   soap->mime.last = NULL;
-  soap->dime.list = soap->dime.first;
-  soap->dime.first = NULL;
-  soap->dime.last = NULL;
+  soap->mime.boundary = NULL;
+  if (soap->xlist)
+  { struct soap_multipart *content;
+    for (content = soap->mime.list; content; content = content->next)
+      soap_resolve_attachment(soap, content);
+  }
 #endif
   DBGLOG(TEST,SOAP_MESSAGE(fdebug, "End of receive message ok\n"));
 #ifdef WITH_ZLIB
   if (soap->mode & SOAP_ENC_ZLIB)
-  { soap->mode &= ~SOAP_ENC_ZLIB;
+  { /* Make sure end of compressed content is reached */
+    while (soap->d_stream->next_out != Z_NULL)
+      if ((int)soap_get1(soap) == EOF)
+        break;
+    soap->mode &= ~SOAP_ENC_ZLIB;
     memcpy(soap->buf, soap->z_buf, SOAP_BUFLEN);
-    soap->bufidx = (char*)soap->d_stream.next_in - soap->z_buf;
+    soap->bufidx = (char*)soap->d_stream->next_in - soap->z_buf;
     soap->buflen = soap->z_buflen;
     soap->zlib_state = SOAP_ZLIB_NONE;
-    if (inflateEnd(&soap->d_stream) != Z_OK)
+    if (inflateEnd(soap->d_stream) != Z_OK)
       return soap->error = SOAP_ZLIB_ERROR;
+    DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Inflate end ok\n"));
 #ifdef WITH_GZIP
     if (soap->zlib_in == SOAP_ZLIB_GZIP)
     { soap_wchar c;
       short i;
+      DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Inflate gzip crc check\n"));
       for (i = 0; i < 8; i++)
-      { if ((int)(c = soap_getchar(soap)) == EOF)
+      { if ((int)(c = soap_get1(soap)) == EOF)
           return soap->error = SOAP_EOF;
         soap->z_buf[i] = (char)c;
@@ -4915 +6236 @@
         return soap->error = SOAP_ZLIB_ERROR;
       }
-      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)))
+      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)))
       { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Gzip error: incorrect message length\n"));
         return soap->error = SOAP_ZLIB_ERROR;
       }
     }
+    soap->zlib_in = SOAP_ZLIB_NONE;
 #endif
   }
@@ -4928 +6250 @@
   if (soap->fdisconnect && (soap->error = soap->fdisconnect(soap)))
     return soap->error;
-  return soap_resolve(soap);
+#ifndef WITH_NOIDREF
+  if (soap_resolve(soap))
+    return soap->error;
+#endif
+#ifndef WITH_LEANER
+  if (soap->xlist)
+  { if (soap->mode & SOAP_ENC_MTOM)
+      return soap->error = SOAP_MIME_HREF;
+    return soap->error = SOAP_DIME_HREF;
+  }
+#endif
+  soap_free_temp(soap);
+  return SOAP_OK;
 }
 #endif
@@ -4937 +6271 @@
 void
 SOAP_FMAC2
-soap_free(struct soap *soap)
-{ register struct soap_nlist *np;
-  register struct soap_attribute *tp;
+soap_free_temp(struct soap *soap)
+{ register struct soap_nlist *np, *nq;
+  register struct soap_attribute *tp, *tq;
   register struct Namespace *ns;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free namespace stack\n"));
-  while (soap->nlist)
-  { np = soap->nlist->next;
-    if (soap->nlist->ns)
-      SOAP_FREE(soap->nlist->ns);
-    SOAP_FREE(soap->nlist);
-    soap->nlist = np;
-  }
+  for (np = soap->nlist; np; np = nq)
+  { nq = np->next;
+    SOAP_FREE(soap, np);
+  }
+  soap->nlist = NULL;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free any remaining temp blocks\n"));
   while (soap->blist)
-    soap_end_block(soap);
-  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free attributes\n"));
-  while (soap->attributes)
-  { tp = soap->attributes->next;
-    if (soap->attributes->value)
-      SOAP_FREE(soap->attributes->value);
-    SOAP_FREE(soap->attributes);
-    soap->attributes = tp;
-  }
+    soap_end_block(soap, NULL);
+  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free attribute storage\n"));
+  for (tp = soap->attributes; tp; tp = tq)
+  { tq = tp->next;
+    if (tp->value)
+      SOAP_FREE(soap, tp->value);
+    SOAP_FREE(soap, tp);
+  }
+  soap->attributes = NULL;
 #ifdef WITH_FAST
   if (soap->labbuf)
-    SOAP_FREE(soap->labbuf);
+    SOAP_FREE(soap, soap->labbuf);
   soap->labbuf = NULL;
   soap->lablen = 0;
   soap->labidx = 0;
 #endif
-  soap_free_pht(soap);
-  soap_free_iht(soap);
   ns = soap->local_namespaces;
   if (ns)
   { for (; ns->id; ns++)
     { if (ns->out)
-      { SOAP_FREE(ns->out);
-        if (soap->encodingStyle == ns->out)
+      { if (soap->encodingStyle == ns->out)
           soap->encodingStyle = SOAP_STR_EOS;
+        SOAP_FREE(soap, ns->out);
         ns->out = NULL;
       }
@@ -4981 +6311 @@
         soap->encodingStyle = SOAP_STR_EOS;
     }
-    SOAP_FREE(soap->local_namespaces);
+    SOAP_FREE(soap, soap->local_namespaces);
     soap->local_namespaces = NULL;
   }
+#ifndef WITH_LEANER
+  while (soap->xlist)
+  { struct soap_xlist *xp = soap->xlist->next;
+    SOAP_FREE(soap, soap->xlist);
+    soap->xlist = xp;
+  }
+#endif
+#ifndef WITH_NOIDREF
+  soap_free_pht(soap);
+  soap_free_iht(soap);
+#endif
 }
 #endif
@@ -5037 +6378 @@
 static void
 soap_set_logfile(struct soap *soap, int i, const char *logfile)
-{ char *s = NULL;
+{ const char *s;
+  char *t = NULL;
   soap_close_logfile(soap, i);
-  if (soap->logfile[i])
-    SOAP_FREE((void*)soap->logfile[i]);
+  s = soap->logfile[i];
+  soap->logfile[i] = logfile;
+  if (s)
+    SOAP_FREE(soap, (void*)s);
   if (logfile)
-    if ((s = (char*)SOAP_MALLOC(strlen(logfile) + 1)))
-      strcpy(s, logfile);
-  soap->logfile[i] = s;
+    if ((t = (char*)SOAP_MALLOC(soap, strlen(logfile) + 1)))
+      strcpy(t, logfile);
+  soap->logfile[i] = t;
 }
 #endif
@@ -5083 +6427 @@
 struct soap*
 SOAP_FMAC2
-soap_copy(struct soap *soap)
-{ return soap_copy_context((struct soap*)SOAP_MALLOC(sizeof(struct soap)), soap);
+soap_copy(const struct soap *soap)
+{ return soap_copy_context((struct soap*)malloc(sizeof(struct soap)), soap);
 }
 #endif
@@ -5093 +6437 @@
 struct soap*
 SOAP_FMAC2
-soap_copy_context(struct soap *copy, struct soap *soap)
-{ if (copy)
-  { register struct soap_plugin *p;
+soap_copy_context(struct soap *copy, const struct soap *soap)
+{ if (soap_check_state(soap))
+    return NULL;
+  if (copy)
+  { register struct soap_plugin *p = NULL;
+#ifdef __cplusplus
+    *copy = *soap;
+#else
     memcpy(copy, soap, sizeof(struct soap));
-    copy->copy = 1;
-    copy->user = NULL;
+#endif
+    copy->state = SOAP_COPY;
+    copy->error = SOAP_OK;
     copy->userid = NULL;
     copy->passwd = NULL;
@@ -5106 +6456 @@
     copy->alist = NULL;
     copy->attributes = NULL;
+    copy->labbuf = NULL;
+    copy->lablen = 0;
+    copy->labidx = 0;
+#ifdef SOAP_MEM_DEBUG
+    soap_init_mht(copy);
+#endif
+#ifdef SOAP_DEBUG
+    soap_init_logs(copy);
+    soap_set_recv_logfile(copy, soap->logfile[SOAP_INDEX_RECV]);
+    soap_set_sent_logfile(copy, soap->logfile[SOAP_INDEX_SENT]);
+    soap_set_test_logfile(copy, soap->logfile[SOAP_INDEX_TEST]);
+#endif
+#ifdef WITH_C_LOCALE
+    copy->c_locale = duplocale(soap->c_locale);
+#else
+    copy->c_locale = NULL;
+#endif
+#ifdef WITH_OPENSSL
+    copy->bio = NULL;
+    copy->ssl = NULL;
+#endif
+#ifdef WITH_ZLIB
+    copy->d_stream = (z_stream*)SOAP_MALLOC(copy, sizeof(z_stream));
+    copy->d_stream->zalloc = Z_NULL;
+    copy->d_stream->zfree = Z_NULL;
+    copy->d_stream->opaque = Z_NULL;
+    copy->z_buf = NULL;
+#endif
     copy->local_namespaces = NULL;
-    soap_set_local_namespaces(copy);
+#ifndef WITH_NOIDREF
     soap_init_iht(copy);
     soap_init_pht(copy);
+#endif
     copy->header = NULL;
     copy->fault = NULL;
     copy->action = NULL;
-    *copy->host = '\0';
 #ifndef WITH_LEAN
 #ifdef WITH_COOKIES
-    copy->cookies = soap_copy_cookies(soap);
+    copy->cookies = soap_copy_cookies(copy, soap);
 #else
     copy->cookies = NULL;
 #endif
 #endif
-#ifdef SOAP_DEBUG
-    soap_init_logs(copy);
-    soap_set_recv_logfile(copy, "RECV.log");
-    soap_set_sent_logfile(copy, "SENT.log");
-    soap_set_test_logfile(copy, "TEST.log");
-#endif
     copy->plugins = NULL;
     for (p = soap->plugins; p; p = p->next)
-    { register struct soap_plugin *q = (struct soap_plugin*)SOAP_MALLOC(sizeof(struct soap_plugin));
+    { register struct soap_plugin *q = (struct soap_plugin*)SOAP_MALLOC(copy, sizeof(struct soap_plugin));
       if (!q)
         return NULL;
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying plugin '%s'\n", p->id));
       *q = *p;
-      if (p->fcopy && (soap->error = p->fcopy(soap, q, p)))
-      { SOAP_FREE(q);
+      if (p->fcopy && p->fcopy(copy, q, p))
+      { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not copy plugin '%s'\n", p->id));
+        SOAP_FREE(copy, q);
         return NULL;
       }
@@ -5142 +6515 @@
     }
   }
-  else
-    soap->error = SOAP_EOM;
   return copy;
 }
@@ -5153 +6524 @@
 void
 SOAP_FMAC2
+soap_copy_stream(struct soap *copy, struct soap *soap)
+{ copy->mode = soap->mode;
+  copy->imode = soap->imode;
+  copy->omode = soap->omode;
+  copy->socket = soap->socket;
+  copy->recv_timeout = soap->recv_timeout;
+  copy->send_timeout = soap->send_timeout;
+#if defined(__cplusplus) && !defined(WITH_LEAN)
+  copy->os = soap->os;
+  copy->is = soap->is;
+#endif
+  copy->sendfd = soap->sendfd;
+  copy->recvfd = soap->recvfd;
+  copy->bufidx = soap->bufidx;
+  copy->buflen = soap->buflen;
+  copy->ahead = soap->ahead;
+  copy->cdata = soap->cdata;
+  copy->chunksize = soap->chunksize;
+  copy->chunkbuflen = soap->chunkbuflen;
+  copy->keep_alive = soap->keep_alive;
+  copy->tcp_keep_alive = soap->tcp_keep_alive;
+  copy->tcp_keep_idle = soap->tcp_keep_idle;
+  copy->tcp_keep_intvl = soap->tcp_keep_intvl;
+  copy->tcp_keep_cnt = soap->tcp_keep_cnt;
+  copy->max_keep_alive = soap->max_keep_alive;
+#ifndef WITH_NOIO
+  copy->peer = soap->peer;
+  copy->peerlen = soap->peerlen;
+#endif
+#ifdef WITH_OPENSSL
+  copy->bio = soap->bio;
+  copy->ssl = soap->ssl;
+  copy->ctx = soap->ctx;
+#endif
+#ifdef WITH_ZLIB
+  copy->zlib_state = soap->zlib_state;
+  copy->zlib_in = soap->zlib_in;
+  copy->zlib_out = soap->zlib_out;
+  copy->d_stream = (z_stream*)SOAP_MALLOC(copy, sizeof(z_stream));
+  memcpy(copy->d_stream, soap->d_stream, sizeof(z_stream));
+  copy->z_crc = soap->z_crc;
+  copy->z_ratio_in = soap->z_ratio_in;
+  copy->z_ratio_out = soap->z_ratio_out;
+  copy->z_buf = NULL;
+  copy->z_buflen = soap->z_buflen;
+  copy->z_level = soap->z_level;
+  if (soap->z_buf && soap->zlib_state != SOAP_ZLIB_NONE)
+  { copy->z_buf = (char*)SOAP_MALLOC(copy, SOAP_BUFLEN);
+    memcpy(copy->z_buf, soap->z_buf, sizeof(soap->z_buf));
+  }
+#endif
+  memcpy(copy->buf, soap->buf, sizeof(soap->buf));
+}
+#endif
+
+/******************************************************************************/
+#ifndef PALM_1
+SOAP_FMAC1
+void
+SOAP_FMAC2
 soap_init(struct soap *soap)
-{ soap->version = 0;
+{ soap->state = SOAP_INIT;
+#ifdef SOAP_MEM_DEBUG
+  soap_init_mht(soap);
+#endif
+#ifdef SOAP_DEBUG
+  soap_init_logs(soap);
+  soap_set_recv_logfile(soap, "RECV.log");
+  soap_set_sent_logfile(soap, "SENT.log");
+  soap_set_test_logfile(soap, "TEST.log");
+  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Initializing context\n"));
+#endif
+  soap->version = 0;
   soap_imode(soap, SOAP_IO_DEFAULT);
   soap_omode(soap, SOAP_IO_DEFAULT);
-  soap->copy = 0;
   soap->plugins = NULL;
   soap->user = NULL;
   soap->userid = NULL;
   soap->passwd = NULL;
+#ifndef WITH_NOHTTP
   soap->fpost = http_post;
   soap->fget = http_get;
+  soap->fput = http_put;
+  soap->fdel = http_del;
+  soap->fhead = http_head;
+  soap->fform = NULL;
   soap->fposthdr = http_post_header;
   soap->fresponse = http_response;
   soap->fparse = http_parse;
   soap->fparsehdr = http_parse_header;
+#endif
+  soap->fheader = NULL;
   soap->fconnect = NULL;
   soap->fdisconnect = NULL;
-#ifndef MAC_CARBON
+#ifndef WITH_NOIO
+  soap->ipv6_multicast_if = 0;
+  soap->ipv4_multicast_if = NULL;
 #ifndef WITH_IPV6
   soap->fresolve = tcp_gethost;
@@ -5185 +6635 @@
   soap->fpoll = soap_poll;
 #else
+  soap->fopen = NULL;
+  soap->fclose = NULL;
   soap->fpoll = NULL;
 #endif
+  soap->fseterror = NULL;
+  soap->fignore = NULL;
+  soap->fserveloop = NULL;
+  soap->fplugin = fplugin;
+  soap->fmalloc = NULL;
+#ifndef WITH_LEANER
   soap->fprepareinit = NULL;
   soap->fpreparesend = NULL;
   soap->fpreparerecv = NULL;
-  soap->fignore = NULL;
-  soap->fserveloop = NULL;
-  soap->fplugin = fplugin;
+  soap->fpreparefinal = NULL;
   soap->fdimereadopen = NULL;
   soap->fdimewriteopen = NULL;
@@ -5199 +6655 @@
   soap->fdimeread = NULL;
   soap->fdimewrite = NULL;
-  soap->float_format = "%.8g"; /* .8 preserves single FP precision as much as possible, but might not be very efficient */
-  soap->double_format = "%.17lg"; /* .17 preserves double FP precision as much as possible, but might not be very efficient */
+  soap->fmimereadopen = NULL;
+  soap->fmimewriteopen = NULL;
+  soap->fmimereadclose = NULL;
+  soap->fmimewriteclose = NULL;
+  soap->fmimeread = NULL;
+  soap->fmimewrite = NULL;
+#endif
+  soap->float_format = "%.9G"; /* Alternative: use "%G" */
+  soap->double_format = "%.17lG"; /* Alternative: use "%lG" */
   soap->dime_id_format = "cid:id%d"; /* default DIME id format */
   soap->http_version = "1.1";
+  soap->proxy_http_version = "1.0";
+  soap->http_content = NULL;
   soap->actor = NULL;
+  soap->lang = "en";
+  soap->keep_alive = 0;
+  soap->tcp_keep_alive = 0;
+  soap->tcp_keep_idle = 0;
+  soap->tcp_keep_intvl = 0;
+  soap->tcp_keep_cnt = 0;
   soap->max_keep_alive = SOAP_MAXKEEPALIVE;
-  soap->keep_alive = 0;
   soap->recv_timeout = 0;
   soap->send_timeout = 0;
@@ -5214 +6684 @@
   soap->bind_flags = 0;
   soap->accept_flags = 0;
+  soap->linger_time = 0;
   soap->ip = 0;
   soap->labbuf = NULL;
@@ -5236 +6707 @@
   soap->os = NULL;
   soap->is = NULL;
+#ifndef WITH_LEANER
   soap->dom = NULL;
   soap->dime.list = NULL;
@@ -5245 +6717 @@
   soap->mime.boundary = NULL;
   soap->mime.start = NULL;
+  soap->xlist = NULL;
+#endif
 #ifndef UNDER_CE
   soap->recvfd = 0;
@@ -5261 +6735 @@
   soap->authrealm = NULL;
   soap->prolog = NULL;
+#ifdef WITH_ZLIB
+  soap->zlib_state = SOAP_ZLIB_NONE;
+  soap->zlib_in = SOAP_ZLIB_NONE;
+  soap->zlib_out = SOAP_ZLIB_NONE;
+  soap->d_stream = (z_stream*)SOAP_MALLOC(soap, sizeof(z_stream));
+  soap->d_stream->zalloc = Z_NULL;
+  soap->d_stream->zfree = Z_NULL;
+  soap->d_stream->opaque = Z_NULL;
+  soap->z_buf = NULL;
+  soap->z_level = 6;
+#endif
+#ifndef WITH_LEAN
+  soap->c14ninclude = NULL;
+  soap->c14nexclude = NULL;
+  soap->cookies = NULL;
+  soap->cookie_domain = NULL;
+  soap->cookie_path = NULL;
+  soap->cookie_max = 32;
+#endif
+#ifdef WMW_RPM_IO
+  soap->rpmreqid = NULL;
+#endif
+#ifdef PALM
+  palmNetLibOpen();
+#endif
+#ifndef WITH_NOIDREF
+  soap_init_iht(soap);
+  soap_init_pht(soap);
+#endif
 #ifdef WITH_OPENSSL
+  if (!soap_ssl_init_done)
+  { soap_ssl_init();
+    DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Initializing OpenSSL, version=%ld\n", (long)OPENSSL_VERSION_NUMBER));
+  }
   soap->fsslauth = ssl_auth_init;
   soap->fsslverify = ssl_verify_callback;
@@ -5267 +6774 @@
   soap->ssl = NULL;
   soap->ctx = NULL;
-  soap->require_server_auth = 0;
-  soap->require_client_auth = 0;
-  soap->rsa = 0;
+  soap->ssl_flags = SOAP_SSL_DEFAULT;
   soap->keyfile = NULL;
   soap->password = NULL;
@@ -5275 +6780 @@
   soap->cafile = NULL;
   soap->capath = NULL;
+  soap->crlfile = NULL;
   soap->randfile = NULL;
   soap->session = NULL;
 #endif
-#ifdef WITH_ZLIB
-  soap->zlib_state = SOAP_ZLIB_NONE;
-  soap->zlib_in = SOAP_ZLIB_NONE;
-  soap->zlib_out = SOAP_ZLIB_NONE;
-  soap->d_stream.zalloc = NULL;
-  soap->d_stream.zfree = NULL;
-  soap->d_stream.opaque = NULL;
-  soap->z_level = 6;
-#endif
-#ifndef WITH_LEAN
-  soap->cookies = NULL;
-  soap->cookie_domain = NULL;
-  soap->cookie_path = NULL;
-  soap->cookie_max = 32;
-#endif
-#ifdef SOAP_DEBUG
-  soap_init_logs(soap);
-  soap_set_recv_logfile(soap, "RECV.log");
-  soap_set_sent_logfile(soap, "SENT.log");
-  soap_set_test_logfile(soap, NULL);
-#endif
-/* WR[ */
-#ifdef WMW_RPM_IO
-  soap->rpmreqid = NULL;
-#endif /* WMW_RPM_IO */
-/* ]WR */
-#ifdef PALM
-  palmNetLibOpen();
-#endif
-  soap_init_iht(soap);
-  soap_init_pht(soap);
+#ifdef WITH_C_LOCALE
+  soap->c_locale = newlocale(LC_ALL_MASK, "C", NULL);
+#else
+  soap->c_locale = NULL;
+#endif
   soap_begin(soap);
-#ifdef SOAP_DEBUG
-  soap_set_test_logfile(soap, "TEST.log");
-#endif
 }
 #endif
@@ -5321 +6798 @@
 void
 SOAP_FMAC2
-soap_init1(struct soap *soap, int mode)
+soap_init1(struct soap *soap, soap_mode mode)
 { soap_init2(soap, mode, mode);
 }
@@ -5331 +6808 @@
 void
 SOAP_FMAC2
-soap_init2(struct soap *soap, int imode, int omode)
+soap_init2(struct soap *soap, soap_mode imode, soap_mode omode)
 { soap_init(soap);
   soap_imode(soap, imode);
@@ -5344 +6821 @@
 SOAP_FMAC2
 soap_begin(struct soap *soap)
-{ DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Initializing\n"));
+{ DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Reinitializing context\n"));
   if (!soap->keep_alive)
   { soap->buflen = 0;
@@ -5356 +6833 @@
   soap->mode = 0;
   soap->ns = 0;
-  soap->part = SOAP_BEGIN;
+  soap->part = SOAP_END;
   soap->alloced = 0;
   soap->count = 0;
@@ -5367 +6844 @@
   soap->level = 0;
   soap->endpoint[0] = '\0';
+#ifndef WITH_LEANER
   soap->dime.chunksize = 0;
   soap->dime.buflen = 0;
-  soap_free(soap);
+#endif
+  soap_free_temp(soap);
 }
 #endif
@@ -5379 +6858 @@
 SOAP_FMAC2
 soap_end(struct soap *soap)
-{ register struct soap_clist *cp;
-  soap_free(soap);
+{ if (soap_check_state(soap))
+    return;
+  soap_free_temp(soap);
   soap_dealloc(soap, NULL);
   while (soap->clist)
-  { cp = soap->clist->next;
-    SOAP_FREE(soap->clist);
+  { register struct soap_clist *cp = soap->clist->next;
+    SOAP_FREE(soap, soap->clist);
     soap->clist = cp;
   }
@@ -5402 +6882 @@
 int
 SOAP_FMAC2
-soap_set_namespaces(struct soap *soap, struct Namespace *p)
-{ struct Namespace *ns = soap->local_namespaces;
-  struct soap_nlist *np, *nq, *nr;
-  unsigned int level = soap->level;
+soap_set_namespaces(struct soap *soap, const struct Namespace *p)
+{ register struct Namespace *ns = soap->local_namespaces;
+  register struct soap_nlist *np, *nq, *nr;
+  register unsigned int level = soap->level;
   soap->namespaces = p;
   soap->local_namespaces = NULL;
   soap_set_local_namespaces(soap);
-  /* reverse the list */
+  /* reverse the namespace list */
   np = soap->nlist;
   soap->nlist = NULL;
@@ -5422 +6902 @@
     }
   }
+  /* then push on new stack */
   while (np)
-  { soap->level = np->level; /* preserve element nesting level */
-    if (np->ns)
-    { if (soap_push_namespace(soap, np->id, np->ns))
-        return soap->error;
-    }
-    else if (np->index >= 0 && ns)
-    { if (ns[np->index].out)
-      { if (soap_push_namespace(soap, np->id, ns[np->index].out))
-          return soap->error;
-      }
-      else if (soap_push_namespace(soap, np->id, ns[np->index].ns))
-        return soap->error;
-    }
-    if (np->ns)
-      SOAP_FREE(np->ns);
+  { register const char *s;
+    soap->level = np->level; /* preserve element nesting level */
+    s = np->ns;
+    if (!s && np->index >= 0 && ns)
+    { s = ns[np->index].out;
+      if (!s)
+        s = ns[np->index].ns;
+    }
+    if (s && soap_push_namespace(soap, np->id, s))
+      return soap->error;
     nq = np;
     np = np->next;
-    SOAP_FREE(nq);
+    SOAP_FREE(soap, nq);
   }
   if (ns)
-  { int i;
+  { register int i;
     for (i = 0; ns[i].id; i++)
     { if (ns[i].out)
-      { SOAP_FREE(ns[i].out);
+      { SOAP_FREE(soap, ns[i].out);
         ns[i].out = NULL;
       }
     }
-    SOAP_FREE(ns);
+    SOAP_FREE(soap, ns);
   }
   soap->level = level; /* restore level */
@@ -5459 +6935 @@
 /******************************************************************************/
 #ifndef PALM_1
-static void
+SOAP_FMAC1
+void
+SOAP_FMAC2
 soap_set_local_namespaces(struct soap *soap)
 { if (soap->namespaces && !soap->local_namespaces)
@@ -5467 +6945 @@
     for (ns1 = soap->namespaces; ns1->id; ns1++)
       n++;
-    if (n > 3)
-    { n *= sizeof(struct Namespace);
-      ns2 = (struct Namespace*)SOAP_MALLOC(n);
-      if (ns2)
-      { memcpy(ns2, soap->namespaces, n);
-        ns2[0].id = "SOAP-ENV";
-        ns2[1].id = "SOAP-ENC";
-        ns2[2].id = "xsi";
-        if (ns2[0].ns)
-        { if (!strcmp(ns2[0].ns, soap_env1))
-            soap->version = 1;
-          else
-            soap->version = 2;
-        }
-        soap->local_namespaces = ns2;
-      }
-    }
-  }
+    n *= sizeof(struct Namespace);
+    ns2 = (struct Namespace*)SOAP_MALLOC(soap, n);
+    if (ns2)
+    { memcpy(ns2, soap->namespaces, n);
+      if (ns2[0].ns)
+      { if (!strcmp(ns2[0].ns, soap_env1))
+          soap->version = 1;
+        else
+          soap->version = 2;
+      }
+      soap->local_namespaces = ns2;
+    }
+  }
+}
+#endif
+
+/******************************************************************************/
+#ifndef WITH_LEAN
+#ifndef PALM_1
+SOAP_FMAC1
+const char *
+SOAP_FMAC2
+soap_strsearch(const char *big, const char *little)
+{ size_t n = strlen(little);
+  const char *s = big;
+  while (s) 
+  { if (!strncmp(s, little, n) && (s[n] == '\0' || s[n] == ' '))
+      return s;
+    s = strchr(s, ' ');
+    if (s)
+      s++;
+  }
+  return NULL;
+}
+#endif
+#endif
+
+/******************************************************************************/
+#ifndef WITH_LEAN
+#ifndef PALM_1
+SOAP_FMAC1
+struct soap_nlist *
+SOAP_FMAC2
+soap_lookup_ns(struct soap *soap, const char *tag, size_t n)
+{ register struct soap_nlist *np;
+  for (np = soap->nlist; np; np = np->next)
+  { if (!strncmp(np->id, tag, n) && !np->id[n])
+      return np;
+  }
+  return NULL;
+}
+#endif
+#endif
+
+/******************************************************************************/
+#ifndef WITH_LEAN
+static struct soap_nlist *
+soap_push_ns(struct soap *soap, const char *id, const char *ns, short utilized)
+{ register struct soap_nlist *np;
+  size_t n, k;
+  if (soap_strsearch(soap->c14nexclude, id))
+    return NULL;
+  if (!utilized)
+  { for (np = soap->nlist; np; np = np->next)
+    { if (!strcmp(np->id, id) && (!np->ns || !strcmp(np->ns, ns)))
+        break;
+    }
+    if (np)
+    { if ((np->level < soap->level || !np->ns) && np->index == 1)
+        utilized = 1;
+      else
+        return NULL;
+    }
+  }
+  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Adding namespace binding (level=%u) '%s' '%s' utilized=%d\n", soap->level, id, ns?ns:"(null)", utilized));
+  n = strlen(id);
+  if (ns)
+    k = strlen(ns);
+  else
+    k = 0;
+  np = (struct soap_nlist*)SOAP_MALLOC(soap, sizeof(struct soap_nlist) + n + k + 1);
+  if (!np)
+  { soap->error = SOAP_EOM;
+    return NULL;
+  }
+  np->next = soap->nlist;
+  soap->nlist = np;
+  strcpy(np->id, id);
+  if (ns)
+  { np->ns = np->id + n + 1;
+    strcpy(np->ns, ns);
+  }
+  else
+    np->ns = NULL;
+  np->level = soap->level;
+  np->index = utilized;
+  return np;
+}
+#endif
+
+/******************************************************************************/
+#ifndef WITH_LEAN
+static void
+soap_utilize_ns(struct soap *soap, const char *tag, size_t n)
+{ register struct soap_nlist *np = soap_lookup_ns(soap, tag, n);
+  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Utilizing namespace of '%s'\n", tag));
+  if (np)
+  { if (np->index == 0)
+      soap_push_ns(soap, np->id, np->ns, 1);
+  }
+  else if (strncmp(tag, "xml", 3))
+  { strncpy(soap->tmpbuf, tag, n);
+    soap->tmpbuf[n] = '\0';
+    soap_push_ns(soap, soap->tmpbuf, NULL, 1);
+  }
+}
+#endif
+
+/******************************************************************************/
+#ifndef WITH_LEAN
+static void
+soap_pop_ns(struct soap *soap)
+{ soap_pop_namespace(soap);
 }
 #endif
@@ -5494 +7077 @@
 SOAP_FMAC2
 soap_element(struct soap *soap, const char *tag, int id, const char *type)
-{ struct Namespace *ns = soap->local_namespaces;
-  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Element begin tag='%s' id='%d' type='%s'\n", tag, id, type?type:""));
-/**/
+{
+#ifdef WITH_XMLNS
+  register const char *s;
+#endif
+  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Element begin tag='%s' id='%d' type='%s'\n", tag, id, type?type:SOAP_STR_EOS));
 #ifdef WITH_DOM
+  if (soap->part == SOAP_BEGIN_SECURITY && (soap->mode & SOAP_XML_CANONICAL) && !(soap->mode & SOAP_DOM_ASIS))
+  { register struct soap_nlist *np;
+    /* wsu:Id found: clear xmlns renderings, so re-emit them for exc-c14n */
+    for (np = soap->nlist; np; np = np->next)
+    { if (np->index == 2)
+        np->index = 0;
+    }
+  }
   if (soap->mode & SOAP_XML_DOM)
-  { register struct soap_dom_element *p, *e = (struct soap_dom_element*)soap_malloc(soap, sizeof(struct soap_dom_element));
-    e->next = NULL;
-    e->prnt = soap->dom;
-    e->nstr = NULL;
-    e->name = soap_strdup(soap, tag); /* check EOM? */
-    e->data = NULL;
-    e->type = 0;
-    e->node = NULL;
-    e->elts = NULL;
-    e->atts = NULL;
+  { register struct soap_dom_element *elt = (struct soap_dom_element*)soap_malloc(soap, sizeof(struct soap_dom_element));
+    if (!elt)
+      return soap->error;
+    elt->soap = soap;
+    elt->next = NULL;
+    elt->prnt = soap->dom;
+    elt->name = soap_strdup(soap, tag);
+    elt->elts = NULL;
+    elt->atts = NULL;
+    elt->nstr = NULL;
+    elt->data = NULL;
+    elt->wide = NULL;
+    elt->node = NULL;
+    elt->type = 0;
+    elt->head = NULL;
+    elt->tail = NULL;
     if (soap->dom)
-    { p = soap->dom->elts;
+    { struct soap_dom_element *p = soap->dom->elts;
       if (p)
       { while (p->next)
           p = p->next;
-        p->next = e;
+        p->next = elt;
       }
       else
-        soap->dom->elts = e;
-    }
-    soap->dom = e;
+        soap->dom->elts = elt;
+    }
+    soap->dom = elt;
   }
   else
-#endif
-{
-  soap->level++;
-  if (!soap->ns && !(soap->mode & SOAP_XML_CANONICAL))
-    if (soap_send(soap, soap->prolog ? soap->prolog : "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"))
+  {
+#endif
+    soap->level++;
+#ifndef WITH_LEAN
+    if (!soap->ns)
+    { if (!(soap->mode & SOAP_XML_CANONICAL)
+       && soap_send(soap, soap->prolog ? soap->prolog : "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"))
+        return soap->error;
+    }
+    else if (soap->mode & SOAP_XML_INDENT)
+    { if (soap->ns == 1 && soap_send_raw(soap, soap_indent, soap->level < sizeof(soap_indent) ? soap->level : sizeof(soap_indent) - 1))
+        return soap->error;
+      soap->body = 1;
+    }
+#endif
+#ifdef WITH_XMLNS
+    s = strchr(tag, ':');
+    if (s && strncmp(tag, "SOAP-ENV", s - tag))
+    { struct Namespace *ns = soap->local_namespaces;
+      size_t n = s - tag;
+      if (soap_send_raw(soap, "<", 1)
+       || soap_send(soap, s + 1))
+        return soap->error;
+      if (soap->nlist && !strncmp(soap->nlist->id, tag, n) && !soap->nlist->id[n])
+        ns = NULL;
+      for (; ns && ns->id; ns++)
+      { if (*ns->id && (ns->out || ns->ns) && !strncmp(ns->id, tag, n) && !ns->id[n])
+        { soap_push_ns(soap, ns->id, ns->out ? ns->out : ns->ns, 0);
+          if (soap_attribute(soap, "xmlns", ns->out ? ns->out : ns->ns))
+            return soap->error;
+          break;
+        }
+      }   
+    }
+    else
+#endif
+    if (soap_send_raw(soap, "<", 1)
+     || soap_send(soap, tag))
       return soap->error;
-  if (soap_send_raw(soap, "<", 1)
-   || soap_send(soap, tag))
-    return soap->error;
-}
-/**/
+#ifdef WITH_DOM
+  }
+#endif
   if (!soap->ns)
-  { for (ns = soap->local_namespaces; ns && ns->id; ns++)
+  { struct Namespace *ns;
+    for (ns = soap->local_namespaces; ns && ns->id; ns++)
     { if (*ns->id && (ns->out || ns->ns))
       { sprintf(soap->tmpbuf, "xmlns:%s", ns->id);
@@ -5541 +7172 @@
       }
     }   
-    soap->ns = 1;
-  }
+  }
+  soap->ns = 1; /* namespace table control: ns = 0 or 2 to start, then 1 to stop dumping the table  */
+#ifndef WITH_LEAN
+  if (soap->mode & SOAP_XML_CANONICAL)
+  { const char *t = strchr(tag, ':');
+    if (t)
+      soap_utilize_ns(soap, tag, t - tag);
+  }
+#endif
   if (id > 0)
   { sprintf(soap->tmpbuf, "_%d", id);
@@ -5548 +7186 @@
       return soap->error;
   }
-  if (type && *type)
+  if (type && *type && (!(soap->mode & SOAP_XML_SEC) || soap->part == SOAP_IN_BODY))
   { if (soap_attribute(soap, "xsi:type", type))
       return soap->error;
+#ifndef WITH_LEAN
+    if (soap->mode & SOAP_XML_CANONICAL)
+    { const char *t = strchr(type, ':');
+      if (t)
+        soap_utilize_ns(soap, type, t - type);
+    }
+#endif
   }
   if (soap->null && soap->position > 0)
-  { int i;
+  { register int i;
     sprintf(soap->tmpbuf, "[%d", soap->positions[0]);
     for (i = 1; i < soap->position; i++)
@@ -5585 +7230 @@
   soap->null = 0;
   soap->position = 0;
+  if (soap->part == SOAP_BEGIN_SECURITY && (soap->mode & SOAP_XML_CANONICAL))
+    soap->part = SOAP_IN_SECURITY;
   return SOAP_OK;
 }
@@ -5639 +7286 @@
       s++;
     while ((c = *s) && c >= '0' && c <= '9')
-    { if (n > 214748364)
+    { if (n >= 214748364 && (n > 214748364 || c >= '8'))
         break;
       n *= 10;
@@ -5685 +7332 @@
       s++;
     while ((c = *s) && c >= '0' && c <= '9')
-    { if (n > 429496729)
+    { if (n >= 429496729 && (n > 429496729 || c >= '6'))
         break;
       n *= 10;
@@ -5740 +7387 @@
       return soap->error;
   }
+#ifndef WITH_LEAN
+  if (type && *type && (soap->mode & SOAP_XML_CANONICAL))
+  { const char *s = strchr(type, ':');
+    if (s)
+      soap_utilize_ns(soap, type, s - type);
+  }
+#endif
   return soap_element_start_end_out(soap, NULL);
 }
@@ -5751 +7405 @@
 soap_element_start_end_out(struct soap *soap, const char *tag)
 { register struct soap_attribute *tp;
-/**/
+#ifndef WITH_LEAN
+  if (soap->mode & SOAP_XML_CANONICAL)
+  { struct soap_nlist *np;
+    for (tp = soap->attributes; tp; tp = tp->next)
+    { if (tp->visible && tp->name)
+      { const char *s = strchr(tp->name, ':');
+        if (s)
+          soap_utilize_ns(soap, tp->name, s - tp->name);
+      }
+    }
+    for (np = soap->nlist; np; np = np->next)
+    { if (np->index == 1 && np->ns)
+      { sprintf(soap->tmpbuf, "xmlns:%s", np->id);
+        DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Enabling utilized binding (level=%u) %s='%s'\n", np->level, soap->tmpbuf, np->ns));
+        soap_set_attr(soap, soap->tmpbuf, np->ns);
+        np->index = 2;
+      }
+    }
+  }
+#endif
 #ifdef WITH_DOM
   if ((soap->mode & SOAP_XML_DOM) && soap->dom)
-  { for (tp = soap->attributes; tp; tp = tp->next)
+  { register struct soap_dom_attribute **att;
+    att = &soap->dom->atts;
+    for (tp = soap->attributes; tp; tp = tp->next)
     { if (tp->visible)
-      { register struct soap_dom_attribute *a = (struct soap_dom_attribute*)soap_malloc(soap, sizeof(struct soap_dom_attribute));
-        a->next = soap->dom->atts;
-        a->nstr = NULL;
-        a->name = soap_strdup(soap, tp->name); /* check EOM */
-        a->data = soap_strdup(soap, tp->value); /* check EOM */
-        a->wide = NULL;
-        soap->dom->atts = a;
+      { *att = (struct soap_dom_attribute*)soap_malloc(soap, sizeof(struct soap_dom_attribute));
+        if (!*att)
+          return soap->error;
+        (*att)->next = NULL;
+        (*att)->nstr = NULL;
+        (*att)->name = soap_strdup(soap, tp->name);
+        (*att)->data = soap_strdup(soap, tp->value);
+        (*att)->wide = NULL;
+        (*att)->soap = soap;
+        att = &(*att)->next;
         tp->visible = 0;
       }
@@ -5769 +7447 @@
   }
 #endif
-/**/
   for (tp = soap->attributes; tp; tp = tp->next)
   { if (tp->visible)
-    { if (soap_send2(soap, " ", tp->name))
+    {
+#ifdef WITH_XMLNS
+      const char *s = strchr(tp->name, ':');
+      if (s)
+      { size_t n = s - tp->name;
+        if (soap->nlist && !strncmp(soap->nlist->id, tp->name, n) && !soap->nlist->id[n])
+          s++;
+        else
+          s = tp->name;
+        if (soap_send(soap, " ") || soap_send(soap, s))
+          return soap->error;
+      }
+      else
+#endif
+      if (soap_send(soap, " ") || soap_send(soap, tp->name))
         return soap->error;
       if (tp->visible == 2 && tp->value)
         if (soap_send_raw(soap, "=\"", 2)
-         || soap_string_out(soap, tp->value, 1)
-         || soap_send_raw(soap, "\"", 1))
+         || soap_string_out(soap, tp->value, 1)
+         || soap_send_raw(soap, "\"", 1))
           return soap->error;
       tp->visible = 0;
@@ -5783 +7474 @@
   }
   if (tag)
-  { soap->level--;
+  { 
 #ifndef WITH_LEAN
     if (soap->mode & SOAP_XML_CANONICAL)
@@ -5792 +7483 @@
     }
 #endif
-    return soap_send_raw(soap, "/>", 2);
+    soap->level--;      /* decrement level just before /> */
+    if (soap_send_raw(soap, "/>", 2))
+      return soap->error;
+    return SOAP_OK;
   }
   return soap_send_raw(soap, ">", 1);
@@ -5807 +7501 @@
     return SOAP_OK;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Element ending tag='%s'\n", tag));
-/**/
 #ifdef WITH_DOM
   if ((soap->mode & SOAP_XML_DOM) && soap->dom)
@@ -5815 +7508 @@
   }
 #endif
-/**/
-  soap->level--;
+#ifndef WITH_LEAN
+  if (soap->mode & SOAP_XML_CANONICAL)
+    soap_pop_ns(soap);
+  if (soap->mode & SOAP_XML_INDENT)
+  { if (!soap->body)
+    { if (soap_send_raw(soap, soap_indent, soap->level < sizeof(soap_indent) ? soap->level : sizeof(soap_indent) - 1))
+        return soap->error;
+    }
+    soap->body = 0;
+  }
+#endif
+#ifdef WITH_XMLNS
+  { const char *s = strchr(tag, ':');
+    if (s && strncmp(tag, "SOAP-ENV", s - tag))
+    { soap_pop_ns(soap);
+      tag = s + 1;
+    }
+  }
+#endif
   if (soap_send_raw(soap, "</", 2)
    || soap_send(soap, tag))
     return soap->error;
+  soap->level--;        /* decrement level just before > */
   return soap_send_raw(soap, ">", 1);
 }
@@ -5831 +7542 @@
 soap_element_ref(struct soap *soap, const char *tag, int id, int href)
 { register int n = 0;
+  const char *s = "href";
   if (soap->version == 2)
+  { s = "SOAP-ENC:ref";
     n = 1;
+  }
   sprintf(soap->href, "#_%d", href);
-  return soap_element_href(soap, tag, id, "href" + n, soap->href + n);
+  return soap_element_href(soap, tag, id, s, soap->href + n);
 }
 #endif
@@ -5866 +7580 @@
   { if (soap_element(soap, tag, id, type))
       return soap->error;
-    if (soap->part != SOAP_IN_HEADER && soap->encodingStyle)
-      if (soap_attribute(soap, "xsi:nil", "true"))
-        return soap->error;
+    if (!tp && soap_attribute(soap, "xsi:nil", "true"))
+      return soap->error;
     return soap_element_start_end_out(soap, tag);
   }
@@ -5884 +7597 @@
 SOAP_FMAC2
 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) 
-{ struct soap_plist *pp;
-  if (!p || (a && !a->__ptr))
+{ if (!p || (a && !a->__ptr))
   { soap_element_null(soap, tag, id, type);
     return -1;
   }
+#ifndef WITH_NOIDREF
   if (soap->mode & SOAP_XML_TREE)
     return 0;
   if (id < 0)
-  { if (a)
+  { struct soap_plist *pp;
+    if (a)
       id = soap_array_pointer_lookup(soap, p, a, n, t, &pp);
     else
@@ -5907 +7621 @@
   }
   return id;
+#else
+  return 0;
+#endif
 }
 #endif
@@ -5917 +7634 @@
 soap_element_result(struct soap *soap, const char *tag)
 { if (soap->version == 2 && soap->encodingStyle)
-    if (soap_element(soap, "SOAP-RPC:result", 0, NULL)
+  { if (soap_element(soap, "SOAP-RPC:result", 0, NULL)
      || soap_attribute(soap, "xmlns:SOAP-RPC", soap_rpc)
      || soap_element_start_end_out(soap, NULL)
@@ -5923 +7640 @@
      || soap_element_end_out(soap, "SOAP-RPC:result"))
       return soap->error;
+  }
   return SOAP_OK;
+}
+#endif
+
+/******************************************************************************/
+#ifndef PALM_1
+SOAP_FMAC1
+void
+SOAP_FMAC2
+soap_check_result(struct soap *soap, const char *tag)
+{ if (soap->version == 2 && soap->encodingStyle)
+  { soap_instring(soap, ":result", NULL, NULL, 0, 2, -1, -1);
+    /* just ignore content for compliance reasons, but should compare tag to element's QName value? */
+  }
 }
 #endif
@@ -5934 +7665 @@
 soap_attribute(struct soap *soap, const char *name, const char *value)
 { 
-/**/
 #ifdef WITH_DOM
-  if ((soap->mode & SOAP_XML_DOM) && soap->dom)
+  if ((soap->mode & SOAP_XML_DOM) && !(soap->mode & SOAP_XML_CANONICAL) && soap->dom)
   { register struct soap_dom_attribute *a = (struct soap_dom_attribute*)soap_malloc(soap, sizeof(struct soap_dom_attribute));
+    if (!a)
+      return soap->error;
     a->next = soap->dom->atts;
     a->nstr = NULL;
-    a->name = soap_strdup(soap, name); /* check EOM */
-    a->data = soap_strdup(soap, value); /* check EOM */
+    a->name = soap_strdup(soap, name);
+    a->data = soap_strdup(soap, value);
     a->wide = NULL;
+    a->soap = soap;
     soap->dom->atts = a;
     return SOAP_OK;
   }
 #endif
-/**/
 #ifndef WITH_LEAN
   if (soap->mode & SOAP_XML_CANONICAL)
-  { if (soap_set_attr(soap, name, value))
+  { /* TODO: consider using this code to handle default namespace bindings
+    if (!strncmp(name, "xmlns", 5) && (name[5] == ':' || name[5] == '\0'))
+    { if (name[5] == ':')
+        soap_push_ns(soap, name + 6, value, 0);
+      else
+        soap_push_ns(soap, "", value, 0);
+    }
+    */
+    if (!strncmp(name, "xmlns:", 6))
+      soap_push_ns(soap, name + 6, value, 0);
+    else if (soap_set_attr(soap, name, value))
       return soap->error;
   }
   else
 #endif
-  { if (soap_send2(soap, " ", name))
+  { if (soap_send(soap, " ") || soap_send(soap, name))
       return soap->error;
     if (value)
@@ -5972 +7714 @@
 int
 SOAP_FMAC2
-soap_element_begin_in(struct soap *soap, const char *tag, int nillable)
+soap_element_begin_in(struct soap *soap, const char *tag, int nillable, const char *type)
 { if (!soap_peek_element(soap))
   { if (soap->other)
@@ -5980 +7722 @@
     if (!(soap->error = soap_match_tag(soap, soap->tag, tag)))
     { soap->peeked = 0;
+      if (type && *soap->type && soap_match_tag(soap, soap->type, type))
+        return soap->error = SOAP_TYPE;
+      if (!nillable && soap->null && (soap->mode & SOAP_XML_STRICT))
+        return soap->error = SOAP_NULL;
       if (soap->body)
         soap->level++;
-      DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Begin element found (level=%u) '%s'='%s'\n", soap->level, soap->tag, tag?tag:"" ));
-      if (!nillable && soap->null && (soap->mode & SOAP_XML_STRICT))
-        return soap->error = SOAP_NULL;
-    }
-  }
+      DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Begin element found (level=%u) '%s'='%s'\n", soap->level, soap->tag, tag?tag:SOAP_STR_EOS ));
+    }
+  }
+  else if (soap->error == SOAP_NO_TAG && tag && *tag == '-')
+    soap->error = SOAP_OK;
   return soap->error;
 }
@@ -5999 +7745 @@
 { register soap_wchar c;
   register char *s;
-  register const char *t;
+  register int n = 0;
   if (tag && *tag == '-')
     return SOAP_OK;
-  soap->level--;
-  soap_pop_namespace(soap);
+  if (soap->error == SOAP_NO_TAG)
+    soap->error = SOAP_OK;
+#ifdef WITH_DOM
+  /* this whitespace or mixed content is not insignificant for DOM */
+  if ((soap->mode & SOAP_XML_DOM) && soap->dom)
+  { if (!soap->peeked && !soap_string_in(soap, 3, -1, -1))
+      return soap->error;
+    if (soap->dom->prnt)
+      soap->dom = soap->dom->prnt;
+  }
+#endif
   if (soap->peeked)
-  { if (*soap->tag == '\0')
-    { soap->peeked = 0;
-      if (soap->error == SOAP_NO_TAG || soap->error == SOAP_TAG_END)
-        soap->error = SOAP_OK;
-    }
-    else
-      return soap->error = SOAP_TAG_END;
-  }
-  else
+  { if (*soap->tag)
+      n++;
+    soap->peeked = 0;
+  }
+  do
   { while (((c = soap_get(soap)) != SOAP_TT))
     { if ((int)c == EOF)
         return soap->error = SOAP_EOF;
       if (c == SOAP_LT)
-        return soap->error = SOAP_TAG_END;
-    }
-  }
+        n++;
+      else if (c == '/')
+      { c = soap_get(soap);
+        if (c == SOAP_GT)
+          n--;
+        else
+          soap_unget(soap, c);
+      }
+    }
+  } while (n--);
   s = soap->tag;
-  do c = soap_get(soap);
-  while (soap_blank(c));
-  do
-  { *s++ = (char)c;
-    c = soap_get(soap);
-  } while (soap_notblank(c));
+  n = sizeof(soap->tag);
+  while (soap_notblank(c = soap_get(soap)))
+  { if (--n > 0)
+      *s++ = (char)c;
+  }
   *s = '\0';
   if ((int)c == EOF)
@@ -6035 +7792 @@
   if (c != SOAP_GT)
     return soap->error = SOAP_SYNTAX_ERROR;
-  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End element found (level=%u) '%s'='%s'\n", soap->level, soap->tag, tag?tag:""));
-  if (!tag)
-    return SOAP_OK;
-  if ((s = strchr(soap->tag, ':')))
-    s++;
-  else
-    s = soap->tag;
-  if ((t = strchr(tag, ':')))
-    t++;
-  else
-    t = tag;
-  if (!SOAP_STRCMP(s, t))
-    return SOAP_OK;
-  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End element tag name does not match\n"));
-  return soap->error = SOAP_SYNTAX_ERROR;
+  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End element found (level=%u) '%s'='%s'\n", soap->level, soap->tag, tag?tag:SOAP_STR_EOS));
+#ifndef WITH_LEAN
+  if (tag && (soap->mode & SOAP_XML_STRICT))
+  { soap_pop_namespace(soap);
+    if (soap_match_tag(soap, soap->tag, tag))
+    { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End element tag name does not match\n"));
+      return soap->error = SOAP_SYNTAX_ERROR;
+    }
+  }
+#endif
+  soap->level--;
+  return SOAP_OK;
 }
 #endif
@@ -6060 +7814 @@
 soap_attr_value(struct soap *soap, const char *name, int flag)
 { register struct soap_attribute *tp;
+  if (*name == '-')
+    return SOAP_STR_EOS;
   for (tp = soap->attributes; tp; tp = tp->next)
-    if (!soap_match_tag(soap, tp->name, name))
+  { if (tp->visible && !soap_match_tag(soap, tp->name, name))
       break;
-  if (tp && tp->visible == 2)
+  }
+  if (tp)
   { if (flag == 2 && (soap->mode & SOAP_XML_STRICT))
       soap->error = SOAP_PROHIBITED;
@@ -6082 +7839 @@
 soap_set_attr(struct soap *soap, const char *name, const char *value)
 { register struct soap_attribute *tp;
-  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Set attribute %s='%s'\n", name, value?value:""));
+  if (*name == '-')
+    return SOAP_OK;
+  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Set attribute %s='%s'\n", name, value?value:SOAP_STR_EOS));
   for (tp = soap->attributes; tp; tp = tp->next)
-    if (!strcmp(tp->name, name))
+  { if (!strcmp(tp->name, name))
       break;
+  }
   if (!tp)
   { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Allocate attribute %s\n", name));
-    if (!(tp = (struct soap_attribute*)SOAP_MALLOC(sizeof(struct soap_attribute) + strlen(name))))
+    if (!(tp = (struct soap_attribute*)SOAP_MALLOC(soap, sizeof(struct soap_attribute) + strlen(name))))
       return soap->error = SOAP_EOM;
     tp->ns = NULL;
@@ -6095 +7855 @@
     { struct soap_attribute **tpp = &soap->attributes;
       const char *s = strchr(name, ':');
+      DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inserting attribute %s for c14n\n", name))
       if (!strncmp(name, "xmlns", 5))
       { for (; *tpp; tpp = &(*tpp)->next)
@@ -6108 +7869 @@
       { int k;
         for (; *tpp; tpp = &(*tpp)->next)
-        { if (!strncmp((*tpp)->name, "xmlns:", 6) && !strncmp((*tpp)->name + 6, name, s - name) && !(*tpp)->name[6 + s - name])
-          { if (!tp->ns)
-            { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Canonicalization: prefix %s=%p(%s)\n", name, (*tpp)->ns, (*tpp)->ns));
-              tp->ns = (*tpp)->ns;
-            }
-          }
+        { if (!strncmp((*tpp)->name, "xmlns:", 6) && !strncmp((*tpp)->name + 6, name, s - name) && !(*tpp)->name[6 + s - name])
+          { if (!tp->ns)
+            { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Canonicalization: prefix %s=%p (%s)\n", name, (*tpp)->ns, (*tpp)->ns));
+              tp->ns = (*tpp)->ns;
+            }
+          }
           else if (strncmp((*tpp)->name, "xmlns", 5) && (*tpp)->ns && tp->ns && ((k = strcmp((*tpp)->ns, tp->ns)) > 0 || (!k && strcmp((*tpp)->name, name) > 0)))
             break;
@@ -6129 +7890 @@
     tp->value = NULL;
   }
+  else if (tp->visible)
+  { return SOAP_OK;
+  }
   else if (value && tp->value && tp->size <= strlen(value))
   { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free attribute value of %s (free %p)\n", name, tp->value));
-    SOAP_FREE(tp->value);
+    SOAP_FREE(soap, tp->value);
     tp->value = NULL;
     tp->ns = NULL;
@@ -6138 +7902 @@
   { if (!tp->value)
     { tp->size = strlen(value) + 1;
-      if (!(tp->value = (char*)SOAP_MALLOC(tp->size)))
+      if (!(tp->value = (char*)SOAP_MALLOC(soap, tp->size)))
         return soap->error = SOAP_EOM;
-      DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Allocate attribute value of %s (%p)\n", tp->name, tp->value));
+      DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Allocate attribute value for %s (%p)\n", tp->name, tp->value));
     }
     strcpy(tp->value, value);
@@ -6146 +7910 @@
       tp->ns = tp->value;
     tp->visible = 2;
+#ifndef WITH_LEAN
+    if (!strcmp(name, "wsu:Id"))
+    { soap->part = SOAP_BEGIN_SECURITY;
+      strncpy(soap->id, value, sizeof(soap->id));
+      soap->id[sizeof(soap->id)-1] = '\0';
+    }
+#endif
   }
   else
@@ -6161 +7932 @@
 { register struct soap_attribute *tp;
 #ifndef WITH_LEAN
-  if (soap->mode & SOAP_XML_CANONICAL)
+  if ((soap->mode & SOAP_XML_CANONICAL))
   { while (soap->attributes)
     { tp = soap->attributes->next;
-      SOAP_FREE(soap->attributes->value);
-      SOAP_FREE(soap->attributes);
+      if (soap->attributes->value)
+        SOAP_FREE(soap, soap->attributes->value);
+      SOAP_FREE(soap, soap->attributes);
       soap->attributes = tp;
     }
@@ -6181 +7953 @@
 static int
 soap_getattrval(struct soap *soap, char *s, size_t n, soap_wchar d)
-{ size_t i;
-  soap_wchar c;
+{ register size_t i;
   for (i = 0; i < n; i++)
-  { c = soap_getutf8(soap);
+  { register soap_wchar c = soap_get(soap);
     switch (c)
     {
@@ -6239 +8010 @@
 #ifdef WITH_FAST
 #ifndef PALM_2
-static int 
+SOAP_FMAC1
+int
+SOAP_FMAC2
+soap_store_lab(struct soap *soap, const char *s, size_t n)
+{ soap->labidx = 0;
+  return soap_append_lab(soap, s, n);
+}
+#endif
+#endif
+
+/******************************************************************************/
+#ifdef WITH_FAST
+#ifndef PALM_2
+SOAP_FMAC1
+int
+SOAP_FMAC2
 soap_append_lab(struct soap *soap, const char *s, size_t n)
 { if (soap->labidx + n >= soap->lablen)
@@ -6249 +8035 @@
       soap->lablen <<= 1;
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, ", new size=%lu\n", (unsigned long)soap->lablen));
-    soap->labbuf = (char*)SOAP_MALLOC(soap->lablen);
+    soap->labbuf = (char*)SOAP_MALLOC(soap, soap->lablen);
     if (!soap->labbuf)
     { if (t)
-        free(t);
+        SOAP_FREE(soap, t);
       return soap->error = SOAP_EOM;
     }
-    if (t && soap->labidx)
+    if (t)
     { memcpy(soap->labbuf, t, soap->labidx);
-      free(t);
+      SOAP_FREE(soap, t);
     }
   }
@@ -6275 +8061 @@
 SOAP_FMAC2
 soap_peek_element(struct soap *soap)
-{ register struct soap_attribute *tp;
+{
+#ifdef WITH_DOM
+  register struct soap_dom_attribute **att = NULL;
+  register char *lead = NULL;
+#endif
+  register struct soap_attribute *tp, *tq = NULL;
   const char *t;
   register char *s;
   register soap_wchar c;
   register int i;
-  if (soap->error == SOAP_NO_TAG || soap->error == SOAP_TAG_END || soap->error == SOAP_TAG_MISMATCH)
-    soap->error = SOAP_OK;      /* retry */
   if (soap->peeked)
-  { if (*soap->tag == '\0')
+  { if (!*soap->tag)
       return soap->error = SOAP_NO_TAG;
     return SOAP_OK;
   }
   soap->peeked = 1;
-  for (;;)
-  { while (((c = soap_getutf8(soap)) != SOAP_LT) && c != SOAP_TT)
-    { if ((int)c == EOF)
-        return soap->error = SOAP_EOF;
-    }
-    if (c == SOAP_TT)
-    { *soap->tag = '\0';
-      return soap->error = SOAP_NO_TAG; /* ending tag found */
-    }
-    s = soap->tag;
-    do c = soap_get(soap);
-    while (soap_blank(c));
-    i = sizeof(soap->tag);
-    while (c != '/' && soap_notblank(c))
-    { if (--i > 0)
-        *s++ = (char)c;
-      c = soap_get(soap);
-    }
-    while (soap_blank(c))
-      c = soap_get(soap);
-    *s = '\0';
-    if (*soap->tag != '?')
-      break;
-    DBGLOG(TEST, SOAP_MESSAGE(fdebug, "XML PI <%s?>\n", soap->tag));
-    while ((int)c != EOF && c != SOAP_GT && c != '?')
-    { s = soap->tmpbuf;
-      i = sizeof(soap->tmpbuf) - 2;
-      while (c != '=' && c != SOAP_GT && c != '?' && soap_notblank(c))
-      { if (--i > 0)
-          *s++ = (char)c;
-        c = soap_get(soap);
-      }
-      while (soap_blank(c))
-        c = soap_get(soap);
-      if (c == '=')
-      { *s++ = '=';
-        do c = soap_get(soap);
-        while (soap_blank(c));
-        if (c != SOAP_QT && c != SOAP_AP)
-        { soap_unget(soap, c);
-          c = ' '; /* blank delimiter */
-        }
-        if (soap_getattrval(soap, s, i, c) == SOAP_EOM)
-          while (soap_getattrval(soap, soap->tmpbuf, sizeof(soap->tmpbuf), c) == SOAP_EOM)
-            ;
-        else if (!strcmp(soap->tag, "?xml") && (!soap_tag_cmp(soap->tmpbuf, "encoding=iso-8859-1") || !soap_tag_cmp(soap->tmpbuf, "encoding=latin1")))
-        { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "XML latin1 encoding\n"));
-          soap->mode |= SOAP_ENC_LATIN;
-        }
-      }
-      do c = soap_get(soap);
-      while (soap_blank(c));
-    }
-  }
   soap->id[0] = '\0';
   soap->href[0] = '\0';
@@ -6353 +8088 @@
   soap->null = 0;
   soap->mustUnderstand = 0;
-  soap_clr_attr(soap);
-  while ((int)c != EOF && c != SOAP_GT && c != '/')
+  c = soap_getutf8(soap);
+#ifdef WITH_DOM
+  /* whitespace leading to start tag is not insignificant for DOM */
+  if (soap_blank(c))
+  { soap->labidx = 0;
+    do
+    { if (soap_append_lab(soap, NULL, 0))
+        return SOAP_EOM;
+      s = soap->labbuf + soap->labidx;
+      i = soap->lablen - soap->labidx;
+      soap->labidx = soap->lablen;
+      while (soap_blank(c) && i--)
+      { *s++ = c;
+        c = soap_getutf8(soap);
+      }
+    }
+    while (soap_blank(c));
+    *s = '\0';
+    lead = soap_strdup(soap, soap->labbuf);
+  }
+#else
+  while (soap_blank(c))
+    c = soap_getutf8(soap);
+#endif
+  if (c != SOAP_LT)
+  { *soap->tag = '\0';
+    if ((int)c == EOF)
+      return soap->error = SOAP_EOF;
+    soap_unget(soap, c);
+#ifdef WITH_DOM
+    /* whitespace leading to end tag is not insignificant for DOM */
+    if ((soap->mode & SOAP_XML_DOM) && soap->dom)
+      soap->dom->tail = soap_strdup(soap, lead);
+#endif
+    return soap->error = SOAP_NO_TAG;
+  }
+  s = soap->tag;
+  do c = soap_get1(soap);
+  while (soap_blank(c));
+  i = sizeof(soap->tag);
+  while (c != '>' && c != '/' && soap_notblank(c) && (int)c != EOF)
+  { if (--i > 0)
+      *s++ = (char)c;
+    c = soap_get1(soap);
+  }
+  while (soap_blank(c))
+    c = soap_get1(soap);
+  *s = '\0';
+#ifdef WITH_DOM
+  if (soap->mode & SOAP_XML_DOM)
+  { register struct soap_dom_element *elt;
+    elt = (struct soap_dom_element*)soap_malloc(soap, sizeof(struct soap_dom_element));
+    if (!elt)
+      return soap->error;
+    elt->next = NULL;
+    elt->nstr = NULL;
+    elt->name = soap_strdup(soap, soap->tag);
+    elt->prnt = soap->dom;
+    elt->elts = NULL;
+    elt->atts = NULL;
+    elt->data = NULL;
+    elt->wide = NULL;
+    elt->type = 0;
+    elt->node = NULL;
+    elt->head = lead;
+    elt->tail = NULL;
+    elt->soap = soap;
+    if (soap->dom)
+    { struct soap_dom_element *p = soap->dom->elts;
+      if (p)
+      { while (p->next)
+          p = p->next;
+        p->next = elt;
+      }
+      else
+        soap->dom->elts = elt;
+    }
+    soap->dom = elt;
+    att = &elt->atts;
+  }
+#endif
+  soap_pop_namespace(soap);
+  for (tp = soap->attributes; tp; tp = tp->next)
+    tp->visible = 0;
+  while ((int)c != EOF && c != '>' && c != '/')
   { s = soap->tmpbuf;
     i = sizeof(soap->tmpbuf);
-    while (c != '=' && c != '/' && soap_notblank(c))
+    while (c != '=' && c != '>' && c != '/' && soap_notblank(c) && (int)c != EOF)
     { if (--i > 0)
         *s++ = (char)c;
-      c = soap_get(soap);
+      c = soap_get1(soap);
     }
     *s = '\0';
     if (i == sizeof(soap->tmpbuf))
       return soap->error = SOAP_SYNTAX_ERROR;
-    if (!strncmp(soap->tmpbuf, "xmlns:", 6))
-    { soap->tmpbuf[5] = '\0';
-      t = soap->tmpbuf + 6;
-    }
-    else if (!strcmp(soap->tmpbuf, "xmlns"))
-      t = SOAP_STR_EOS;
+#ifdef WITH_DOM
+    /* add attribute name to dom */
+    if (att)
+    { *att = (struct soap_dom_attribute*)soap_malloc(soap, sizeof(struct soap_dom_attribute));
+       if (!*att)
+         return soap->error;
+       (*att)->next = NULL;
+       (*att)->nstr = NULL;
+       (*att)->name = soap_strdup(soap, soap->tmpbuf);
+       (*att)->data = NULL;
+       (*att)->wide = NULL;
+       (*att)->soap = soap;
+    }
+#endif
+    if (!strncmp(soap->tmpbuf, "xmlns", 5))
+    { if (soap->tmpbuf[5] == ':')
+        t = soap->tmpbuf + 6;
+      else if (soap->tmpbuf[5])
+        t = NULL;
+      else
+        t = SOAP_STR_EOS;
+    }
     else
       t = NULL;
-    for (tp = soap->attributes; tp; tp = tp->next)
-      if (!SOAP_STRCMP(tp->name, soap->tmpbuf))
+    tq = NULL;
+    for (tp = soap->attributes; tp; tq = tp, tp = tp->next)
+    { if (!SOAP_STRCMP(tp->name, soap->tmpbuf))
         break;
+    }
     if (!tp)
-    { tp = (struct soap_attribute*)SOAP_MALLOC(sizeof(struct soap_attribute) + strlen(soap->tmpbuf));
+    { tp = (struct soap_attribute*)SOAP_MALLOC(soap, sizeof(struct soap_attribute) + strlen(soap->tmpbuf));
       if (!tp)
         return soap->error = SOAP_EOM;
@@ -6383 +8219 @@
       tp->value = NULL;
       tp->size = 0;
-      tp->next = soap->attributes;
-      soap->attributes = tp;
+      /* if attribute name is qualified, append it to the end of the list */
+      if (tq && strchr(soap->tmpbuf, ':'))
+      { tq->next = tp;
+        tp->next = NULL;
+      }
+      else
+      { tp->next = soap->attributes;
+        soap->attributes = tp;
+      }
     }
     while (soap_blank(c))
-      c = soap_get(soap);
+      c = soap_get1(soap);
     if (c == '=')
-    { do c = soap_get(soap);
+    { do c = soap_getutf8(soap);
       while (soap_blank(c));
       if (c != SOAP_QT && c != SOAP_AP)
@@ -6401 +8244 @@
           return soap->error;
         soap->error = SOAP_OK;
-        soap->labidx = 0;
-        if (soap_append_lab(soap, tp->value, tp->size))
-          return soap->error;
-        SOAP_FREE(tp->value);
-        for (;;)
-        { if (soap_getattrval(soap, soap->labbuf + soap->labidx, soap->lablen - soap->labidx, c))
-          { if (soap->error != SOAP_EOM)
-              return soap->error;
+        if (soap_store_lab(soap, tp->value, tp->size))
+          return soap->error;
+        if (tp->value)
+          SOAP_FREE(soap, tp->value);
+        for (;;)
+        { if (soap_getattrval(soap, soap->labbuf + soap->labidx, soap->lablen - soap->labidx, c))
+          { if (soap->error != SOAP_EOM)
+              return soap->error;
             soap->error = SOAP_OK;
-            soap->labidx = soap->lablen;
-            if (soap_append_lab(soap, NULL, 0))
-              return soap->error;
-          }
-          else
-            break;
-        }
-        tp->size = soap->lablen;
-        if (!(tp->value = (char*)SOAP_MALLOC(tp->size)))
-          return soap->error = SOAP_EOM;
-        memcpy(tp->value, soap->labbuf, soap->lablen);
+            soap->labidx = soap->lablen;
+            if (soap_append_lab(soap, NULL, 0))
+              return soap->error;
+          }
+          else
+            break;
+        }
+        if (soap->labidx)
+          tp->size = soap->lablen;
+        else
+        { tp->size = strlen(soap->labbuf) + 1;
+          if (tp->size < SOAP_LABLEN)
+            tp->size = SOAP_LABLEN;
+        }
+        if (!(tp->value = (char*)SOAP_MALLOC(soap, tp->size)))
+          return soap->error = SOAP_EOM;
+        strcpy(tp->value, soap->labbuf);
 #else
-        size_t n;
+        size_t n;
         if (soap->error != SOAP_EOM)
           return soap->error;
         soap->error = SOAP_OK;
-        if (soap_new_block(soap))
+        if (soap_new_block(soap) == NULL)
           return soap->error;
         for (;;)
-        { if (!(s = (char*)soap_push_block(soap, SOAP_BLKLEN)))
+        { if (!(s = (char*)soap_push_block(soap, NULL, SOAP_BLKLEN)))
             return soap->error;
           if (soap_getattrval(soap, s, SOAP_BLKLEN, c))
@@ -6439 +8288 @@
             break;
         }
-        n = tp->size + soap->blist->size;
-        if (!(s = (char*)SOAP_MALLOC(n)))
+        n = tp->size + soap->blist->size;
+        if (!(s = (char*)SOAP_MALLOC(soap, n)))
           return soap->error = SOAP_EOM;
         if (tp->value)
         { memcpy(s, tp->value, tp->size);
-          SOAP_FREE(tp->value);
+          SOAP_FREE(soap, tp->value);
         }
-        soap_save_block(soap, s + tp->size, 0);
+        soap_save_block(soap, NULL, s + tp->size, 0);
         tp->value = s;
         tp->size = n;
 #endif
       }
-      do c = soap_get(soap);
+      do c = soap_get1(soap);
       while (soap_blank(c));
       tp->visible = 2; /* seen this attribute w/ value */
+#ifdef WITH_DOM
+      if (att)
+        (*att)->data = soap_strdup(soap, tp->value);
+#endif
     }
     else
       tp->visible = 1; /* seen this attribute w/o value */
+#ifdef WITH_DOM
+    if (att)
+      att = &(*att)->next;
+#endif
     if (t && tp->value)
     { if (soap_push_namespace(soap, t, tp->value))
         return soap->error;
-      tp->visible = 0;
-    }
-  }
+    }
+  }
+#ifdef WITH_DOM
+  if (att)
+  { soap->dom->nstr = soap_current_namespace(soap, soap->tag);
+    for (att = &soap->dom->atts; *att; att = &(*att)->next)
+      (*att)->nstr = soap_current_namespace(soap, (*att)->name);
+  }
+#endif
   if ((int)c == EOF)
     return soap->error = SOAP_EOF;
+  if (!(soap->body = (c != '/')))
+    do c = soap_get1(soap);
+    while (soap_blank(c));
+#ifdef WITH_DOM
+  if (soap->mode & SOAP_XML_DOM)
+  { if (!soap->body && soap->dom->prnt)
+      soap->dom = soap->dom->prnt;
+  }
+#endif
   for (tp = soap->attributes; tp; tp = tp->next)
   { if (tp->visible && tp->value)
-    { if (!strcmp(tp->name, "id"))
-      { *soap->id = '#';
-        strncpy(soap->id + 1, tp->value, sizeof(soap->id) - 2);
-        soap->id[sizeof(soap->id)-1] = '\0';
+    { 
+#ifndef WITH_NOIDREF
+      if (!strcmp(tp->name, "id"))
+      { if ((soap->version > 0 && !(soap->mode & SOAP_XML_TREE))
+         || (soap->mode & SOAP_XML_GRAPH))
+        { *soap->id = '#';
+          strncpy(soap->id + 1, tp->value, sizeof(soap->id) - 2);
+          soap->id[sizeof(soap->id)-1] = '\0';
+        }
       }
       else if (!strcmp(tp->name, "href"))
-      { strncpy(soap->href, tp->value, sizeof(soap->href) - 1);
-        soap->href[sizeof(soap->href)-1] = '\0';
-      }
-      else if ((soap->version == 2 || (soap->mode & SOAP_XML_GRAPH)) && !strcmp(tp->name, "ref"))
-      { *soap->href = '#';
-        strncpy(soap->href + 1, tp->value, sizeof(soap->href) - 2);
-        soap->href[sizeof(soap->href)-1] = '\0';
-      }
-      else if (!soap_match_tag(soap, tp->name, "xsi:type"))
+      { if (soap->version == 1
+         || (soap->mode & SOAP_XML_GRAPH)
+         || (soap->mode & SOAP_ENC_MTOM))
+        { strncpy(soap->href, tp->value, sizeof(soap->href) - 1);
+          soap->href[sizeof(soap->href)-1] = '\0';
+        }
+      }
+      else
+#endif
+      if (!soap_match_tag(soap, tp->name, "xsi:type"))
       { strncpy(soap->type, tp->value, sizeof(soap->type) - 1);
         soap->type[sizeof(soap->type)-1] = '\0';
       }
-      else if (soap->version == 1 && !soap_match_tag(soap, tp->name, "SOAP-ENC:arrayType"))
-      { s = soap_strrchr(tp->value, '[');
-        if (s && (size_t)(s - tp->value) < sizeof(soap->arrayType))
-        { strncpy(soap->arrayType, tp->value, s - tp->value);
-          soap->arrayType[s - tp->value] = '\0';
-          strncpy(soap->arraySize, s, sizeof(soap->arraySize) - 1);
-        }
-        else
-          strncpy(soap->arrayType, tp->value, sizeof(soap->arrayType) - 1);
-        soap->arraySize[sizeof(soap->arrayType)-1] = '\0';
-        soap->arrayType[sizeof(soap->arrayType)-1] = '\0';
-      }
-      else if (soap->version == 2 && !soap_match_tag(soap, tp->name, "SOAP-ENC:itemType"))
-        strncpy(soap->arrayType, tp->value, sizeof(soap->arrayType) - 1);
-      else if (soap->version == 2 && !soap_match_tag(soap, tp->name, "SOAP-ENC:arraySize"))
-        strncpy(soap->arraySize, tp->value, sizeof(soap->arraySize) - 1);
-      else if (soap->version == 1 && !soap_match_tag(soap, tp->name, "SOAP-ENC:offset"))
-        strncpy(soap->arrayOffset, tp->value, sizeof(soap->arrayOffset));
-      else if (soap->version == 1 && !soap_match_tag(soap, tp->name, "SOAP-ENC:position"))
-        soap->position = soap_getposition(tp->value, soap->positions);
-      else if (soap->version == 1 && !soap_match_tag(soap, tp->name, "SOAP-ENC:root"))
-        soap->root = ((!strcmp(tp->value, "1") || !strcmp(tp->value, "true")));
-      else if (!soap_match_tag(soap, tp->name, "SOAP-ENV:actor")
-            || !soap_match_tag(soap, tp->name, "SOAP-ENV:role"))
-      { if ((!soap->actor || strcmp(soap->actor, tp->value))
-         && strcmp(tp->value, "http://schemas.xmlsoap.org/soap/actor/next")
-         && strcmp(tp->value, "http://www.w3.org/2003/05/soap-envelope/role/next"))
-          soap->other = 1;
-      }
-      else if (!soap_match_tag(soap, tp->name, "SOAP-ENV:mustUnderstand")
-            && (!strcmp(tp->value, "1") || !strcmp(tp->value, "true")))
-        soap->mustUnderstand = 1;
       else if ((!soap_match_tag(soap, tp->name, "xsi:null")
              || !soap_match_tag(soap, tp->name, "xsi:nil"))
             && (!strcmp(tp->value, "1")
              || !strcmp(tp->value, "true")))
-        soap->null = 1;
-    }
-  }
-  if (!(soap->body = (c != '/')))
-    do c = soap_get(soap);
-    while (soap_blank(c));
-  return SOAP_OK;
+      { soap->null = 1;
+      }
+      else if (soap->version == 1)
+      { if (!soap_match_tag(soap, tp->name, "SOAP-ENC:arrayType"))
+        { s = soap_strrchr(tp->value, '[');
+          if (s && (size_t)(s - tp->value) < sizeof(soap->arrayType))
+          { strncpy(soap->arrayType, tp->value, s - tp->value);
+            soap->arrayType[s - tp->value] = '\0';
+            strncpy(soap->arraySize, s, sizeof(soap->arraySize) - 1);
+          }
+          else
+            strncpy(soap->arrayType, tp->value, sizeof(soap->arrayType) - 1);
+          soap->arraySize[sizeof(soap->arrayType)-1] = '\0';
+          soap->arrayType[sizeof(soap->arrayType)-1] = '\0';
+        }
+        else if (!soap_match_tag(soap, tp->name, "SOAP-ENC:offset"))
+          strncpy(soap->arrayOffset, tp->value, sizeof(soap->arrayOffset));
+        else if (!soap_match_tag(soap, tp->name, "SOAP-ENC:position"))
+          soap->position = soap_getposition(tp->value, soap->positions);
+        else if (!soap_match_tag(soap, tp->name, "SOAP-ENC:root"))
+          soap->root = ((!strcmp(tp->value, "1") || !strcmp(tp->value, "true")));
+        else if (!soap_match_tag(soap, tp->name, "SOAP-ENV:mustUnderstand")
+              && (!strcmp(tp->value, "1") || !strcmp(tp->value, "true")))
+          soap->mustUnderstand = 1;
+        else if (!soap_match_tag(soap, tp->name, "SOAP-ENV:actor"))
+        { if ((!soap->actor || strcmp(soap->actor, tp->value))
+           && strcmp(tp->value, "http://schemas.xmlsoap.org/soap/actor/next"))
+            soap->other = 1;
+        }
+      }
+      else if (soap->version == 2)
+      {
+#ifndef WITH_NOIDREF
+        if (!strcmp(tp->name, "ref")
+         || !soap_match_tag(soap, tp->name, "SOAP-ENC:ref"))
+        { *soap->href = '#';
+          strncpy(soap->href + 1, tp->value, sizeof(soap->href) - 2);
+          soap->href[sizeof(soap->href)-1] = '\0';
+        }
+        else
+#endif
+        if (!soap_match_tag(soap, tp->name, "SOAP-ENC:itemType"))
+          strncpy(soap->arrayType, tp->value, sizeof(soap->arrayType) - 1);
+        else if (!soap_match_tag(soap, tp->name, "SOAP-ENC:arraySize"))
+          strncpy(soap->arraySize, tp->value, sizeof(soap->arraySize) - 1);
+        else if (!soap_match_tag(soap, tp->name, "SOAP-ENV:mustUnderstand")
+              && (!strcmp(tp->value, "1") || !strcmp(tp->value, "true")))
+          soap->mustUnderstand = 1;
+        else if (!soap_match_tag(soap, tp->name, "SOAP-ENV:role"))
+        { if ((!soap->actor || strcmp(soap->actor, tp->value))
+           && strcmp(tp->value, "http://www.w3.org/2003/05/soap-envelope/role/next"))
+            soap->other = 1;
+        }
+      }
+    }
+  }
+  return soap->error = SOAP_OK;
 }
 #endif
@@ -6537 +8433 @@
 SOAP_FMAC2
 soap_retry(struct soap *soap)
-{ soap->peeked = 1;
-  soap->error = SOAP_OK;
+{ soap->error = SOAP_OK;
+  soap_revert(soap);
 }
 #endif
@@ -6565 +8461 @@
 { register const char *t;
   register soap_wchar c;
-  register soap_wchar mask = 0x80000000;
+  register soap_wchar mask = (soap_wchar)0xFFFFFF80UL;
 #ifdef WITH_DOM
   if ((soap->mode & SOAP_XML_DOM) && soap->dom)
-  { soap->dom->data = soap_strdup(soap, s); /* check EOM */
+  { soap->dom->data = soap_strdup(soap, s);
     return SOAP_OK;
   }
@@ -6578 +8474 @@
   { switch (c)
     { 
-    case 9:
+    case 0x09:
       if (flag)
       { if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, "&#x9;", 5))
-          return soap->error;
+          return soap->error;
         s = t;
       }
       break;
-    case 10:
+    case 0x0A:
       if (flag || !(soap->mode & SOAP_XML_CANONICAL))
       { if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, "&#xA;", 5))
-          return soap->error;
+          return soap->error;
         s = t;
       }
       break;
-    case 13:
+    case 0x0D:
       if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, "&#xD;", 5))
         return soap->error;
@@ -6610 +8506 @@
       if (!flag)
       { if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, "&gt;", 4))
-          return soap->error;
+          return soap->error;
         s = t;
       }
@@ -6617 +8513 @@
       if (flag)
       { if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, "&quot;", 6))
-          return soap->error;
+          return soap->error;
         s = t;
       }
       break;
     default:
+#ifndef WITH_LEANER
 #ifdef HAVE_MBTOWC
       if (soap->mode & SOAP_C_MBSTRING)
@@ -6629 +8526 @@
         { if (soap_send_raw(soap, s, t - s - 1) || soap_pututf8(soap, wc))
             return soap->error;
-          s = t + m - 1;
-          continue;
+          s = t += m - 1;
+          continue;
         }
       }
 #endif
-      if (c & mask)
+#endif
+#ifndef WITH_NOSTRINGTOUTF8
+      if ((c & mask) || !(c & 0xFFFFFFE0UL))
       { if (soap_send_raw(soap, s, t - s - 1) || soap_pututf8(soap, (unsigned char)c))
           return soap->error;
         s = t;
       }
+#endif
     }
   }
@@ -6655 +8555 @@
   register size_t i;
   register long l = 0;
-  register int n = 0;
-  register int m = 0;
+  register int n = 0, f = 0, m = 0;
   register soap_wchar c;
-#ifdef HAVE_WCTOMB
+#if !defined(WITH_LEANER) && defined(HAVE_WCTOMB)
   char buf[MB_LEN_MAX > 8 ? MB_LEN_MAX : 8];
 #else
   char buf[8];
 #endif
+  DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Reading string content\n"));
+  if (soap->peeked)
+  { if (*soap->tag)
+    {
+#ifndef WITH_LEAN
+      struct soap_attribute *tp;
+      t = soap->tmpbuf;
+      *t = '<';
+      t[sizeof(soap->tmpbuf)-1] = '\0';
+      strncpy(t + 1, soap->tag, sizeof(soap->tmpbuf) - 2);
+      t += strlen(t);
+      for (tp = soap->attributes; tp; tp = tp->next)
+      { if (tp->visible)
+        { if (t >= soap->tmpbuf + sizeof(soap->tmpbuf) - 2)
+            break;
+          *t++ = ' ';
+          strcpy(t, tp->name);
+          t += strlen(t);
+          if (t >= soap->tmpbuf + sizeof(soap->tmpbuf) - 2)
+            break; /* too many or large attribute values */
+          if (tp->value)
+          { *t++ = '=';
+            *t++ = '"';
+            strcpy(t, tp->value);
+            t += strlen(t);
+            *t++ = '"';
+          }
+        }
+      }
+      if (!soap->body)
+        *t++ = '/';
+      *t++ = '>';
+      *t = '\0';
+      t = soap->tmpbuf;
+      m = (int)strlen(soap->tmpbuf);
+#endif
+      if (soap->body)
+        n = 1;
+      f = 1;
+      soap->peeked = 0;
+    }
+  }
 #ifdef WITH_CDATA
   if (!flag)
@@ -6669 +8610 @@
     soap->labidx = 0;                   /* use look-aside buffer */
 #else
-    if (soap_new_block(soap))
+    if (soap_new_block(soap) == NULL)
       return NULL;
 #endif
@@ -6683 +8624 @@
 #else
       register size_t k = SOAP_BLKLEN;
-      if (!(s = (char*)soap_push_block(soap, k)))
+      if (!(s = (char*)soap_push_block(soap, NULL, k)))
         return NULL;
 #endif
@@ -6689 +8630 @@
       { if (m > 0)
         { *s++ = *t++;  /* copy multibyte characters */
-          m--;
+          m--;
           continue;
         }
         c = soap_getchar(soap);
-        if ((int)c == EOF)
+        if ((int)c == EOF)
           goto end;
-        if (c >= 0x80 && !(soap->mode & SOAP_ENC_LATIN))
+        if (c >= 0x80 && state != 1 && !(soap->mode & SOAP_ENC_LATIN))
         { soap_unget(soap, c);
-          c = soap_getutf8(soap);
-          if (soap->mode & SOAP_C_UTFSTRING)
+          c = soap_getutf8(soap);
+          if (soap->mode & SOAP_C_UTFSTRING)
           { if ((c & 0x80000000) && c >= -0x7FFFFF80 && c < SOAP_AP)
             { c &= 0x7FFFFFFF;
@@ -6724 +8665 @@
               }
               *t++ = (char)(0x80 | (c & 0x3F));
-              m = (int)(t - buf) - 1;
+              m = (int)(t - buf) - 1;
               t = buf;
               *s++ = *t++;
               continue;
-            }
+            }
           }
         }
-        switch (state)
+        switch (state)
         { case 1:
             if (c == ']')
-              state = 4;
-            *s++ = c;
-            continue;
-          case 2:
-            if (c == '-')
+              state = 4;
+            *s++ = c;
+            continue;
+          case 2:
+            if (c == '-')
               state = 6;
-            *s++ = c;
-            continue;
-          case 3:
-            if (c == '?')
-              state = 8;
-            *s++ = c;
-            continue;
+            *s++ = c;
+            continue;
+          case 3:
+            if (c == '?')
+              state = 8;
+            *s++ = c;
+            continue;
           /* CDATA */
-          case 4:
-            if (c == ']')
+          case 4:
+            if (c == ']')
               state = 5;
-            else
-              state = 1;
-            *s++ = c;
-            continue;
-          case 5:
-            if (c == '>')
-              state = 0;
-            else
-              state = 1;
-            *s++ = c;
-            continue;
+            else
+              state = 1;
+            *s++ = c;
+            continue;
+          case 5:
+            if (c == '>')
+              state = 0;
+            else
+              state = 1;
+            *s++ = c;
+            continue;
           /* comment */
           case 6:
             if (c == '-')
-              state = 7;
-            else
-              state = 2;
-            *s++ = c;
-            continue;
+              state = 7;
+            else
+              state = 2;
+            *s++ = c;
+            continue;
           case 7:
             if (c == '>')
-              state = 0;
-            else
-              state = 2;
-            *s++ = c;
-            continue;
+              state = 0;
+            else
+              state = 2;
+            *s++ = c;
+            continue;
           /* PI */
-          case 8:
+          case 8:
             if (c == '>')
-              state = 0;
-            else
-              state = 3;
-            *s++ = c;
-            continue;
+              state = 0;
+            else
+              state = 3;
+            *s++ = c;
+            continue;
         }
         switch (c)
@@ -6798 +8739 @@
           break;
         case '<':
-          c = soap_getchar(soap);
-          if (c == '/')
-          { if (n == 0)
-            { c = SOAP_TT;
-              goto end;
-            }
-            n--;
-          }
-          else if (c == '!')
-          { c = soap_getchar(soap);
-            if (c == '[')
+          c = soap_getchar(soap);
+          if (c == '/')
+          { if (n == 0)
+            { c = SOAP_TT;
+              goto end;
+            }
+            n--;
+          }
+          else if (c == '!')
+          { c = soap_getchar(soap);
+            if (c == '[')
             { do c = soap_getchar(soap);
               while ((int)c != EOF && c != '[');
               if ((int)c == EOF)
                  goto end;
-              t = (char*)"![CDATA[";
-              m = 8;
-              state = 1;
-            }
+              t = (char*)"![CDATA[";
+              m = 8;
+              state = 1;
+            }
             else if (c == '-')
-            { if ((c = soap_getchar(soap)) == '-')
-                state = 2;
-              t = (char*)"!-";
-              m = 2;
-              soap_unget(soap, c);
-            }
-            else
-            { t = (char*)"!";
-              m = 1;
-              soap_unget(soap, c);
-            }
-            *s++ = '<';
-            break;
-          }
-          else if (c == '?')
-            state = 3;
-          else
-            n++;
+            { if ((c = soap_getchar(soap)) == '-')
+                state = 2;
+              t = (char*)"!-";
+              m = 2;
+              soap_unget(soap, c);
+            }
+            else
+            { t = (char*)"!";
+              m = 1;
+              soap_unget(soap, c);
+            }
+            *s++ = '<';
+            break;
+          }
+          else if (c == '?')
+            state = 3;
+          else
+            n++;
           soap_unget(soap, c);
           *s++ = '<';
@@ -6846 +8787 @@
           break;
         default:
+#ifndef WITH_LEANER
 #ifdef HAVE_WCTOMB
           if (soap->mode & SOAP_C_MBSTRING)
           { m = wctomb(buf, c & 0x7FFFFFFF);
-            if (m >= 1)
+            if (m >= 1 && m <= (int)MB_CUR_MAX)
             { t = buf;
               *s++ = *t++;
@@ -6855 +8797 @@
             }
             else
-              *s++ = SOAP_UNKNOWN_CHAR;
+            { *s++ = SOAP_UNKNOWN_CHAR;
+              m = 0;
+            }
           }
           else
 #endif
+#endif
             *s++ = (char)(c & 0xFF);
         }
-        l++;
+        l++;
         if ((soap->mode & SOAP_XML_STRICT) && maxlen >= 0 && l > maxlen)
         { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "String too long: maxlen=%ld\n", maxlen));
@@ -6874 +8819 @@
   soap->labidx = 0;                     /* use look-aside buffer */
 #else
-  if (soap_new_block(soap))
+  if (soap_new_block(soap) == NULL)
     return NULL;
 #endif
@@ -6888 +8833 @@
 #else
     register size_t k = SOAP_BLKLEN;
-    if (!(s = (char*)soap_push_block(soap, k)))
+    if (!(s = (char*)soap_push_block(soap, NULL, k)))
       return NULL;
 #endif
@@ -6923 +8868 @@
           }
           *t++ = (char)(0x80 | (c & 0x3F));
-          m = (int)(t - buf) - 1;
+          m = (int)(t - buf) - 1;
           t = buf;
           *s++ = *t++;
@@ -6939 +8884 @@
         *s++ = '<';
         t = (char*)"/";
-        m = 1;
+        m = 1;
         break;
       case SOAP_LT:
+        if (f && n == 0)
+          goto end;
         n++;
         *s++ = '<';
@@ -6963 +8910 @@
         *s++ = '/';
         break;
-      case '<' | 0x80000000:
+      case (soap_wchar)('<' | 0x80000000):
         if (flag)
           *s++ = '<';
@@ -6969 +8916 @@
         { *s++ = '&';
           t = (char*)"lt;";
-          m = 3;
+          m = 3;
         }
         break;
-      case '>' | 0x80000000:
+      case (soap_wchar)('>' | 0x80000000):
         if (flag)
           *s++ = '>';
@@ -6978 +8925 @@
         { *s++ = '&';
           t = (char*)"gt;";
-          m = 3;
+          m = 3;
         }
         break;
-      case '"' | 0x80000000:
+      case (soap_wchar)('&' | 0x80000000):
+        if (flag)
+          *s++ = '&';
+        else
+        { *s++ = '&';
+          t = (char*)"amp;";
+          m = 4;
+        }
+        break;
+      case (soap_wchar)('"' | 0x80000000):
         if (flag)
           *s++ = '"';
@@ -6987 +8943 @@
         { *s++ = '&';
           t = (char*)"quot;";
-          m = 5;
+          m = 5;
         }
         break;
-      case '\'' | 0x80000000:
+      case (soap_wchar)('\'' | 0x80000000):
         if (flag)
           *s++ = '\'';
@@ -6996 +8952 @@
         { *s++ = '&';
           t = (char*)"apos;";
-          m = 5;
+          m = 5;
         }
         break;
@@ -7002 +8958 @@
         if ((int)c == EOF)
           goto end;
+#ifndef WITH_LEANER
 #ifdef HAVE_WCTOMB
         if (soap->mode & SOAP_C_MBSTRING)
         { m = wctomb(buf, c & 0x7FFFFFFF);
-          if (m >= 1)
+          if (m >= 1 && m <= (int)MB_CUR_MAX)
           { t = buf;
             *s++ = *t++;
@@ -7011 +8968 @@
           }
           else
-            *s++ = SOAP_UNKNOWN_CHAR;
+          { *s++ = SOAP_UNKNOWN_CHAR;
+            m = 0;
+          }
         }
         else
+#endif
 #endif
           *s++ = (char)(c & 0xFF);
@@ -7031 +8991 @@
   t = soap_strdup(soap, soap->labbuf);
 #else
-  soap_size_block(soap, i+1);
+  soap_size_block(soap, NULL, i+1);
   t = soap_save_block(soap, NULL, 0);
 #endif
@@ -7039 +8999 @@
     return NULL;
   }
+#ifdef WITH_DOM
+  if ((soap->mode & SOAP_XML_DOM) && soap->dom)
+  { if (flag == 3)
+      soap->dom->tail = t;
+    else
+      soap->dom->data = t;
+  }
+#endif
   if (flag == 2)
     if (soap_s2QName(soap, t, &t))
@@ -7047 +9015 @@
 
 /******************************************************************************/
+#ifndef WITH_LEANER
 #ifndef PALM_2
 SOAP_FMAC1
@@ -7057 +9026 @@
 #ifdef WITH_DOM
   if ((soap->mode & SOAP_XML_DOM) && soap->dom)
-  { soap->dom->wide = NULL; /* soap_malloc() ??? */
+  { wchar_t *r = (wchar_t*)s;
+    int n = 1;
+    while (*r++)
+      n++;
+    soap->dom->wide = r = (wchar_t*)soap_malloc(soap, n * sizeof(wchar_t));
+    while (n--)
+      *r++ = *s++;
     return SOAP_OK;
   }
@@ -7064 +9039 @@
   { switch (c)
     { 
-    case 9:
+    case 0x09:
       if (flag)
         t = "&#x9;";
@@ -7070 +9045 @@
         t = "\t";
       break;
-    case 10:
+    case 0x0A:
       if (flag || !(soap->mode & SOAP_XML_CANONICAL))
         t = "&#xA;";
@@ -7076 +9051 @@
         t = "\n";
       break;
-    case 13:
+    case 0x0D:
       t = "&#xD;";
       break;
@@ -7089 +9064 @@
         t = ">";
       else
-        t = "&gt;";
+        t = "&gt;";
       break;
     case '"':
@@ -7098 +9073 @@
       break;
     default:
-      if (c > 0 && c < 0x80)
+      if (c >= 0x20 && c < 0x80)
       { tmp = (char)c;
         if (soap_send_raw(soap, &tmp, 1))
@@ -7113 +9088 @@
 }
 #endif
-
-/******************************************************************************/
+#endif
+
+/******************************************************************************/
+#ifndef WITH_LEANER
 #ifndef PALM_2
 SOAP_FMAC1
@@ -7121 +9098 @@
 soap_wstring_in(struct soap *soap, int flag, long minlen, long maxlen)
 { wchar_t *s;
-  register int i, n = 0;
+  register int i, n = 0, f = 0;
   register long l = 0;
   register soap_wchar c;
-  const char *t = NULL;
-  if (soap_new_block(soap))
+  char *t = NULL;
+  DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Reading wide string content\n"));
+  if (soap->peeked)
+  { if (*soap->tag)
+    {
+#ifndef WITH_LEAN
+      struct soap_attribute *tp;
+      t = soap->tmpbuf;
+      *t = '<';
+      t[sizeof(soap->tmpbuf)-1] = '\0';
+      strncpy(t + 1, soap->tag, sizeof(soap->tmpbuf) - 2);
+      t += strlen(t);
+      for (tp = soap->attributes; tp; tp = tp->next)
+      { if (tp->visible)
+        { if (t >= soap->tmpbuf + sizeof(soap->tmpbuf) - 2)
+            break;
+          *t++ = ' ';
+          strcpy(t, tp->name);
+          t += strlen(t);
+          if (t >= soap->tmpbuf + sizeof(soap->tmpbuf) - 2)
+            break;
+          if (tp->value)
+          { *t++ = '=';
+            *t++ = '"';
+            strcpy(t, tp->value);
+            t += strlen(t);
+            *t++ = '"';
+          }
+        }
+      }
+      if (!soap->body)
+        *t++ = '/';
+      *t++ = '>';
+      *t = '\0';
+      t = soap->tmpbuf;
+#endif
+      if (soap->body)
+        n = 1;
+      f = 1;
+      soap->peeked = 0;
+    }
+  }
+  if (soap_new_block(soap) == NULL)
     return NULL;
   for (;;)
-  { if (!(s = (wchar_t*)soap_push_block(soap, sizeof(wchar_t)*SOAP_BLKLEN)))
+  { if (!(s = (wchar_t*)soap_push_block(soap, NULL, sizeof(wchar_t)*SOAP_BLKLEN)))
       return NULL;
     for (i = 0; i < SOAP_BLKLEN; i++)
@@ -7148 +9166 @@
         break;
       case SOAP_LT:
+        if (f && n == 0)
+          goto end;
         n++;
         *s++ = '<';
@@ -7174 +9194 @@
         else
         { *s++ = (soap_wchar)'&';
-          t = "lt;";
+          t = (char*)"lt;";
         }
         break;
@@ -7182 +9202 @@
         else
         { *s++ = (soap_wchar)'&';
-          t = "gt;";
+          t = (char*)"gt;";
         }
         break;
@@ -7190 +9210 @@
         else
         { *s++ = (soap_wchar)'&';
-          t = "quot;";
+          t = (char*)"quot;";
         }
         break;
@@ -7209 +9229 @@
   soap_unget(soap, c);
   *s = '\0';
-  soap_size_block(soap, sizeof(wchar_t) * (i + 1));
+  soap_size_block(soap, NULL, sizeof(wchar_t) * (i + 1));
   if ((soap->mode & SOAP_XML_STRICT) && l < minlen)
   { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "String too short: %ld chars, minlen=%ld\n", l, minlen));
@@ -7215 +9235 @@
     return NULL;
   }
-  return (wchar_t*)soap_save_block(soap, NULL, 0);
-}
+  s = (wchar_t*)soap_save_block(soap, NULL, NULL, 0);
+#ifdef WITH_DOM
+  if ((soap->mode & SOAP_XML_DOM) && soap->dom)
+    soap->dom->wide = s;
+#endif
+  return s;
+}
+#endif
 #endif
 
@@ -7250 +9276 @@
 { if (s)
   { char *r;
+#ifndef WITH_NOIO
+#ifndef WITH_LEAN
+    soap_reset_errno;
+#endif
+#endif
     *p = (int)soap_strtol(s, &r, 10);
-    if (*r)
+    if ((s == r && (soap->mode & SOAP_XML_STRICT)) || *r
+#ifndef WITH_NOIO
+#ifndef WITH_LEAN
+     || soap_errno == SOAP_ERANGE
+#endif
+#endif
+    )
       soap->error = SOAP_TYPE;
   }
@@ -7264 +9301 @@
 SOAP_FMAC2
 soap_inint(struct soap *soap, const char *tag, int *p, const char *type, int t)
-{ if (soap_element_begin_in(soap, tag, 0))
+{ if (soap_element_begin_in(soap, tag, 0, NULL))
     return NULL;
 #ifndef WITH_LEAN
@@ -7278 +9315 @@
 #endif
   p = (int*)soap_id_enter(soap, soap->id, p, t, sizeof(int), 0, NULL, NULL, NULL);
-  if (p)
+  if (*soap->href)
+    p = (int*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(int), 0, NULL);
+  else if (p)
   { if (soap_s2int(soap, soap_value(soap), p))
       return NULL;
   }
-  p = (int*)soap_id_forward(soap, soap->href, p, t, 0, sizeof(int), 0, NULL);
   if (soap->body && soap_element_end_in(soap, tag))
     return NULL;
@@ -7321 +9359 @@
 { if (s)
   { char *r;
+#ifndef WITH_NOIO
+#ifndef WITH_LEAN
+    soap_reset_errno;
+#endif
+#endif
     *p = soap_strtol(s, &r, 10);
-    if (*r)
+    if ((s == r && (soap->mode & SOAP_XML_STRICT)) || *r
+#ifndef WITH_NOIO
+#ifndef WITH_LEAN
+     || soap_errno == SOAP_ERANGE
+#endif
+#endif
+    )
       soap->error = SOAP_TYPE;
   }
@@ -7335 +9384 @@
 SOAP_FMAC2
 soap_inlong(struct soap *soap, const char *tag, long *p, const char *type, int t)
-{ if (soap_element_begin_in(soap, tag, 0))
+{ if (soap_element_begin_in(soap, tag, 0, NULL))
     return NULL;
 #ifndef WITH_LEAN
@@ -7349 +9398 @@
 #endif
   p = (long*)soap_id_enter(soap, soap->id, p, t, sizeof(long), 0, NULL, NULL, NULL);
-  if (p)
+  if (*soap->href)
+    p = (long*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(long), 0, NULL);
+  else if (p)
   { if (soap_s2long(soap, soap_value(soap), p))
       return NULL;
   }
-  p = (long*)soap_id_forward(soap, soap->href, p, t, 0, sizeof(long), 0, NULL);
   if (soap->body && soap_element_end_in(soap, tag))
     return NULL;
@@ -7390 +9440 @@
 SOAP_FMAC2
 soap_s2LONG64(struct soap *soap, const char *s, LONG64 *p)
-{ if (s && sscanf(s, SOAP_LONG_FORMAT, p) != 1)
-    soap->error = SOAP_TYPE;
+{ if (s)
+  {
+#ifdef HAVE_STRTOLL
+    char *r;
+#ifndef WITH_NOIO
+#ifndef WITH_LEAN
+    soap_reset_errno;
+#endif
+#endif
+    *p = strtoll(s, &r, 10);
+    if ((s == r && (soap->mode & SOAP_XML_STRICT)) || *r
+#ifndef WITH_NOIO
+#ifndef WITH_LEAN
+       || soap_errno == SOAP_ERANGE
+#endif
+#endif
+      )
+#else
+# ifdef HAVE_SSCANF
+    if (sscanf(s, SOAP_LONG_FORMAT, p) != 1)
+# endif
+#endif
+      soap->error = SOAP_TYPE;
+  }
   return soap->error;
 }
@@ -7402 +9474 @@
 SOAP_FMAC2
 soap_inLONG64(struct soap *soap, const char *tag, LONG64 *p, const char *type, int t)
-{ if (soap_element_begin_in(soap, tag, 0))
+{ if (soap_element_begin_in(soap, tag, 0, NULL))
     return NULL;
 #ifndef WITH_LEAN
@@ -7422 +9494 @@
 #endif
   p = (LONG64*)soap_id_enter(soap, soap->id, p, t, sizeof(LONG64), 0, NULL, NULL, NULL);
-  if (p)
+  if (*soap->href)
+    p = (LONG64*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(LONG64), 0, NULL);
+  else if (p)
   { if (soap_s2LONG64(soap, soap_value(soap), p))
       return NULL;
   }
-  p = (LONG64*)soap_id_forward(soap, soap->href, p, t, 0, sizeof(LONG64), 0, NULL);
   if (soap->body && soap_element_end_in(soap, tag))
     return NULL;
@@ -7466 +9539 @@
     char *r;
     n = soap_strtol(s, &r, 10);
-    if (*r || n < -128 || n > 127)
+    if (s == r || *r || n < -128 || n > 127)
       soap->error = SOAP_TYPE;
     *p = (char)n;
@@ -7480 +9553 @@
 SOAP_FMAC2
 soap_inbyte(struct soap *soap, const char *tag, char *p, const char *type, int t)
-{ if (soap_element_begin_in(soap, tag, 0))
+{ if (soap_element_begin_in(soap, tag, 0, NULL))
     return NULL;
 #ifndef WITH_LEAN
@@ -7492 +9565 @@
 #endif
   p = (char*)soap_id_enter(soap, soap->id, p, t, sizeof(char), 0, NULL, NULL, NULL);
-  if (p)
+  if (*soap->href)
+    p = (char*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(char), 0, NULL);
+  else if (p)
   { if (soap_s2byte(soap, soap_value(soap), p))
       return NULL;
   }
-  p = (char*)soap_id_forward(soap, soap->href, p, t, 0, sizeof(char), 0, NULL);
   if (soap->body && soap_element_end_in(soap, tag))
     return NULL;
@@ -7536 +9610 @@
     char *r;
     n = soap_strtol(s, &r, 10);
-    if (*r || n < -32768 || n > 32767)
+    if (s == r || *r || n < -32768 || n > 32767)
       soap->error = SOAP_TYPE;
     *p = (short)n;
@@ -7550 +9624 @@
 SOAP_FMAC2
 soap_inshort(struct soap *soap, const char *tag, short *p, const char *type, int t)
-{ if (soap_element_begin_in(soap, tag, 0))
+{ if (soap_element_begin_in(soap, tag, 0, NULL))
     return NULL;
 #ifndef WITH_LEAN
@@ -7563 +9637 @@
 #endif
   p = (short*)soap_id_enter(soap, soap->id, p, t, sizeof(short), 0, NULL, NULL, NULL);
-  if (p)
+  if (*soap->href)
+    p = (short*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(short), 0, NULL);
+  else if (p)
   { if (soap_s2short(soap, soap_value(soap), p))
       return NULL;
   }
-  p = (short*)soap_id_forward(soap, soap->href, p, t, 0, sizeof(short), 0, NULL);
   if (soap->body && soap_element_end_in(soap, tag))
     return NULL;
@@ -7580 +9655 @@
 SOAP_FMAC2
 soap_float2s(struct soap *soap, float n)
-{ const char *s;
+{ char *s;
   if (soap_isnan((double)n))
-    s = "NaN";
-  else if (soap_ispinff(n))
-    s = "INF";
-  else if (soap_isninff(n))
-    s = "-INF";
-  else
-  { sprintf(soap->tmpbuf, soap->float_format, n);
-    s = soap->tmpbuf;
-  }
-  return s;
+    return "NaN";
+  if (soap_ispinff(n))
+    return "INF";
+  if (soap_isninff(n))
+    return "-INF";
+  s = soap->tmpbuf;
+#if defined(HAVE_SPRINTF_L)
+  sprintf_l(s, soap->c_locale, soap->float_format, n);
+#else
+  sprintf(s, soap->float_format, n);
+  s = strchr(s, ',');   /* convert decimal comma to DP */
+  if (s)
+    *s = '.';
+#endif
+  return soap->tmpbuf;
 }
 #endif
@@ -7615 +9695 @@
 soap_s2float(struct soap *soap, const char *s, float *p)
 { if (s)
-  { if (!soap_tag_cmp(s, "INF"))
+  { if (!*s)
+      return soap->error = SOAP_TYPE;
+    if (!soap_tag_cmp(s, "INF"))
       *p = FLT_PINFTY;
     else if (!soap_tag_cmp(s, "+INF"))
@@ -7625 +9707 @@
     else
     {
-#ifdef HAVE_STRTOD
+/* On some systems, strtof appears to be broken or doesn't link: use with caution */
+#if defined(HAVE_STRTOF_L)
+      char *r;
+      *p = strtof_l((char*)s, &r, soap->c_locale);
+      if (*r)
+#elif defined(HAVE_STRTOD_L)
+      char *r;
+      *p = (float)strtod_l(s, &r, soap->c_locale);
+      if (*r)
+#elif defined(HAVE_STRTOF)
+      char *r;
+      *p = strtof((char*)s, &r);
+      if (*r)
+#elif defined(HAVE_STRTOD)
       char *r;
       *p = (float)strtod(s, &r);
       if (*r)
 #endif
-#ifdef HAVE_SSCANF
-        if (sscanf(s, soap->float_format, p) != 1)
+      {
+#if defined(HAVE_SSCANF_L) && !defined(HAVE_STRTOF_L) && !defined(HAVE_STRTOD_L)
+        if (sscanf_l(s, soap->c_locale, "%g", p) != 1)
+          soap->error = SOAP_TYPE;
+#elif defined(HAVE_SSCANF)
+        if (sscanf(s, "%g", p) != 1)
           soap->error = SOAP_TYPE;
 #else
         soap->error = SOAP_TYPE;
 #endif
+      }
     }
   }
@@ -7676 +9776 @@
 SOAP_FMAC2
 soap_infloat(struct soap *soap, const char *tag, float *p, const char *type, int t)
-{ if (soap_element_begin_in(soap, tag, 0))
+{ if (soap_element_begin_in(soap, tag, 0, NULL))
     return NULL;
 #ifndef WITH_LEAN
@@ -7683 +9783 @@
 #endif
   p = (float*)soap_id_enter(soap, soap->id, p, t, sizeof(float), 0, NULL, NULL, NULL);
-  if (p)
+  if (*soap->href)
+    p = (float*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(float), 0, NULL);
+  else if (p)
   { if (soap_s2float(soap, soap_value(soap), p))
       return NULL;
   }
-  p = (float*)soap_id_forward(soap, soap->href, p, t, 0, sizeof(float), 0, NULL);
   if (soap->body && soap_element_end_in(soap, tag))
     return NULL;
@@ -7700 +9801 @@
 SOAP_FMAC2
 soap_double2s(struct soap *soap, double n)
-{ const char *s;
+{ char *s;
   if (soap_isnan(n))
-    s = "NaN";
-  else if (soap_ispinfd(n))
-    s = "INF";
-  else if (soap_isninfd(n))
-    s = "-INF";
-  else
-  { sprintf(soap->tmpbuf, soap->double_format, n);
-    s = soap->tmpbuf;
-  }
-  return s;
+    return "NaN";
+  if (soap_ispinfd(n))
+    return "INF";
+  if (soap_isninfd(n))
+    return "-INF";
+  s = soap->tmpbuf;
+#if defined(HAVE_SPRINTF_L)
+  sprintf_l(s, soap->c_locale, soap->double_format, n);
+#else
+  sprintf(s, soap->double_format, n);
+  s = strchr(s, ',');   /* convert decimal comma to DP */
+  if (s)
+    *s = '.';
+#endif
+  return soap->tmpbuf;
 }
 #endif
@@ -7735 +9841 @@
 soap_s2double(struct soap *soap, const char *s, double *p)
 { if (s)
-  { if (!soap_tag_cmp(s, "INF"))
+  { if (!*s)
+      return soap->error = SOAP_TYPE;
+    if (!soap_tag_cmp(s, "INF"))
       *p = DBL_PINFTY;
     else if (!soap_tag_cmp(s, "+INF"))
@@ -7745 +9853 @@
     else
     {
-#ifdef HAVE_STRTOD
+#if defined(HAVE_STRTOD_L)
+      char *r;
+      *p = strtod_l(s, &r, soap->c_locale);
+      if (*r)
+#elif defined(HAVE_STRTOD)
       char *r;
       *p = strtod(s, &r);
       if (*r)
 #endif
-#ifdef HAVE_SSCANF
-        if (sscanf(s, soap->double_format, p) != 1)
+      {
+#if defined(HAVE_SSCANF_L) && !defined(HAVE_STRTOF_L) && !defined(HAVE_STRTOD_L)
+        if (sscanf_l(s, soap->c_locale, "%lg", p) != 1)
+          soap->error = SOAP_TYPE;
+#elif defined(HAVE_SSCANF)
+        if (sscanf(s, "%lg", p) != 1)
           soap->error = SOAP_TYPE;
 #else
         soap->error = SOAP_TYPE;
 #endif
+      }
     }
   }
@@ -7768 +9885 @@
 SOAP_FMAC2
 soap_indouble(struct soap *soap, const char *tag, double *p, const char *type, int t)
-{ if (soap_element_begin_in(soap, tag, 0))
+{ if (soap_element_begin_in(soap, tag, 0, NULL))
     return NULL;
 #ifndef WITH_LEAN
@@ -7775 +9892 @@
 #endif
   p = (double*)soap_id_enter(soap, soap->id, p, t, sizeof(double), 0, NULL, NULL, NULL);
-  if (p)
+  if (*soap->href)
+    p = (double*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(double), 0, NULL);
+  else if (p)
   { if (soap_s2double(soap, soap_value(soap), p))
       return NULL;
   }
-  p = (double*)soap_id_forward(soap, soap->href, p, t, 0, sizeof(double), 0, NULL);
   if (soap->body && soap_element_end_in(soap, tag))
     return NULL;
@@ -7819 +9937 @@
     char *r;
     n = soap_strtoul(s, &r, 10);
-    if (*r || n > 255)
+    if (s == r || *r || n > 255)
       soap->error = SOAP_TYPE;
     *p = (unsigned char)n;
@@ -7833 +9951 @@
 SOAP_FMAC2
 soap_inunsignedByte(struct soap *soap, const char *tag, unsigned char *p, const char *type, int t)
-{ if (soap_element_begin_in(soap, tag, 0))
+{ if (soap_element_begin_in(soap, tag, 0, NULL))
     return NULL;
 #ifndef WITH_LEAN
@@ -7845 +9963 @@
 #endif
   p = (unsigned char*)soap_id_enter(soap, soap->id, p, t, sizeof(unsigned char), 0, NULL, NULL, NULL);
-  if (p)
+  if (*soap->href)
+    p = (unsigned char*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(unsigned char), 0, NULL);
+  else if (p)
   { if (soap_s2unsignedByte(soap, soap_value(soap), p))
       return NULL;
   }
-  p = (unsigned char*)soap_id_forward(soap, soap->href, p, t, 0, sizeof(unsigned char), 0, NULL);
   if (soap->body && soap_element_end_in(soap, tag))
     return NULL;
@@ -7857 +9976 @@
 
 /******************************************************************************/
-#ifndef WITH_LEAN
+#ifndef PALM_2
 SOAP_FMAC1
 const char*
@@ -7867 +9986 @@
 
 /******************************************************************************/
-#ifndef WITH_LEAN
+#ifndef PALM_2
 SOAP_FMAC1
 int
@@ -7880 +9999 @@
 
 /******************************************************************************/
-#ifndef WITH_LEAN
+#ifndef PALM_2
 SOAP_FMAC1
 int
@@ -7889 +10008 @@
     char *r;
     n = soap_strtoul(s, &r, 10);
-    if (*r || n > 65535)
+    if (s == r || *r || n > 65535)
       soap->error = SOAP_TYPE;
     *p = (unsigned short)n;
@@ -7898 +10017 @@
 
 /******************************************************************************/
-#ifndef WITH_LEAN
+#ifndef PALM_2
 SOAP_FMAC1
 unsigned short *
 SOAP_FMAC2
 soap_inunsignedShort(struct soap *soap, const char *tag, unsigned short *p, const char *type, int t)
-{ if (soap_element_begin_in(soap, tag, 0))
+{ if (soap_element_begin_in(soap, tag, 0, NULL))
     return NULL;
 #ifndef WITH_LEAN
@@ -7916 +10035 @@
 #endif
   p = (unsigned short*)soap_id_enter(soap, soap->id, p, t, sizeof(unsigned short), 0, NULL, NULL, NULL);
-  if (p)
+  if (*soap->href)
+    p = (unsigned short*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(unsigned short), 0, NULL);
+  else if (p)
   { if (soap_s2unsignedShort(soap, soap_value(soap), p))
       return NULL;
   }
-  p = (unsigned short*)soap_id_forward(soap, soap->href, p, t, 0, sizeof(unsigned short), 0, NULL);
   if (soap->body && soap_element_end_in(soap, tag))
     return NULL;
@@ -7958 +10078 @@
 { if (s)
   { char *r;
+#ifndef WITH_NOIO
+#ifndef WITH_LEAN
+    soap_reset_errno;
+#endif
+#endif
     *p = (unsigned int)soap_strtoul(s, &r, 10);
-    if (*r)
+    if ((s == r && (soap->mode & SOAP_XML_STRICT)) || *r
+#ifndef WITH_NOIO
+#ifndef WITH_LEAN
+     || soap_errno == SOAP_ERANGE
+#endif
+#endif
+    )
       soap->error = SOAP_TYPE;
   }
@@ -7972 +10103 @@
 SOAP_FMAC2
 soap_inunsignedInt(struct soap *soap, const char *tag, unsigned int *p, const char *type, int t)
-{ if (soap_element_begin_in(soap, tag, 0))
+{ if (soap_element_begin_in(soap, tag, 0, NULL))
     return NULL;
 #ifndef WITH_LEAN
@@ -7986 +10117 @@
 #endif
   p = (unsigned int*)soap_id_enter(soap, soap->id, p, t, sizeof(unsigned int), 0, NULL, NULL, NULL);
-  if (p)
+  if (*soap->href)
+    p = (unsigned int*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(unsigned int), 0, NULL);
+  else if (p)
   { if (soap_s2unsignedInt(soap, soap_value(soap), p))
       return NULL;
   }
-  p = (unsigned int*)soap_id_forward(soap, soap->href, p, t, 0, sizeof(unsigned int), 0, NULL);
   if (soap->body && soap_element_end_in(soap, tag))
     return NULL;
@@ -8029 +10161 @@
 { if (s)
   { char *r;
+#ifndef WITH_NOIO
+#ifndef WITH_LEAN
+    soap_reset_errno;
+#endif
+#endif
     *p = soap_strtoul(s, &r, 10);
-    if (*r)
+    if ((s == r && (soap->mode & SOAP_XML_STRICT)) || *r
+#ifndef WITH_NOIO
+#ifndef WITH_LEAN
+     || soap_errno == SOAP_ERANGE
+#endif
+#endif
+    )
       soap->error = SOAP_TYPE;
   }
@@ -8043 +10186 @@
 SOAP_FMAC2
 soap_inunsignedLong(struct soap *soap, const char *tag, unsigned long *p, const char *type, int t)
-{ if (soap_element_begin_in(soap, tag, 0))
+{ if (soap_element_begin_in(soap, tag, 0, NULL))
     return NULL;
 #ifndef WITH_LEAN
@@ -8057 +10200 @@
 #endif
   p = (unsigned long*)soap_id_enter(soap, soap->id, p, t, sizeof(unsigned long), 0, NULL, NULL, NULL);
-  if (p)
+  if (*soap->href)
+    p = (unsigned long*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(unsigned long), 0, NULL);
+  else if (p)
   { if (soap_s2unsignedLong(soap, soap_value(soap), p))
       return NULL;
   }
-  p = (unsigned long*)soap_id_forward(soap, soap->href, p, t, 0, sizeof(unsigned long), 0, NULL);
   if (soap->body && soap_element_end_in(soap, tag))
     return NULL;
@@ -8098 +10242 @@
 SOAP_FMAC2
 soap_s2ULONG64(struct soap *soap, const char *s, ULONG64 *p)
-{ if (s && sscanf(s, SOAP_ULONG_FORMAT, p) != 1)
-    soap->error = SOAP_TYPE;
+{ if (s)
+  {
+#ifdef HAVE_STRTOULL
+    char *r;
+#ifndef WITH_NOIO
+#ifndef WITH_LEAN
+    soap_reset_errno;
+#endif
+#endif
+    *p = strtoull(s, &r, 10);
+    if ((s == r && (soap->mode & SOAP_XML_STRICT)) || *r
+#ifndef WITH_NOIO
+#ifndef WITH_LEAN
+       || soap_errno == SOAP_ERANGE
+#endif
+#endif
+      )
+#else
+#ifdef HAVE_SSCANF
+    if (sscanf(s, SOAP_ULONG_FORMAT, p) != 1)
+#endif
+#endif
+      soap->error = SOAP_TYPE;
+  }
   return soap->error;
 }
@@ -8110 +10276 @@
 SOAP_FMAC2
 soap_inULONG64(struct soap *soap, const char *tag, ULONG64 *p, const char *type, int t)
-{ if (soap_element_begin_in(soap, tag, 0))
+{ if (soap_element_begin_in(soap, tag, 0, NULL))
     return NULL;
   if (*soap->type
@@ -8125 +10291 @@
   }
   p = (ULONG64*)soap_id_enter(soap, soap->id, p, t, sizeof(ULONG64), 0, NULL, NULL, NULL);
-  if (p)
+  if (*soap->href)
+    p = (ULONG64*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(ULONG64), 0, NULL);
+  else if (p)
   { if (soap_s2ULONG64(soap, soap_value(soap), p))
       return NULL;
   }
-  p = (ULONG64*)soap_id_forward(soap, soap->href, p, t, 0, sizeof(ULONG64), 0, NULL);
   if (soap->body && soap_element_end_in(soap, tag))
     return NULL;
@@ -8142 +10309 @@
 SOAP_FMAC2
 soap_s2string(struct soap *soap, const char *s, char **t)
-{ *t = NULL;
-  if (s && !(*t = soap_strdup(soap, s)))
-    soap->error = SOAP_EOM;
+{ if (s)
+  { if (!(*t = soap_strdup(soap, s)))
+      return soap->error = SOAP_EOM;
+    if (!(soap->mode & (SOAP_ENC_LATIN | SOAP_C_UTFSTRING)))
+    { /* TODO: consider truncating UTF8 to ASCII for regular XML attribute strings? */
+    }
+  }
   return soap->error;
 }
@@ -8156 +10327 @@
 soap_s2QName(struct soap *soap, const char *s, char **t)
 { if (s)
-  { struct soap_nlist *np;
-    const char *p;
-    if (!strncmp(s, "xml:", 4))
-    { *t = soap_strdup(soap, s);
-      return SOAP_OK;
-    }
-    np = soap->nlist;
-    p = strchr(s, ':');
-    if (p)
-    { register int n = p - s;
-      while (np && (strncmp(np->id, s, n) || np->id[n]))
-        np = np->next;
-      p++;
+  { soap->labidx = 0;
+    DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Normalized namespace(s) of QNames '%s'", s));
+    /* convert (by prefix normalize prefix) all QNames in s */
+    for (;;)
+    { size_t n;
+      struct soap_nlist *np;
+      register const char *p;
+      /* skip blanks */
+      while (*s && soap_blank(*s))
+        s++;
+      if (!*s)
+        break;
+      /* find next QName */
+      n = 1;
+      while (s[n] && !soap_blank(s[n]))
+        n++;
+      np = soap->nlist;
+      /* if there is no namespace stack, or prefix is "xml" then copy string */
+      if (!np || !strncmp(s, "xml:", 4))
+      { soap_append_lab(soap, s, n);
+      }
+      else /* we normalize the QName by replacing its prefix */
+      { p = strchr(s, ':');
+        if (p)
+        { size_t k = p - s;
+          while (np && (strncmp(np->id, s, k) || np->id[k]))
+            np = np->next;
+          p++;
+        }
+        else
+        { while (np && *np->id)
+            np = np->next;
+          p = s;
+        }
+        /* replace prefix */
+        if (np)
+        { if (np->index >= 0 && soap->local_namespaces)
+          { const char *q = soap->local_namespaces[np->index].id;
+            if (q)
+              soap_append_lab(soap, q, strlen(q));
+          }
+          else if (np->ns)
+          { soap_append_lab(soap, "\"", 1);
+            soap_append_lab(soap, np->ns, strlen(np->ns));
+            soap_append_lab(soap, "\"", 1);
+          }
+          else
+          { 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));
+            return soap->error = SOAP_NAMESPACE; 
+          }
+        }
+        else /* no namespace: assume default "" namespace */
+        { soap_append_lab(soap, "\"\"", 2);
+        } 
+        soap_append_lab(soap, ":", 1);
+        soap_append_lab(soap, p, n - (p-s));
+      }
+      /* advance to next and add spacing */
+      s += n;
+      if (*s)
+        soap_append_lab(soap, " ", 1);
+    }
+    soap_append_lab(soap, SOAP_STR_EOS, 1);
+    *t = soap_strdup(soap, soap->labbuf);
+    DBGLOG(TEST, SOAP_MESSAGE(fdebug, " into '%s'\n", *t));
+  }
+  return soap->error;
+}
+#endif
+
+/******************************************************************************/
+#ifndef PALM_2
+SOAP_FMAC1
+const char*
+SOAP_FMAC2
+soap_QName2s(struct soap *soap, const char *s)
+{ const char *t = NULL;
+  if (s)
+  { soap->labidx = 0;
+    for (;;)
+    { size_t n;
+      /* skip blanks */
+      while (*s && soap_blank(*s))
+        s++;
+      if (!*s)
+        break;
+      /* find next QName */
+      n = 1;
+      while (s[n] && !soap_blank(s[n]))
+        n++;
+      /* normal prefix: pass string as is */
+      if (*s != '"')
+      { soap_append_lab(soap, s, n);
+#ifndef WITH_LEAN
+        if ((soap->mode & SOAP_XML_CANONICAL))
+        { const char *r = strchr(s, ':');
+          if (r)
+            soap_utilize_ns(soap, s, r - s);
+        }
+#endif
+      }
+      else /* URL-based string prefix */
+      { const char *q;
+        s++;
+        q = strchr(s, '"');
+        if (q)
+        { struct Namespace *p = soap->local_namespaces;
+          if (p)
+          { for (; p->id; p++)
+            { if (p->ns)
+                if (!soap_tag_cmp(s, p->ns))
+                  break;
+              if (p->in)
+                if (!soap_tag_cmp(s, p->in))
+                  break;
+            }
+          }
+          /* URL is in the namespace table? */
+          if (p && p->id)
+          { soap_append_lab(soap, p->id, strlen(p->id));
+          }
+          else /* not in namespace table: create xmlns binding */
+          { char *r = soap_strdup(soap, s);
+            r[q-s] = '\0';
+            sprintf(soap->tmpbuf, "xmlns:_%d", soap->idnum++);
+            soap_set_attr(soap, soap->tmpbuf, r);
+            soap_append_lab(soap, soap->tmpbuf + 6, strlen(soap->tmpbuf + 6));
+          }
+          soap_append_lab(soap, q + 1, n - (q-s) - 1);
+        }
+      }
+      /* advance to next and add spacing */
+      s += n;
+      if (*s)
+        soap_append_lab(soap, " ", 1);
+    }
+    soap_append_lab(soap, SOAP_STR_EOS, 1);
+    t = soap_strdup(soap, soap->labbuf);
+  }
+  return t;
+}
+#endif
+
+/******************************************************************************/
+#ifndef WITH_LEAN
+SOAP_FMAC1
+int
+SOAP_FMAC2
+soap_s2wchar(struct soap *soap, const char *s, wchar_t **t)
+{ if (s)
+  { wchar_t *r;
+    *t = r = (wchar_t*)soap_malloc(soap, sizeof(wchar_t) * (strlen(s) + 1));
+    if (!r)
+      return soap->error;
+    if (soap->mode & SOAP_ENC_LATIN)
+    { while (*s)
+        *r++ = (wchar_t)*s++;
     }
     else
-    { while (np && *np->id)
-        np = np->next;
-      p = s;
-    }
-    if (np)
-    { if (np->index >= 0 && soap->local_namespaces)
-      { register const char *q = soap->local_namespaces[np->index].id;
-        if (q)
-        { if ((*t = (char*)soap_malloc(soap, strlen(p) + strlen(q) + 2)))
-            sprintf(*t, "%s:%s", q, p);
-          return SOAP_OK;
+    { /* Convert UTF8 to wchar */
+      while (*s)
+      { register soap_wchar c, c1, c2, c3, c4;
+        c = (unsigned char)*s++;
+        if (c < 0x80)
+          *r++ = (wchar_t)c;
+        else
+        { c1 = (soap_wchar)*s++ & 0x3F;
+          if (c < 0xE0)
+            *r++ = (wchar_t)(((soap_wchar)(c & 0x1F) << 6) | c1);
+          else
+          { c2 = (soap_wchar)*s++ & 0x3F;
+            if (c < 0xF0)
+              *r++ = (wchar_t)(((soap_wchar)(c & 0x0F) << 12) | (c1 << 6) | c2);
+            else
+            { c3 = (soap_wchar)*s++ & 0x3F;
+              if (c < 0xF8)
+                *r++ = (wchar_t)(((soap_wchar)(c & 0x07) << 18) | (c1 << 12) | (c2 << 6) | c3);
+              else
+              { c4 = (soap_wchar)*s++ & 0x3F;
+                if (c < 0xFC)
+                  *r++ = (wchar_t)(((soap_wchar)(c & 0x03) << 24) | (c1 << 18) | (c2 << 12) | (c3 << 6) | c4);
+                else
+                  *r++ = (wchar_t)(((soap_wchar)(c & 0x01) << 30) | (c1 << 24) | (c2 << 18) | (c3 << 12) | (c4 << 6) | (soap_wchar)(*s++ & 0x3F));
+              }
+            }
+          }
         }
       }
-      if (np->ns)
-      { if ((*t = (char*)soap_malloc(soap, strlen(p) + strlen(np->ns) + 4)))
-          sprintf(*t, "\"%s\":%s", np->ns, p);
-        return SOAP_OK;
-      }
-      DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Namespace prefix of '%s' not defined (index=%d, URI=%s)\n", s, np->index, np->ns?np->ns:""));
-      return soap->error = SOAP_NAMESPACE; 
-    }
-    DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Namespace prefix of '%s' not defined, assuming empty namespace\n", s));
-    if ((*t = (char*)soap_malloc(soap, strlen(p) + 4)))
-      sprintf(*t, "\"\":%s", p);
-  }
-  return soap->error;
-}
-#endif
-
-/******************************************************************************/
-#ifndef PALM_2
+    }
+    *r = L'\0';
+  }
+  return SOAP_OK;
+}
+#endif
+
+/******************************************************************************/
+#ifndef WITH_LEAN
 SOAP_FMAC1
 const char*
 SOAP_FMAC2
-soap_QName2s(struct soap *soap, const char *s)
-{ struct Namespace *p;
-  char *t;
-  int n;
-  if (!s || *s != '"')
-    return s;
-  s++;
-  if ((p = soap->local_namespaces))
-  { for (; p->id; p++)
-    { if (p->ns)
-        if (!soap_tag_cmp(s, p->ns))
-          break;
-      if (p->in)
-        if (!soap_tag_cmp(s, p->in))
-          break;
-    }
-    if (p && p->id)
-    { s = strchr(s, '"');
-      if (s)
-      { t = (char*)soap_malloc(soap, strlen(p->id) + strlen(s));
-        strcpy(t, p->id);
-        strcat(t, s + 1);
-        return t;
-      }
-    }
-  }
-  t = (char*)strchr(s, '"');
-  if (t)
-    n = t - s;
-  else
-    n = 0;
-  t = soap_strdup(soap, s);
-  t[n] = '\0';
-  sprintf(soap->tmpbuf, "xmlns:_%lu", soap->idnum++);
-  soap_set_attr(soap, soap->tmpbuf, t);
-  s = strchr(s, '"');
-  if (s)
-  { t = (char*)soap_malloc(soap, strlen(soap->tmpbuf) + strlen(s) - 6);
-    strcpy(t, soap->tmpbuf + 6);
-    strcat(t, s + 1);
-  }
-  return t;
+soap_wchar2s(struct soap *soap, const wchar_t *s)
+{ register soap_wchar c;
+  register char *r, *t;
+  const wchar_t *q = s;
+  size_t n = 0;
+  while ((c = *q++))
+  { if (c > 0 && c < 0x80)
+      n++;
+    else
+      n += 6;
+  }
+  r = t = (char*)soap_malloc(soap, n + 1);
+  if (r)
+  { /* Convert wchar to UTF8 */
+    while ((c = *s++))
+    { if (c > 0 && c < 0x80)
+        *t++ = (char)c;
+      else
+      { if (c < 0x0800)
+          *t++ = (char)(0xC0 | ((c >> 6) & 0x1F));
+        else
+        { if (c < 0x010000)
+            *t++ = (char)(0xE0 | ((c >> 12) & 0x0F));
+          else
+          { if (c < 0x200000)
+              *t++ = (char)(0xF0 | ((c >> 18) & 0x07));
+            else
+            { if (c < 0x04000000)
+                *t++ = (char)(0xF8 | ((c >> 24) & 0x03));
+              else
+              { *t++ = (char)(0xFC | ((c >> 30) & 0x01));
+                *t++ = (char)(0x80 | ((c >> 24) & 0x3F));
+              }
+              *t++ = (char)(0x80 | ((c >> 18) & 0x3F));
+            }     
+            *t++ = (char)(0x80 | ((c >> 12) & 0x3F));
+          }
+          *t++ = (char)(0x80 | ((c >> 6) & 0x3F));
+        }
+        *t++ = (char)(0x80 | (c & 0x3F));
+      }
+    }
+    *t = '\0';
+  }
+  return r;
 }
 #endif
@@ -8257 +10582 @@
 soap_outstring(struct soap *soap, const char *tag, int id, char *const*p, const char *type, int n) 
 { id = soap_element_id(soap, tag, id, *p, NULL, 0, type, n);
-  if (id < 0
-   || soap_element_begin_out(soap, tag, id, type)
+  if (id < 0)
+    return soap->error;
+  if (!**p && (soap->mode & SOAP_C_NILSTRING))
+    return soap_element_null(soap, tag, id, type);
+  if (soap_element_begin_out(soap, tag, id, type)
    || soap_string_out(soap, *p, 0)
    || soap_element_end_out(soap, tag))
@@ -8272 +10600 @@
 SOAP_FMAC2
 soap_instring(struct soap *soap, const char *tag, char **p, const char *type, int t, int flag, long minlen, long maxlen)
-{ if (soap_element_begin_in(soap, tag, 1))
-    return NULL;
+{ if (soap_element_begin_in(soap, tag, 1, NULL))
+  { if (!tag || *tag != '-' || soap->error != SOAP_NO_TAG)
+      return NULL;
+    soap->error = SOAP_OK;
+  }
   if (!p)
-    if (!(p = (char**)soap_malloc(soap, sizeof(char*))))
+  { if (!(p = (char**)soap_malloc(soap, sizeof(char*))))
       return NULL;
+  }
   if (soap->body)
   { *p = soap_string_in(soap, flag, minlen, maxlen);
     if (!*p || !(char*)soap_id_enter(soap, soap->id, *p, t, sizeof(char*), 0, NULL, NULL, NULL))
       return NULL;
-  }
+    if (!**p && tag && *tag == '-')
+    { soap->error = SOAP_NO_TAG;
+      return NULL;
+    }
+  }
+  else if (tag && *tag == '-')
+  { soap->error = SOAP_NO_TAG;
+    return NULL;
+  }
+  else if (soap->null)
+    *p = NULL;
   else
-    *p = NULL;
-  p = (char**)soap_id_lookup(soap, soap->href, (void**)p, t, sizeof(char**), 0);
+    *p = soap_strdup(soap, SOAP_STR_EOS);
+  if (*soap->href)
+    p = (char**)soap_id_lookup(soap, soap->href, (void**)p, t, sizeof(char**), 0);
   if (soap->body && soap_element_end_in(soap, tag))
     return NULL;
@@ -8292 +10635 @@
 
 /******************************************************************************/
+#ifndef WITH_LEANER
 #ifndef PALM_2
 SOAP_FMAC1
@@ -8298 +10642 @@
 soap_outwstring(struct soap *soap, const char *tag, int id, wchar_t *const*p, const char *type, int n) 
 { id = soap_element_id(soap, tag, id, *p, NULL, 0, type, n);
-  if (id < 0
-   || soap_element_begin_out(soap, tag, id, type)
+  if (id < 0)
+    return soap->error;
+  if (!**p && (soap->mode & SOAP_C_NILSTRING))
+    return soap_element_null(soap, tag, id, type);
+  if (soap_element_begin_out(soap, tag, id, type)
    || soap_wstring_out(soap, *p, 0)
    || soap_element_end_out(soap, tag))
@@ -8306 +10653 @@
 }
 #endif
-
-/******************************************************************************/
+#endif
+
+/******************************************************************************/
+#ifndef WITH_LEANER
 #ifndef PALM_2
 SOAP_FMAC1
@@ -8313 +10662 @@
 SOAP_FMAC2
 soap_inwstring(struct soap *soap, const char *tag, wchar_t **p, const char *type, int t, long minlen, long maxlen)
-{ if (soap_element_begin_in(soap, tag, 1))
-    return NULL;
+{ if (soap_element_begin_in(soap, tag, 1, NULL))
+  { if (!tag || *tag != '-' || soap->error != SOAP_NO_TAG)
+      return NULL;
+    soap->error = SOAP_OK;
+  }
   if (!p)
-    if (!(p = (wchar_t**)soap_malloc(soap, sizeof(wchar_t*))))
+  { if (!(p = (wchar_t**)soap_malloc(soap, sizeof(wchar_t*))))
       return NULL;
+  }
   if (soap->body)
   { *p = soap_wstring_in(soap, 1, minlen, maxlen);
     if (!*p || !(wchar_t*)soap_id_enter(soap, soap->id, *p, t, sizeof(wchar_t*), 0, NULL, NULL, NULL))
       return NULL;
-  }
+    if (!**p && tag && *tag == '-')
+    { soap->error = SOAP_NO_TAG;
+      return NULL;
+    }
+  }
+  else if (tag && *tag == '-')
+  { soap->error = SOAP_NO_TAG;
+    return NULL;
+  }
+  else if (soap->null)
+    *p = NULL;
   else
-    *p = NULL;
-  p = (wchar_t**)soap_id_lookup(soap, soap->href, (void**)p, t, sizeof(wchar_t**), 0);
+    *p = soap_wstrdup(soap, (wchar_t*)SOAP_STR_EOS);
+  if (*soap->href)
+    p = (wchar_t**)soap_id_lookup(soap, soap->href, (void**)p, t, sizeof(wchar_t**), 0);
   if (soap->body && soap_element_end_in(soap, tag))
     return NULL;
@@ -8331 +10695 @@
 }
 #endif
+#endif
 
 /******************************************************************************/
 #ifndef WITH_LEAN
-static time_t
+SOAP_FMAC1
+time_t
+SOAP_FMAC2
 soap_timegm(struct tm *T)
 {
 #if defined(HAVE_TIMEGM)
   return timegm(T);
-#elif defined(HAVE_GETTIMEOFDAY)
-  struct timezone t;
-  struct timeval tv;
-  memset((void*)&t, 0, sizeof(t));
-  gettimeofday(&tv, &t);
-  T->tm_min -= t.tz_minuteswest - (t.tz_dsttime != 0)*60;
-  T->tm_isdst = 0;
-  return mktime(T);
-/* WR[ */
-  /* The following define was added for VxWorks*/
-#elif defined(HAVE_MKTIME)
-  /* FOR VXWORKS:
-  vxWorks does not seem to have any variable representation of time zones, but
-  timezone information can be set in INSTALL_DIR/target/h/private/timeP.h header
-  file, by setting the ZONEBUFFER define.  The ZONEBUFFER define follows this 
-  format:
-    name_of_zone:<(unused)>:time_in_minutes_from_UTC:daylight_start:daylight_end 
-  To calculate local time, the value of time_in_minutes_from_UTC is subtracted
-  from UTC; time_in_minutes_from_UTC must be positive. Daylight information is 
-  expressed as mmddhh (month-day-hour), for example: 
-    UTC::0:040102:100102
-  */
-  return mktime(T);
-/* ]WR */
-#elif defined(HAVE_FTIME)
-  struct timeb t;
-  memset((void*)&t, 0, sizeof(t));
-  t.timezone = 0;
-  t.dstflag = -1;
-  ftime(&t);
-  T->tm_min -= t.timezone - (t.dstflag != 0)*60;
-  T->tm_isdst = 0;
-  return mktime(T);
 #else
-#warning "time_t (de)serialization is not MT safe on this platform"
-  time_t t;
-  char *tz = getenv("TZ");
-  putenv("TZ=UTC");
-  tzset();
+  time_t t, g, z;
+  struct tm tm;
   t = mktime(T);
-  if (tz)
-  { char tmp[16];
-    strcpy(tmp, "TZ=");
-    strncat(tmp, tz, 12);
-    tmp[15] = '\0';
-    putenv(tmp);
-  }
-  else
-    putenv("TZ=");
-  tzset();
-  return t;
+  if (t == (time_t)-1)
+    return (time_t)-1;
+#ifdef HAVE_GMTIME_R
+  gmtime_r(&t, &tm);
+#else
+  tm = *gmtime(&t);
+#endif
+  tm.tm_isdst = 0;
+  g = mktime(&tm);
+  if (g == (time_t)-1)
+    return (time_t)-1;
+  z = g - t;
+  return t - z;
 #endif
 }
@@ -8400 +10733 @@
 SOAP_FMAC2
 soap_dateTime2s(struct soap *soap, time_t n)
-{ struct tm T;
-  struct tm *pT = &T;
+{ struct tm T, *pT = &T;
 #if defined(HAVE_GMTIME_R)
   if (gmtime_r(&n, pT))
     strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%SZ", pT);
-/* WR[ */
-  /* The following defines were added for VxWorks*/
-#elif defined(HAVE_PGMTIME_R)
-  if (gmtime_r(&n, pT))
-    strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%SZ", pT);
-#elif defined(HAVE_PGMTIME)
-  if (gmtime(&n, pT))
-    strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%SZ", pT);
-/* ]WR */
 #elif defined(HAVE_GMTIME)
   if ((pT = gmtime(&n)))
@@ -8425 +10748 @@
     gettimeofday(&tv, &tz);
     strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT);
-    sprintf(soap->tmpbuf + strlen(soap->tmpbuf), "%+03d:%02d", -tz.tz_minuteswest/60+(tz.tz_dsttime!=0), abs(tz.tz_minuteswest)%60);
+    sprintf(soap->tmpbuf + strlen(soap->tmpbuf), "%+03d:%02d", -tz.tz_minuteswest/60+(pT->tm_isdst!=0), abs(tz.tz_minuteswest)%60);
   }
 #else
@@ -8432 +10755 @@
     gettimeofday(&tv, &tz);
     strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT);
-    sprintf(soap->tmpbuf + strlen(soap->tmpbuf), "%+03d:%02d", -tz.tz_minuteswest/60+(tz.tz_dsttime!=0), abs(tz.tz_minuteswest)%60);
+    sprintf(soap->tmpbuf + strlen(soap->tmpbuf), "%+03d:%02d", -tz.tz_minuteswest/60+(pT->tm_isdst!=0), abs(tz.tz_minuteswest)%60);
   }
 #endif
@@ -8440 +10763 @@
 #if defined(HAVE_LOCALTIME_R)
   if (localtime_r(&n, pT))
-  { ftime(&t);
+  {
+#ifdef __BORLANDC__
+    ::ftime(&t);
+#else
+    ftime(&t);
+#endif
     strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT);
-    sprintf(soap->tmpbuf + strlen(soap->tmpbuf), "%+03d:%02d", -t.timezone/60+(t.dstflag!=0), abs(t.timezone)%60);
-  }
-/* WR[ */
-  /* The following defines were added for VxWorks*/
-#elif defined(HAVE_PLOCALTIME_R)
-  if (localtime_r(&n, pT))
-  { strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT);
-    sprintf(soap->tmpbuf+strlen(soap->tmpbuf), "%+03d:%02d", t.timezone/60, abs(t.timezone)%60);
-  }
-/* ]WR */
+    sprintf(soap->tmpbuf + strlen(soap->tmpbuf), "%+03d:%02d", -t.timezone/60+(pT->tm_isdst!=0), abs(t.timezone)%60);
+  }
 #else
   if ((pT = localtime(&n)))
-  { ftime(&t);
+  {
+#ifdef __BORLANDC__
+    ::ftime(&t);
+#else
+    ftime(&t);
+#endif
     strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT);
-    sprintf(soap->tmpbuf + strlen(soap->tmpbuf), "%+03d:%02d", -t.timezone/60+(t.dstflag!=0), abs(t.timezone)%60);
+    sprintf(soap->tmpbuf + strlen(soap->tmpbuf), "%+03d:%02d", -t.timezone/60+(pT->tm_isdst!=0), abs(t.timezone)%60);
   }
 #endif
@@ -8462 +10787 @@
   if (localtime_r(&n, pT))
     strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT);
-/* WR[ */
-  /* The following defines were added for VxWorks*/
-#elif defined(HAVE_PLOCALTIME_R)
-  if (localtime_r(&n, pT))
-    strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT);
-/* ]WR */
 #else
   if ((pT = localtime(&n)))
@@ -8498 +10817 @@
 soap_s2dateTime(struct soap *soap, const char *s, time_t *p)
 { if (s)
-  { struct tm T;
-    char zone[16];
+  { char zone[32];
+    struct tm T;
+    const char *t;
+    *zone = '\0';
     memset((void*)&T, 0, sizeof(T));
-    zone[sizeof(zone)-1] = '\0';
-    sscanf(s, "%d-%d-%dT%d:%d:%d%15s", &T.tm_year, &T.tm_mon, &T.tm_mday, &T.tm_hour, &T.tm_min, &T.tm_sec, zone);
+    if (strchr(s, '-'))
+      t = "%d-%d-%dT%d:%d:%d%31s";
+    else if (strchr(s, ':'))
+      t = "%4d%2d%2dT%d:%d:%d%31s";
+    else /* parse non-XSD-standard alternative ISO 8601 format */
+      t = "%4d%2d%2dT%2d%2d%2d%31s";
+    if (sscanf(s, t, &T.tm_year, &T.tm_mon, &T.tm_mday, &T.tm_hour, &T.tm_min, &T.tm_sec, zone) < 6)
+      return soap->error = SOAP_TYPE;
     if (T.tm_year == 1)
       T.tm_year = 70;
@@ -8508 +10835 @@
       T.tm_year -= 1900;
     T.tm_mon--;
-    if (*zone)
-    { if (*zone == '.')
-      { for (s = zone + 1; *s; s++)
-          if (*s < '0' || *s > '9')
-            break;
-      }
-      else
-        s = zone;
-      if (*s != 'Z')
+    if (*zone == '.')
+    { for (s = zone + 1; *s; s++)
+        if (*s < '0' || *s > '9')
+          break;
+    }
+    else
+      s = zone;
+    if (*s)
+    {
+#ifndef WITH_NOZONE
+      if (*s == '+' || *s == '-')
       { int h = 0, m = 0;
-        sscanf(s, "%d:%d", &h, &m);
-        T.tm_hour -= h;
-        if (h >= 0)
-          T.tm_min -= m;
-        else
-          T.tm_min += m;
-      }
+        if (s[3] == ':')
+        { /* +hh:mm */
+          sscanf(s, "%d:%d", &h, &m);
+          if (h < 0)
+            m = -m;
+        }
+        else /* +hhmm */
+        { m = (int)atol(s);
+          h = m / 100;
+          m = m % 100;
+        }
+        T.tm_min -= m;
+        T.tm_hour -= h;
+        /* put hour and min in range */
+        T.tm_hour += T.tm_min / 60;
+        T.tm_min %= 60;
+        if (T.tm_min < 0)
+          T.tm_min += 60;
+        T.tm_mday += T.tm_hour / 24;
+        T.tm_hour %= 24;
+        if (T.tm_hour < 0)
+          T.tm_hour += 24;
+        /* note: day of the month may be out of range, timegm() handles it */
+      }
+#endif
       *p = soap_timegm(&T);
     }
     else
-      *p = mktime(&T); /* no time zone: suppose it is localtime? */
+      *p = mktime(&T);
   }
   return soap->error;
@@ -8539 +10886 @@
 time_t *
 SOAP_FMAC2
-soap_indateTime(struct soap *soap, const char *tag, time_t *p, const char * type, int t)
-{ if (soap_element_begin_in(soap, tag, 0))
+soap_indateTime(struct soap *soap, const char *tag, time_t *p, const char *type, int t)
+{ if (soap_element_begin_in(soap, tag, 0, NULL))
     return NULL;
   if (*soap->type
@@ -8550 +10897 @@
   }
   p = (time_t*)soap_id_enter(soap, soap->id, p, t, sizeof(time_t), 0, NULL, NULL, NULL);
-  if (p)
+  if (*soap->href)
+    p = (time_t*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(time_t), 0, NULL);
+  else if (p)
   { if (soap_s2dateTime(soap, soap_value(soap), p))
       return NULL;
   }
-  p = (time_t*)soap_id_forward(soap, soap->href, p, t, 0, sizeof(time_t), 0, NULL);
   if (soap->body && soap_element_end_in(soap, tag))
     return NULL;
@@ -8566 +10914 @@
 int
 SOAP_FMAC2
-soap_outliteral(struct soap *soap, const char *tag, char *const*p)
+soap_outliteral(struct soap *soap, const char *tag, char *const*p, const char *type)
 { int i;
   const char *t = NULL;
   if (tag && *tag != '-')
-  { if ((t = strchr(tag, ':')))
+  { if (soap->local_namespaces && (t = strchr(tag, ':')))
     { strncpy(soap->tmpbuf, tag, t-tag);
       soap->tmpbuf[t-tag] = '\0';
@@ -8577 +10925 @@
           break;
       t++;
-      sprintf(soap->tmpbuf, "<%s xmlns=\"%s\">", t, soap->local_namespaces[i].ns ? soap->local_namespaces[i].ns : SOAP_STR_EOS);
+      if (soap_element(soap, t, 0, type)
+       || soap_attribute(soap, "xmlns", soap->local_namespaces[i].ns ? soap->local_namespaces[i].ns : SOAP_STR_EOS)
+       || soap_element_start_end_out(soap, NULL))
+        return soap->error;
     }
     else
     { t = tag;
-      sprintf(soap->tmpbuf, "<%s>", tag);
-    }
-    if (soap_send(soap, soap->tmpbuf))
-      return soap->error;
+      if (soap_element_begin_out(soap, t, 0, type))
+        return soap->error;
+    }
   }
   if (p && *p)
@@ -8591 +10941 @@
   }
   if (t)
-  { sprintf(soap->tmpbuf, "</%s>", t);
-    return soap_send(soap, soap->tmpbuf);
-  }
+    return soap_element_end_out(soap, t);
   return SOAP_OK;
 }
@@ -8604 +10952 @@
 SOAP_FMAC2
 soap_inliteral(struct soap *soap, const char *tag, char **p)
-{ if (soap_element_begin_in(soap, tag, 1))
-    return NULL;
+{ if (soap_element_begin_in(soap, tag, 1, NULL))
+  { if (soap->error != SOAP_NO_TAG || soap_unget(soap, soap_get(soap)) == SOAP_TT)
+      return NULL;
+    soap->error = SOAP_OK;
+  }
   if (!p)
-    if (!(p = (char**)soap_malloc(soap, sizeof(char*))))
+  { if (!(p = (char**)soap_malloc(soap, sizeof(char*))))
       return NULL;
-  if (soap->null)
+  }
+  if (soap->body || (tag && *tag == '-'))
+  { *p = soap_string_in(soap, 0, -1, -1);
+    if (!*p)
+      return NULL;
+    if (!**p && tag && *tag == '-')
+    { soap->error = SOAP_NO_TAG;
+      return NULL;
+    }
+  }
+  else if (soap->null)
     *p = NULL;
-  else if (soap->body)
-    *p = soap_string_in(soap, 0, -1, -1);
   else
-    *p = NULL;
+    *p = soap_strdup(soap, SOAP_STR_EOS);
   if (soap->body && soap_element_end_in(soap, tag))
     return NULL;
@@ -8622 +10981 @@
 
 /******************************************************************************/
+#ifndef WITH_LEANER
 #ifndef PALM_2
 SOAP_FMAC1
 int
 SOAP_FMAC2
-soap_outwliteral(struct soap *soap, const char *tag, wchar_t *const*p)
+soap_outwliteral(struct soap *soap, const char *tag, wchar_t *const*p, const char *type)
 { int i;
   const char *t = NULL;
-  wchar_t c;
-  const wchar_t *s;
   if (tag && *tag != '-')
-  { if (tag && (t = strchr(tag, ':')))
+  { if (soap->local_namespaces && (t = strchr(tag, ':')))
     { strncpy(soap->tmpbuf, tag, t-tag);
       soap->tmpbuf[t-tag] = '\0';
@@ -8639 +10997 @@
           break;
       t++;
-      sprintf(soap->tmpbuf, "<%s xmlns=\"%s\">", t, soap->local_namespaces[i].ns ? soap->local_namespaces[i].ns : SOAP_STR_EOS);
+      if (soap_element(soap, t, 0, type)
+       || soap_attribute(soap, "xmlns", soap->local_namespaces[i].ns ? soap->local_namespaces[i].ns : SOAP_STR_EOS)
+       || soap_element_start_end_out(soap, NULL))
+        return soap->error;
     }
     else
     { t = tag;
-      sprintf(soap->tmpbuf, "<%s>", tag);
+      if (soap_element_begin_out(soap, t, 0, type))
+        return soap->error;
     }
     if (soap_send(soap, soap->tmpbuf))
@@ -8649 +11011 @@
   }
   if (p)
-  { s = *p;
+  { wchar_t c;
+    const wchar_t *s = *p;
     while ((c = *s++))
-      if (soap_pututf8(soap, (unsigned char)c))
+    { if (soap_pututf8(soap, (unsigned long)c))
         return soap->error;
+    }
   }
   if (t)
-  { sprintf(soap->tmpbuf, "</%s>", t);
-    return soap_send(soap, soap->tmpbuf);
-  }
+    return soap_element_end_out(soap, t);
   return SOAP_OK;
 }
 #endif
-
-/******************************************************************************/
+#endif
+
+/******************************************************************************/
+#ifndef WITH_LEANER
 #ifndef PALM_2
 SOAP_FMAC1
@@ -8668 +11032 @@
 SOAP_FMAC2
 soap_inwliteral(struct soap *soap, const char *tag, wchar_t **p)
-{ if (soap_element_begin_in(soap, tag, 1))
+{ if (soap_element_begin_in(soap, tag, 1, NULL))
+  { if (soap->error != SOAP_NO_TAG || soap_unget(soap, soap_get(soap)) == SOAP_TT)
+      return NULL;
+    soap->error = SOAP_OK;
+  }
+  if (!p)
+  { if (!(p = (wchar_t**)soap_malloc(soap, sizeof(wchar_t*))))
+      return NULL;
+  }
+  if (soap->body)
+  { *p = soap_wstring_in(soap, 0, -1, -1);
+    if (!*p)
+      return NULL;
+    if (!**p && tag && *tag == '-')
+    { soap->error = SOAP_NO_TAG;
+      return NULL;
+    }
+  }
+  else if (tag && *tag == '-')
+  { soap->error = SOAP_NO_TAG;
     return NULL;
-  if (!p)
-    if (!(p = (wchar_t**)soap_malloc(soap, sizeof(wchar_t*))))
-      return NULL;
-  if (soap->null)
+  }
+  else if (soap->null)
     *p = NULL;
-  else if (soap->body)
-    *p = soap_wstring_in(soap, 0, -1, -1);
   else
-    *p = NULL;
+    *p = soap_wstrdup(soap, (wchar_t*)SOAP_STR_EOS);
   if (soap->body && soap_element_end_in(soap, tag))
     return NULL;
@@ -8684 +11063 @@
 }
 #endif
+#endif
 
 /******************************************************************************/
@@ -8691 +11071 @@
 SOAP_FMAC2
 soap_value(struct soap *soap)
-{ size_t i;
-  soap_wchar c = 0;
-  char *s = soap->tmpbuf;
+{ register size_t i;
+  register soap_wchar c = 0;
+  register char *s = soap->tmpbuf;
   if (!soap->body)
     return SOAP_STR_EOS;
+  do c = soap_get(soap);
+  while (soap_blank(c));
   for (i = 0; i < sizeof(soap->tmpbuf) - 1; i++)
-  { c = soap_get(soap);
-    if (c == SOAP_TT || (int)c == EOF || soap_blank(c))
+  { if (c == SOAP_TT || (int)c == EOF)
       break;
     *s++ = (char)c;
-  }
+    c = soap_get(soap);
+  }
+  for (s--; i > 0; i--, s--)
+  { if (!soap_blank(*s))
+      break;
+  }
+  s[1] = '\0';
   if ((int)c == EOF || c == SOAP_TT)
     soap_unget(soap, c);
-  *s = '\0';
+  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Element content value='%s'\n", soap->tmpbuf));
+#ifdef WITH_DOM
+  if ((soap->mode & SOAP_XML_DOM) && soap->dom)
+    soap->dom->data = soap_strdup(soap, soap->tmpbuf);
+#endif
   return soap->tmpbuf; /* return non-null pointer */
 }
@@ -8710 +11101 @@
 
 /******************************************************************************/
+#if !defined(WITH_LEANER) || !defined(WITH_NOHTTP)
 #ifndef PALM_2
 SOAP_FMAC1
@@ -8720 +11112 @@
   { while (--i > 0)
     { c = soap_getchar(soap);
-      if (c == '\r')
+      if (c == '\r' || c == '\n')
         break;
       if ((int)c == EOF)
@@ -8726 +11118 @@
       *s++ = (char)c;
     }
-    c = soap_getchar(soap);
+    if (c != '\n')
+      c = soap_getchar(soap); /* got \r or something else, now get \n */
     if (c == '\n')
     { *s = '\0';
-      if (i+1 == len) /* empty line: end of HTTP header */
+      if (i+1 == len) /* empty line: end of HTTP/MIME header */
         break;
-      c = soap_unget(soap, soap_getchar(soap));
+      c = soap_get0(soap);
       if (c != ' ' && c != '\t') /* HTTP line continuation? */
         break;
@@ -8738 +11131 @@
       return soap->error = SOAP_EOF;
   }
+  if (i < 0)
+    return soap->error = SOAP_HDR;
   return SOAP_OK;
 }
+#endif
 #endif
 
@@ -8750 +11146 @@
   register struct soap_multipart *content;
   register size_t count = soap->count;
-  if (soap->mode & SOAP_ENC_DIME)
+  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Calculating the message size with attachments, current count=%lu\n", (unsigned long)count));
+  if ((soap->mode & SOAP_ENC_DIME) && !(soap->mode & SOAP_ENC_MTOM))
   { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Calculating the size of DIME attachments\n"));
     for (content = soap->dime.first; content; content = content->next)
@@ -8760 +11157 @@
       if (content->options)
         count += ((((unsigned char)content->options[2] << 8) | ((unsigned char)content->options[3]))+7)&(~3);
-      DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Size of DIME attachment %lu bytes\n", (unsigned long)content->size));
+      DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Size of DIME attachment content is %lu bytes\n", (unsigned long)content->size));
     }
   }
@@ -8773 +11170 @@
       if (content->type)
         count += 16 + strlen(content->type);
-      s = soap_str_code(mime_codes, content->encoding);
       /* count Content-Transfer-Encoding: ...\r\n */
+      s = soap_code_str(mime_codes, content->encoding);
       if (s)
         count += 29 + strlen(s);
@@ -8785 +11182 @@
       /* count Content-Description: ...\r\n */
       if (content->description)
-        count += 23 + strlen(content->location);
+        count += 23 + strlen(content->description);
       /* count \r\n...content */
       count += 2 + content->size;
-      DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Size of MIME attachment %lu bytes\n", (unsigned long)content->size));
-    }
-    /* count \r\n--boundary--\r\n */
-    count += 8 + n;
-  }
+      DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Size of MIME attachment content is %lu bytes\n", (unsigned long)content->size));
+    }
+    /* count \r\n--boundary-- */
+    count += 6 + n;
+  }
+  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "New count is %lu bytes\n", (unsigned long)count));
   return count;
 #else
@@ -8825 +11223 @@
     s = (char*)soap_malloc(soap, n + 5);
     if (s)
-    { s[0] = optype >> 8;
-      s[1] = optype & 0xFF;
-      s[2] = n >> 8;
-      s[3] = n & 0xFF;
+    { s[0] = (char)(optype >> 8);
+      s[1] = (char)(optype & 0xFF);
+      s[2] = (char)(n >> 8);
+      s[3] = (char)(n & 0xFF);
       strcpy(s + 4, option);
     }
@@ -8846 +11244 @@
 { unsigned char tmp[12];
   size_t optlen = 0, idlen = 0, typelen = 0;
-  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Put DIME header id='%s'\n", soap->dime.id?soap->dime.id:""));
+  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Put DIME header id='%s'\n", soap->dime.id?soap->dime.id:SOAP_STR_EOS));
   if (soap->dime.options)
     optlen = (((unsigned char)soap->dime.options[2] << 8) | ((unsigned char)soap->dime.options[3])) + 4;
   if (soap->dime.id)
-    idlen = strlen(soap->dime.id);
+  { idlen = strlen(soap->dime.id);
+    if (idlen > 0x0000FFFF)
+      idlen = 0x0000FFFF;
+  }
   if (soap->dime.type)
-    typelen = strlen(soap->dime.type);
+  { typelen = strlen(soap->dime.type);
+    if (typelen > 0x0000FFFF)
+      typelen = 0x0000FFFF;
+  }
   tmp[0] = SOAP_DIME_VERSION | (soap->dime.flags & 0x7);
   tmp[1] = soap->dime.flags & 0xF0;
-  tmp[2] = optlen >> 8;
-  tmp[3] = optlen & 0xFF;
-  tmp[4] = idlen >> 8;
-  tmp[5] = idlen & 0xFF;
-  tmp[6] = typelen >> 8;
-  tmp[7] = typelen & 0xFF;
-  tmp[8] = soap->dime.size >> 24;
-  tmp[9] = (soap->dime.size >> 16) & 0xFF;
-  tmp[10] = (soap->dime.size >> 8) & 0xFF;
-  tmp[11] = soap->dime.size & 0xFF;
+  tmp[2] = (char)(optlen >> 8);
+  tmp[3] = (char)(optlen & 0xFF);
+  tmp[4] = (char)(idlen >> 8);
+  tmp[5] = (char)(idlen & 0xFF);
+  tmp[6] = (char)(typelen >> 8);
+  tmp[7] = (char)(typelen & 0xFF);
+  tmp[8] = (char)(soap->dime.size >> 24);
+  tmp[9] = (char)((soap->dime.size >> 16) & 0xFF);
+  tmp[10] = (char)((soap->dime.size >> 8) & 0xFF);
+  tmp[11] = (char)(soap->dime.size & 0xFF);
   if (soap_send_raw(soap, (char*)tmp, 12)
    || soap_putdimefield(soap, soap->dime.options, optlen)
@@ -8898 +11302 @@
         return soap->error;
       }
-      if (!content->size && ((soap->mode & SOAP_ENC_XML) || (soap->mode & SOAP_IO) == SOAP_IO_CHUNK || (soap->mode & SOAP_IO) == SOAP_IO_STORE))
+      if (!size && ((soap->mode & SOAP_ENC_XML) || (soap->mode & SOAP_IO) == SOAP_IO_CHUNK || (soap->mode & SOAP_IO) == SOAP_IO_STORE))
       { size_t chunksize = sizeof(soap->tmpbuf);
         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Chunked streaming DIME\n"));
@@ -8905 +11309 @@
           DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fdimeread returned %lu bytes\n", (unsigned long)size));
           if (size < chunksize)
-          { soap->dime.flags &= ~SOAP_DIME_CF;
+          { soap->dime.flags &= ~SOAP_DIME_CF;
             if (!content->next)
               soap->dime.flags |= SOAP_DIME_ME;
-          }
+          }
           else
             soap->dime.flags |= SOAP_DIME_CF;
-          soap->dime.size = size;
+          soap->dime.size = size;
           if (soap_putdimehdr(soap)
-           || soap_putdimefield(soap, soap->tmpbuf, size))
+           || soap_putdimefield(soap, soap->tmpbuf, size))
             break;
           if (soap->dime.id)
-          { soap->dime.flags &= ~(SOAP_DIME_MB | SOAP_DIME_MEDIA);
+          { soap->dime.flags &= ~(SOAP_DIME_MB | SOAP_DIME_MEDIA);
             soap->dime.id = NULL;
             soap->dime.type = NULL;
@@ -8930 +11334 @@
         do
         { size_t bufsize;
-          if (size < sizeof(soap->tmpbuf))
+          if (size < sizeof(soap->tmpbuf))
             bufsize = size;
           else
             bufsize = sizeof(soap->tmpbuf);
           if (!(bufsize = soap->fdimeread(soap, handle, soap->tmpbuf, bufsize)))
-          { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fdimeread failed: insufficient data (%lu bytes remaining from %lu bytes)\n", (unsigned long)size, (unsigned long)soap->dime.size));
+          { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fdimeread failed: insufficient data (%lu bytes remaining from %lu bytes)\n", (unsigned long)size, (unsigned long)content->size));
             soap->error = SOAP_EOF;
-            break;
+            break;
           }
           if (soap_send_raw(soap, soap->tmpbuf, bufsize))
@@ -8969 +11373 @@
 soap_getdimefield(struct soap *soap, size_t n)
 { register soap_wchar c;
-  register int i;
+  register size_t i;
   register char *s;
-  char *p = NULL;
+  register char *p = NULL;
   if (n)
   { p = (char*)soap_malloc(soap, n + 1);
@@ -9037 +11441 @@
   if (!(soap->dime.type = soap_getdimefield(soap, typelen)) && soap->error)
     return soap->error;
-  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "DIME id=%s, type=%s, options=%s\n", soap->dime.id?soap->dime.id:"", soap->dime.type?soap->dime.type:"", soap->dime.options?soap->dime.options+4:""));
+  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));
   if (soap->dime.flags & SOAP_DIME_ME)
     soap->mode &= ~SOAP_ENC_DIME;
@@ -9052 +11456 @@
 SOAP_FMAC2
 soap_getdime(struct soap *soap)
-{ struct soap_multipart *content;
-  if (soap_getdimehdr(soap))
+{ while (soap->dime.flags & SOAP_DIME_CF)
+  { if (soap_getdimehdr(soap))
+      return soap->error;
+    if (soap_move(soap, (long)soap->dime.size))
+      return soap->error = SOAP_EOF;
+  }
+  if (soap_move(soap, (long)(((soap->dime.size+3)&(~3))-soap_tell(soap))))
+    return soap->error = SOAP_EOF;
+  for (;;)
+  { register struct soap_multipart *content;
+    if (soap_getdimehdr(soap))
+      break;
+    if (soap->fdimewriteopen && ((soap->dime.ptr = (char*)soap->fdimewriteopen(soap, soap->dime.id, soap->dime.type, soap->dime.options)) || soap->error))
+    { const char *id, *type, *options;
+      size_t size, n;
+      if (!soap->dime.ptr)
+        return soap->error;
+      id = soap->dime.id;
+      type = soap->dime.type;
+      options = soap->dime.options;
+      for (;;)
+      { size = soap->dime.size;
+        for (;;)
+        { n = soap->buflen - soap->bufidx;
+          if (size < n)
+            n = size;
+          if ((soap->error = soap->fdimewrite(soap, (void*)soap->dime.ptr, soap->buf + soap->bufidx, n)))
+            break;
+          size -= n;
+          if (!size)
+          { soap->bufidx += n;
+            break;
+          }
+          if (soap_recv(soap))
+          { soap->error = SOAP_EOF;
+            goto end;
+          }
+        }
+        if (soap_move(soap, -(long)soap->dime.size&3))
+        { soap->error = SOAP_EOF;
+          break;
+        }
+        if (!(soap->dime.flags & SOAP_DIME_CF))
+          break;
+        if (soap_getdimehdr(soap))
+          break;
+      }
+end:
+      if (soap->fdimewriteclose)
+        soap->fdimewriteclose(soap, (void*)soap->dime.ptr);
+      soap->dime.size = 0;
+      soap->dime.id = id;
+      soap->dime.type = type;
+      soap->dime.options = options;
+    }
+    else if (soap->dime.flags & SOAP_DIME_CF)
+    { const char *id, *type, *options;
+      id = soap->dime.id;
+      type = soap->dime.type;
+      options = soap->dime.options;
+      if (soap_new_block(soap) == NULL)
+        return SOAP_EOM;
+      for (;;)
+      { register soap_wchar c;
+        register size_t i;
+        register char *s;
+        s = (char*)soap_push_block(soap, NULL, soap->dime.size);
+        if (!s)
+          return soap->error = SOAP_EOM;
+        for (i = soap->dime.size; i > 0; i--)
+        { if ((int)(c = soap_get1(soap)) == EOF)
+            return soap->error = SOAP_EOF;
+          *s++ = (char)c;
+        }
+        if (soap_move(soap, -(long)soap->dime.size&3))
+          return soap->error = SOAP_EOF;
+        if (!(soap->dime.flags & SOAP_DIME_CF))
+          break;
+        if (soap_getdimehdr(soap))
+          return soap->error;
+      }
+      soap->dime.size = soap->blist->size++; /* allocate one more for '\0' */
+      if (!(soap->dime.ptr = soap_save_block(soap, NULL, NULL, 0)))
+        return soap->error;
+      soap->dime.ptr[soap->dime.size] = '\0'; /* force 0-terminated */
+      soap->dime.id = id;
+      soap->dime.type = type;
+      soap->dime.options = options;
+    }
+    else
+      soap->dime.ptr = soap_getdimefield(soap, soap->dime.size);
+    content = soap_new_multipart(soap, &soap->dime.first, &soap->dime.last, soap->dime.ptr, soap->dime.size);
+    if (!content)
+      return soap->error = SOAP_EOM;
+    content->id = soap->dime.id;
+    content->type = soap->dime.type;
+    content->options = soap->dime.options;
+    if (soap->error)
+      return soap->error;
+    soap_resolve_attachment(soap, content);
+  }
+  if (soap->error != SOAP_DIME_END)
     return soap->error;
-  if (soap->fdimewriteopen && ((soap->dime.ptr = (char*)soap->fdimewriteopen(soap, soap->dime.id, soap->dime.type, soap->dime.options)) || soap->error))
-  { const char *id, *type, *options;
-    size_t size, n;
-    if (!soap->dime.ptr)
-      return soap->error;
-    id = soap->dime.id;
-    type = soap->dime.type;
-    options = soap->dime.options;
-    for (;;)
-    { size = soap->dime.size;
-      for (;;)
-      { n = soap->buflen - soap->bufidx;
-        if (size < n)
-          n = size;
-        if ((soap->error = soap->fdimewrite(soap, (void*)soap->dime.ptr, soap->buf + soap->bufidx, n)))
-          break;
-        size -= n;
-        if (!size)
-        { soap->bufidx += n;
-          break;
-        }
-        if (soap_recv(soap))
-        { soap->error = SOAP_EOF;
-          goto end;
-        }
-      }
-      if (soap_move(soap, -(long)soap->dime.size&3))
-      { soap->error = SOAP_EOF;
-        break;
-      }
-      if (!(soap->dime.flags & SOAP_DIME_CF))
-        break;
-      if (soap_getdimehdr(soap))
-        break;
-    }
-end:
-    if (soap->fdimewriteclose)
-      soap->fdimewriteclose(soap, (void*)soap->dime.ptr);
-    soap->dime.size = 0;
-    soap->dime.id = id;
-    soap->dime.type = type;
-    soap->dime.options = options;
-  }
-  else if (soap->dime.flags & SOAP_DIME_CF)
-  { const char *id, *type, *options;
-    register soap_wchar c;
-    register char *s;
-    register int i;
-    id = soap->dime.id;
-    type = soap->dime.type;
-    options = soap->dime.options;
-    if (soap_new_block(soap))
-      return SOAP_EOM;
-    for (;;)
-    { s = (char*)soap_push_block(soap, soap->dime.size);
-      if (!s)
-        return soap->error = SOAP_EOM;
-      for (i = soap->dime.size; i > 0; i--)
-      { if ((int)(c = soap_get1(soap)) == EOF)
-          return soap->error = SOAP_EOF;
-        *s++ = (char)c;
-      }
-      if (soap_move(soap, -(long)soap->dime.size&3))
-        return soap->error = SOAP_EOF;
-      if (!(soap->dime.flags & SOAP_DIME_CF))
-        break;
-      if (soap_getdimehdr(soap))
-        return soap->error;
-    }
-    soap->dime.size = soap->blist->size++; /* allocate one more for '\0' */
-    if (!(soap->dime.ptr = soap_save_block(soap, NULL, 0)))
-      return soap->error;
-    soap->dime.ptr[soap->dime.size] = '\0'; /* force 0-terminated */
-    soap->dime.id = id;
-    soap->dime.type = type;
-    soap->dime.options = options;
-  }
-  else
-    soap->dime.ptr = soap_getdimefield(soap, soap->dime.size);
-  content = soap_new_multipart(soap, &soap->dime.first, &soap->dime.last, soap->dime.ptr, soap->dime.size);
-  if (!content)
-    return soap->error = SOAP_EOM;
-  content->id = soap->dime.id;
-  content->type = soap->dime.type;
-  content->options = soap->dime.options;
-  return soap->error;
+  return soap->error = SOAP_OK;
 }
 #endif
@@ -9191 +11610 @@
       else if (!soap_tag_cmp(key, "Content-Location"))
         content->location = soap_strdup(soap, val);
+      else if (!soap_tag_cmp(key, "Content-Disposition"))
+        content->id = soap_strdup(soap, soap_get_header_attribute(soap, val, "name"));
       else if (!soap_tag_cmp(key, "Content-Type"))
         content->type = soap_strdup(soap, val);
@@ -9196 +11617 @@
         content->description = soap_strdup(soap, val);
       else if (!soap_tag_cmp(key, "Content-Transfer-Encoding"))
-        content->encoding = (enum soap_mime_encoding)soap_int_code(mime_codes, val, (long)SOAP_MIME_NONE);
+        content->encoding = (enum soap_mime_encoding)soap_code_int(mime_codes, val, (long)SOAP_MIME_NONE);
     }
     if (soap_getline(soap, key, sizeof(soap->msgbuf)))
@@ -9213 +11634 @@
 SOAP_FMAC2
 soap_getmime(struct soap *soap)
-{ register soap_wchar c;
-  if (!soap->mime.last)
-    return SOAP_OK;
+{ while (soap_get_mime_attachment(soap, NULL))
+    ;
+  return soap->error;
+}
+#endif
+#endif
+
+/******************************************************************************/
+#ifndef WITH_LEANER
+#ifndef PALM_1
+SOAP_FMAC1
+void
+SOAP_FMAC2
+soap_post_check_mime_attachments(struct soap *soap)
+{ soap->imode |= SOAP_MIME_POSTCHECK;
+}
+#endif
+#endif
+
+/******************************************************************************/
+#ifndef WITH_LEANER
+#ifndef PALM_1
+SOAP_FMAC1
+int
+SOAP_FMAC2
+soap_check_mime_attachments(struct soap *soap)
+{ if (soap->mode & SOAP_MIME_POSTCHECK)
+    return soap_get_mime_attachment(soap, NULL) != NULL;
+  return 0;
+}
+#endif
+#endif
+
+/******************************************************************************/
+#ifndef WITH_LEANER
+#ifndef PALM_1
+SOAP_FMAC1
+struct soap_multipart *
+SOAP_FMAC2
+soap_get_mime_attachment(struct soap *soap, void *handle)
+{ register soap_wchar c = 0;
+  register size_t i, m = 0;
+  register char *s, *t = NULL;
+  register struct soap_multipart *content;
+  register short flag = 0;
+  if (!(soap->mode & SOAP_ENC_MIME))
+    return NULL;
+  content = soap->mime.last;
+  if (!content)
+  { if (soap_getmimehdr(soap))
+      return NULL;
+    content = soap->mime.last;
+  }
+  else if (content != soap->mime.first)
+  { if (soap->fmimewriteopen && ((content->ptr = (char*)soap->fmimewriteopen(soap, (void*)handle, content->id, content->type, content->description, content->encoding)) || soap->error))
+    { if (!content->ptr)
+        return NULL;
+    }
+  }
+  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));
+  if (!content->ptr && soap_new_block(soap) == NULL)
+  { soap->error = SOAP_EOM;
+    return NULL;
+  }
   for (;;)
-  { register size_t i, m = 0;
-    register char *s;
-    struct soap_multipart *content = soap->mime.last;
-    DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Parsing MIME content id=%s type=%s\n", content->id?content->id:"", content->type?content->type:""));
-    if (soap_new_block(soap))
-      return soap->error = SOAP_EOM;
-    for (;;)
-    { register char *t = NULL;
-      if (!(s = (char*)soap_push_block(soap, SOAP_BLKLEN)))
-        return soap->error = SOAP_EOM;
-      for (i = 0; i < SOAP_BLKLEN; i++)
-      { if (m > 0)
-        { *s++ = *t++;
-          m--;
-        }
-        else
+  { if (content->ptr)
+      s = soap->tmpbuf;
+    else if (!(s = (char*)soap_push_block(soap, NULL, sizeof(soap->tmpbuf))))
+    { soap->error = SOAP_EOM;
+      return NULL;
+    }
+    for (i = 0; i < sizeof(soap->tmpbuf); i++)
+    { if (m > 0)
+      { *s++ = *t++;
+        m--;
+      }
+      else
+      { if (!flag)
         { c = soap_get1(soap);
-          if ((int)c == EOF)
-            return soap->error = SOAP_EOF;
-          if (c == '\r')
-          { t = soap->tmpbuf;
-            strcpy(t, "\n--");
-            strncat(t, soap->mime.boundary, sizeof(soap->tmpbuf)-3);
-            t[sizeof(soap->tmpbuf)-1] = '\0';
-            do c = soap_getchar(soap);
-            while (c == *t++);
-            if ((int)c == EOF)
-              return soap->error = SOAP_EOF;
-            if (!*--t)
-              goto end;
-            *t = (char)c;
-            m = t - soap->tmpbuf + 1;
-            t = soap->tmpbuf;
-            c = '\r';
-          }
-          *s++ = (char)c;
+          if ((int)c == EOF)
+          { soap->error = SOAP_EOF;
+            return NULL;
+          }
         }
-      }
-    }
+        if (flag || c == '\r')
+        { t = soap->msgbuf;
+          memset(t, 0, sizeof(soap->msgbuf));
+          strcpy(t, "\n--");
+          if (soap->mime.boundary)
+            strncat(t, soap->mime.boundary, sizeof(soap->msgbuf)-4);
+          do c = soap_getchar(soap);
+          while (c == *t++);
+          if ((int)c == EOF)
+          { soap->error = SOAP_EOF;
+            return NULL;
+          }
+          if (!*--t)
+            goto end;
+          *t = (char)c;
+          flag = (c == '\r');
+          m = t - soap->msgbuf + 1 - flag;
+          t = soap->msgbuf;
+          c = '\r';
+        }
+        *s++ = (char)c;
+      }
+    }
+    if (content->ptr && soap->fmimewrite)
+    { if ((soap->error = soap->fmimewrite(soap, (void*)content->ptr, soap->tmpbuf, i)))
+        break;
+    }
+  }
 end:
-    *s = '\0'; /* force 0-terminated */
-    content->size = soap_size_block(soap, i+1)-1;
-    content->ptr = soap_save_block(soap, NULL, 0);
-    if (c == '-' && soap_getchar(soap) == '-')
-      break;
-    while (c != '\r' && (int)c != EOF && soap_blank(c))
+  *s = '\0'; /* force 0-terminated */
+  if (content->ptr)
+  { if (!soap->error && soap->fmimewrite)
+      soap->error = soap->fmimewrite(soap, (void*)content->ptr, soap->tmpbuf, i);
+    if (soap->fmimewriteclose)
+      soap->fmimewriteclose(soap, (void*)content->ptr);
+    if (soap->error)
+      return NULL;
+  }
+  else
+  { content->size = soap_size_block(soap, NULL, i+1)-1;
+    content->ptr = soap_save_block(soap, NULL, NULL, 0);
+  }
+  soap_resolve_attachment(soap, content);
+  if (c == '-' && soap_getchar(soap) == '-')
+  { soap->mode &= ~SOAP_ENC_MIME;
+    if ((soap->mode & SOAP_MIME_POSTCHECK) && soap_end_recv(soap))
+      return NULL;
+  }
+  else
+  { while (c != '\r' && (int)c != EOF && soap_blank(c))
       c = soap_getchar(soap);
     if (c != '\r' || soap_getchar(soap) != '\n')
-      return soap->error = SOAP_MIME_ERROR;
+    { soap->error = SOAP_MIME_ERROR;
+      return NULL;
+    }
     if (soap_getmimehdr(soap))
-      return soap->error;
-  }
-  do c = soap_getchar(soap);
-  while ((int)c != EOF && c != '\r');
-  if ((int)c == EOF)
-    return soap->error = SOAP_EOF;
-  if (soap_getchar(soap) != '\n')
-    return soap->error = SOAP_MIME_ERROR;
-  return SOAP_OK;
+      return NULL;
+  }
+  return content;
+}
+#endif
+#endif
+
+/******************************************************************************/
+#ifndef WITH_LEANER
+#ifndef PALM_1
+SOAP_FMAC1
+int
+SOAP_FMAC2
+soap_match_cid(struct soap *soap, const char *s, const char *t)
+{ register size_t n;
+  if (!s)
+    return 1;
+  if (!strcmp(s, t))
+    return 0;
+  if (!strncmp(s, "cid:", 4))
+    s += 4;
+  n = strlen(t);
+  if (*t == '<')
+  { t++;
+    n -= 2;
+  }
+  if (!strncmp(s, t, n) && !s[n])
+    return 0;
+  soap_decode(soap->tmpbuf, sizeof(soap->tmpbuf), s, SOAP_STR_EOS);
+  if (!strncmp(soap->tmpbuf, t, n) && !soap->tmpbuf[n])
+    return 0;
+  return 1;
+}
+#endif
+#endif
+
+/******************************************************************************/
+#ifndef WITH_LEANER
+#ifndef PALM_1
+static void
+soap_resolve_attachment(struct soap *soap, struct soap_multipart *content)
+{ if (content->id)
+  { register struct soap_xlist **xp = &soap->xlist;
+    DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Resolving attachment data for id=%s\n", content->id));
+    while (*xp)
+    { register struct soap_xlist *xq = *xp;
+      if (!soap_match_cid(soap, xq->id, content->id))
+      { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Found matching attachment %s for content id=%s\n", xq->id, content->id));
+        *xp = xq->next;
+        *xq->ptr = (unsigned char*)content->ptr;
+        *xq->size = (int)content->size;
+        *xq->type = (char*)content->type;
+        if (content->options)
+          *xq->options = (char*)content->options;
+        else
+          *xq->options = (char*)content->description;
+        SOAP_FREE(soap, xq);
+      }
+      else
+        xp = &(*xp)->next;
+    }
+  }
 }
 #endif
@@ -9288 +11848 @@
 soap_putmimehdr(struct soap *soap, struct soap_multipart *content)
 { const char *s;
-  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "MIME attachment type=%s\n", content->type?content->type:""));
+  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "MIME attachment type=%s\n", content->type?content->type:SOAP_STR_EOS));
   if (soap_send3(soap, "\r\n--", soap->mime.boundary, "\r\n"))
     return soap->error;
   if (content->type && soap_send3(soap, "Content-Type: ", content->type, "\r\n"))
     return soap->error;
-  s = soap_str_code(mime_codes, content->encoding);
+  s = soap_code_str(mime_codes, content->encoding);
   if (s && soap_send3(soap, "Content-Transfer-Encoding: ", s, "\r\n"))
     return soap->error;
@@ -9319 +11879 @@
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Sending MIME attachments\n"));
   for (content = soap->mime.first; content; content = content->next)
-    if (soap_putmimehdr(soap, content)
-     || soap_send_raw(soap, content->ptr, content->size))
-      return soap->error;
-  return soap_send3(soap, "\r\n--", soap->mime.boundary, "--\r\n");
+  { void *handle;
+    if (soap->fmimereadopen && ((handle = soap->fmimereadopen(soap, (void*)content->ptr, content->id, content->type, content->description)) || soap->error))
+    { size_t size = content->size;
+      if (!handle)
+      { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fmimereadopen failed\n"));
+        return soap->error;
+      }
+      if (soap_putmimehdr(soap, content))
+        return soap->error;
+      if (!size)
+      { if ((soap->mode & SOAP_ENC_XML) || (soap->mode & SOAP_IO) == SOAP_IO_CHUNK || (soap->mode & SOAP_IO) == SOAP_IO_STORE)
+        { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Chunked streaming MIME\n"));
+          do 
+          { size = soap->fmimeread(soap, handle, soap->tmpbuf, sizeof(soap->tmpbuf));
+            DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fmimeread returned %lu bytes\n", (unsigned long)size));
+            if (soap_send_raw(soap, soap->tmpbuf, size))
+              break;
+          } while (size); 
+        }
+        else
+        { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Error: cannot chunk streaming MIME (no HTTP chunking)\n"));
+        }
+      }
+      else
+      { do
+        { size_t bufsize;
+          if (size < sizeof(soap->tmpbuf))
+            bufsize = size;
+          else
+            bufsize = sizeof(soap->tmpbuf);
+          if (!(bufsize = soap->fmimeread(soap, handle, soap->tmpbuf, bufsize)))
+          { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fmimeread failed: insufficient data (%lu bytes remaining from %lu bytes)\n", (unsigned long)size, (unsigned long)content->size));
+            soap->error = SOAP_EOF;
+            break;
+          }
+          if (soap_send_raw(soap, soap->tmpbuf, bufsize))
+            break;
+          size -= bufsize;
+        } while (size);
+      }
+      if (soap->fmimereadclose)
+        soap->fmimereadclose(soap, handle);
+    }
+    else
+    { if (soap_putmimehdr(soap, content)
+       || soap_send_raw(soap, content->ptr, content->size))
+        return soap->error;
+    }
+  }
+  return soap_send3(soap, "\r\n--", soap->mime.boundary, "--");
 }
 #endif
@@ -9478 +12084 @@
       n = strlen(s);
     if (n < 16)
-    { n = 72;
-      s = soap->mime.boundary = (char*)soap_malloc(soap, n);
+    { n = 64;
+      s = soap->mime.boundary = (char*)soap_malloc(soap, n + 1);
       if (!s)
         return;
     }
-    strcpy(s, "<>");
+    strcpy(s, "==");
     s += 2;
     n -= 4;
     while (n)
-    { *s++ = soap_base64o[rand()&0x3F];
+    { *s++ = soap_base64o[soap_random & 0x3F];
       n--;
     }
-    *s = '\0';
-    strcat(s, "<>");
+    strcpy(s, "==");
   }
   if (!soap->mime.start)
@@ -9505 +12110 @@
 soap_valid_mime_boundary(struct soap *soap)
 { register struct soap_multipart *content;
-  register size_t k = strlen(soap->mime.boundary);
+  register size_t k;
+  if (soap->fmimeread)
+    return SOAP_OK;
+  k = strlen(soap->mime.boundary);
   for (content = soap->mime.first; content; content = content->next)
   { if (content->ptr && content->size >= k)
@@ -9511 +12119 @@
       register size_t i;
       for (i = 0; i < content->size - k; i++, p++)
-        if (!strncmp(p, soap->mime.boundary, k))
+      { if (!strncmp(p, soap->mime.boundary, k))
           return SOAP_ERR;
+      }
     }
   }
@@ -9520 +12129 @@
 #endif
 
-/******************************************************************************/
+/******************************************************************************\
+ *
+ *      HTTP cookie handling
+ *
+\******************************************************************************/
 
 #ifdef WITH_COOKIES
@@ -9531 +12144 @@
   register size_t n = len;
   while ((c = *s++) && --n > 0)
-  { if (c > ' ' && c < 128 && c != ';' && c != ',')
+  { if (c > ' ' && c < 128 && !strchr("()<>@,;:\\\"/[]?={}", c))
       *t++ = c;
     else if (n > 2)
@@ -9558 +12171 @@
   if (!path)
     path = soap->cookie_path;
-  if (*path == '/')
+  if (!path)
+    path = SOAP_STR_EOS;
+  else if (*path == '/')
     path++;
   n = strlen(path);
+  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Search cookie %s domain=%s path=%s\n", name, domain?domain:"(null)", path?path:"(null)"));
   for (p = soap->cookies; p; p = p->next)
+  { 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));
     if (!strcmp(p->name, name)
-     && domain
      && p->domain
+     && p->path
      && !strcmp(p->domain, domain)
      && !strncmp(p->path, path, n))
       break;
+  }
   return p;
 }
@@ -9578 +12196 @@
 { struct soap_cookie **p, *q;
   int n;
-  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Set cookie: %s=%s domain=%s path=%s\n", name, value?value:"", domain?domain:"", path?path:""));
   if (!domain)
     domain = soap->cookie_domain;
@@ -9584 +12201 @@
     path = soap->cookie_path;
   if (!path)
-  { soap_set_receiver_error(soap, "Cookie path not set", NULL, SOAP_HTTP_ERROR);
-    return NULL;
-  }
-  if (*path == '/')
+    path = SOAP_STR_EOS;
+  else if (*path == '/')
     path++;
   q = soap_cookie(soap, name, domain, path);
+  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)"));
   if (!q)
-  { if ((q = (struct soap_cookie*)SOAP_MALLOC(sizeof(struct soap_cookie))))
-    { if ((q->name = (char*)SOAP_MALLOC(strlen(name)+1)))
+  { if ((q = (struct soap_cookie*)SOAP_MALLOC(soap, sizeof(struct soap_cookie))))
+    { if ((q->name = (char*)SOAP_MALLOC(soap, strlen(name)+1)))
         strcpy(q->name, name);
       q->value = NULL;
       q->domain = NULL;
       q->path = NULL;
-      q->expire = -1;
-      q->version = 0;
+      q->expire = 0;
+      q->maxage = -1;
+      q->version = 1;
       q->secure = 0;
-      q->env = 0;
       q->modified = 0;
       for (p = &soap->cookies, n = soap->cookie_max; *p && n; p = &(*p)->next, n--)
-        if (!strcmp((*p)->name, name) && (*p)->path && strcmp((*p)->path, path) < 0)
+        if (!strcmp((*p)->name, name) && (*p)->path && path && strcmp((*p)->path, path) < 0)
           break;
       if (n)
@@ -9610 +12226 @@
       }
       else
-      { SOAP_FREE(q->name);
-        SOAP_FREE(q);
+      { SOAP_FREE(soap, q->name);
+        SOAP_FREE(soap, q);
         q = NULL;
       }
@@ -9620 +12236 @@
   if (q)
   { if (q->value)
-    { SOAP_FREE(q->value);
+    { SOAP_FREE(soap, q->value);
       q->value = NULL;
     }
     if (q->domain)
-    { SOAP_FREE(q->domain);
+    { SOAP_FREE(soap, q->domain);
       q->domain = NULL;
     }
     if (q->path)
-    { SOAP_FREE(q->path);
+    { SOAP_FREE(soap, q->path);
       q->path = NULL;
     }
-    if (value && *value && (q->value = (char*)SOAP_MALLOC(strlen(value)+1)))
+    if (value && *value && (q->value = (char*)SOAP_MALLOC(soap, strlen(value)+1)))
       strcpy(q->value, value);
-    if (domain && *domain && (q->domain = (char*)SOAP_MALLOC(strlen(domain)+1)))
+    if (domain && (q->domain = (char*)SOAP_MALLOC(soap, strlen(domain)+1)))
       strcpy(q->domain, domain);
-    if (path && *path && (q->path = (char*)SOAP_MALLOC(strlen(path)+1)))
+    if (path && (q->path = (char*)SOAP_MALLOC(soap, strlen(path)+1)))
       strcpy(q->path, path);
     q->session = 1;
+    q->env = 0;
   }
   return q;
@@ -9651 +12268 @@
     domain = soap->cookie_domain;
   if (!domain)
-  { soap_set_receiver_error(soap, "Cookie domain not set", SOAP_STR_EOS, SOAP_HTTP_ERROR);
+  { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Error in clear cookie %s: cookie domain not set\n", name?name:"(null)"));
     return;
   }
@@ -9657 +12274 @@
     path = soap->cookie_path;
   if (!path)
-  { soap_set_receiver_error(soap, "Cookie path not set", SOAP_STR_EOS, SOAP_HTTP_ERROR);
+  { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Error in clear cookie %s: cookie path not set\n", name?name:"(null)"));
     return;
   }
@@ -9663 +12280 @@
     path++;
   for (p = &soap->cookies, q = *p; q; q = *p)
-    if (!strcmp(q->name, name) && !strcmp(q->domain, domain) && !strncmp(q->path, path, strlen(q->path)))
+  { if (!strcmp(q->name, name) && !strcmp(q->domain, domain) && !strncmp(q->path, path, strlen(q->path)))
     { if (q->value)
-        SOAP_FREE(q->value);
+        SOAP_FREE(soap, q->value);
       if (q->domain)
-        SOAP_FREE(q->domain);
+        SOAP_FREE(soap, q->domain);
       if (q->path)
-        SOAP_FREE(q->path);
+        SOAP_FREE(soap, q->path);
       *p = q->next;
-      SOAP_FREE(q);
+      SOAP_FREE(soap, q);
     }
     else
       p = &q->next;
+  }
 }
 
@@ -9690 +12308 @@
 /******************************************************************************/
 SOAP_FMAC1
-long
+char *
+SOAP_FMAC2
+soap_env_cookie_value(struct soap *soap, const char *name, const char *domain, const char *path)
+{ struct soap_cookie *p;
+  if ((p = soap_cookie(soap, name, domain, path)) && p->env)
+    return p->value;
+  return NULL;
+}
+
+/******************************************************************************/
+SOAP_FMAC1
+time_t
 SOAP_FMAC2
 soap_cookie_expire(struct soap *soap, const char *name, const char *domain, const char *path)
@@ -9705 +12334 @@
 soap_set_cookie_expire(struct soap *soap, const char *name, long expire, const char *domain, const char *path)
 { struct soap_cookie *p;
+  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)"));
   if ((p = soap_cookie(soap, name, domain, path)))
-  { p->expire = expire;
+  { p->maxage = expire;
     p->modified = 1;
     return SOAP_OK;
@@ -9750 +12380 @@
   const char *t;
   for (p = soap->cookies; p; p = p->next)
-  { if (p->modified || !p->env)
+  {
+    if (p->modified
+#ifdef WITH_OPENSSL
+     || (!p->env && !soap->ssl == !p->secure)
+#endif
+       )
     { s = tmp;
       if (p->name)
@@ -9759 +12394 @@
       }
       if (p->domain && (int)strlen(p->domain) < tmp-s+4064)
-        sprintf(s, ";Domain=%s", p->domain);
+      { strcpy(s, ";Domain=");
+        strcat(s, p->domain);
+      }
       else if (soap->cookie_domain && (int)strlen(soap->cookie_domain) < tmp-s+4064)
-        sprintf(s, ";Domain=%s", soap->cookie_domain);
+      { strcpy(s, ";Domain=");
+        strcat(s, soap->cookie_domain);
+      }
       strcat(s, ";Path=/");
+      s += strlen(s);
       if (p->path)
         t = p->path;
@@ -9771 +12411 @@
           t++;
         if ((int)strlen(t) < tmp-s+4064)
-          strcat(s, t);
-      }
-      s += strlen(s);
-      if (p->version > 0)
-        sprintf(s, ";Version=%u", p->version);
-      if (p->expire >= 0)
-        sprintf(s, ";Max-Age=%ld", p->expire);
-      if (p->secure)
-        strcat(s, ";Secure");
+        { if (strchr(t, '%'))   /* already URL encoded? */
+          { strcpy(s, t);
+            s += strlen(s);
+          }
+          else
+            s += soap_encode_cookie(t, s, tmp-s+4064);
+        }
+      }
+      if (p->version > 0 && s-tmp < 4060)
+      { sprintf(s, ";Version=%u", p->version);
+        s += strlen(s);
+      }
+      if (p->maxage >= 0 && s-tmp < 4060)
+      { sprintf(s, ";Max-Age=%ld", p->maxage);
+        s += strlen(s);
+      }
+      if (s-tmp < 4073
+       && (p->secure
+#ifdef WITH_OPENSSL
+       || soap->ssl
+#endif
+         ))
+        strcpy(s, ";Secure");
       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Set-Cookie: %s\n", tmp));
-      if (soap->fposthdr(soap, "Set-Cookie", tmp))
+      if ((soap->error = soap->fposthdr(soap, "Set-Cookie", tmp)))
         return soap->error;
     }
@@ -9798 +12452 @@
   char *s, tmp[4096];
   p = &soap->cookies;
+  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Sending cookies for domain=%s path=%s\n", domain, path));
+  if (*path == '/')
+    path++;
   while ((q = *p))
   { if (q->expire && now > q->expire)
     { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Cookie %s expired\n", q->name));
-      SOAP_FREE(q->name);
+      SOAP_FREE(soap, q->name);
       if (q->value)
-        SOAP_FREE(q->value);
+        SOAP_FREE(soap, q->value);
       if (q->domain)
-        SOAP_FREE(q->domain);
+        SOAP_FREE(soap, q->domain);
       if (q->path)
-        SOAP_FREE(q->path);
+        SOAP_FREE(soap, q->path);
       *p = q->next;
-      SOAP_FREE(q);
-    }
-    else if ((!q->domain || !strcmp(q->domain, domain))
+      SOAP_FREE(soap, q);
+    }
+    else
+    { int flag;
+      char *t = q->domain;
+      size_t n = 0;
+      if (!t)
+        flag = 1;
+      else
+      { const char *r = strchr(t, ':');
+        if (r)
+          n = r - t;
+        else
+          n = strlen(t);
+        flag = !strncmp(t, domain, n);
+      }
+      /* domain-level cookies, cannot compile when WITH_NOIO set */
+#ifndef WITH_NOIO
+      if (!flag)
+      { struct hostent *hostent = gethostbyname((char*)domain);
+        if (hostent)
+        { const char *r = strchr(hostent->h_name, '.');
+          if (!r)
+            r = hostent->h_name;
+          flag = !strncmp(t, r, n);
+        }
+      }
+#endif
+      if (flag
           && (!q->path || !strncmp(q->path, path, strlen(q->path)))
           && (!q->secure || secure))
-    { s = tmp;
-      if (q->version != version)
-      { sprintf(s, "$Version=%u;", q->version);
-        version = q->version;
-      }
-      if (q->name)
-        s += soap_encode_cookie(q->name, s, tmp-s+4080);
-      if (q->value && *q->value)
-      { *s++ = '=';
-        s += soap_encode_cookie(q->value, s, tmp-s+4080);
-      }
-      if (q->path && (int)strlen(q->path) < tmp-s+4080)
-      { sprintf(s, ";$Path=/%s", q->path);
-        s += strlen(s);
-      }
-      if (q->domain && (int)strlen(q->domain) < tmp-s+4080)
-        sprintf(s, ";$Domain=%s", q->domain);
-      DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Cookie: %s\n", tmp));
-      if (soap->fposthdr(soap, "Cookie", tmp))
-        return soap->error;
+      { s = tmp;
+        if (q->version != version)
+        { sprintf(s, "$Version=%u;", q->version);
+          version = q->version;
+        }
+        if (q->name)
+          s += soap_encode_cookie(q->name, s, tmp-s+4080);
+        if (q->value && *q->value)
+        { *s++ = '=';
+          s += soap_encode_cookie(q->value, s, tmp-s+4080);
+        }
+        if (q->path && *q->path && (int)strlen(q->path) < tmp-s+4080)
+        { sprintf(s, ";$Path=\"/%s\"", (*q->path == '/' ? q->path + 1 : q->path));
+          s += strlen(s);
+        }
+        if (q->domain && (int)strlen(q->domain) < tmp-s+4080)
+          sprintf(s, ";$Domain=\"%s\"", q->domain);
+        DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Cookie: %s\n", tmp));
+        if ((soap->error = soap->fposthdr(soap, "Cookie", tmp)))
+          return soap->error;
+      }
       p = &q->next;
     }
-    else
-      p = &q->next;
   }
   return SOAP_OK;
@@ -9870 +12552 @@
     { s = soap_decode_val(tmp, sizeof(tmp), s);
       if (*tmp)
-      { if ((t = (char*)SOAP_MALLOC(strlen(tmp)+1)))
+      { if ((t = (char*)SOAP_MALLOC(soap, strlen(tmp)+1)))
           strcpy(t, tmp);
       }
@@ -9877 +12559 @@
       if (p)
       { if (p->path)
-          SOAP_FREE(p->path);
+          SOAP_FREE(soap, p->path);
         p->path = t;
       }
       else
       { if (path)
-          SOAP_FREE(path);
+          SOAP_FREE(soap, path);
         path = t;
       }
@@ -9889 +12571 @@
     { s = soap_decode_val(tmp, sizeof(tmp), s);
       if (*tmp)
-      { if ((t = (char*)SOAP_MALLOC(strlen(tmp)+1)))
+      { if ((t = (char*)SOAP_MALLOC(soap, strlen(tmp)+1)))
           strcpy(t, tmp);
       }
@@ -9896 +12578 @@
       if (p)
       { if (p->domain)
-          SOAP_FREE(p->domain);
-        p->domain = t;
+          SOAP_FREE(soap, p->domain);
+        p->domain = t;
       }
       else
       { if (domain)
-          SOAP_FREE(domain);
+          SOAP_FREE(soap, domain);
         domain = t;
       }
@@ -9907 +12589 @@
     else if (p && !soap_tag_cmp(tmp, "Path"))
     { if (p->path)
-        SOAP_FREE(p->path);
+        SOAP_FREE(soap, p->path);
       s = soap_decode_val(tmp, sizeof(tmp), s);
       if (*tmp)
-      { if ((p->path = (char*)SOAP_MALLOC(strlen(tmp)+1)))
+      { if ((p->path = (char*)SOAP_MALLOC(soap, strlen(tmp)+1)))
           strcpy(p->path, tmp);
       }
@@ -9918 +12600 @@
     else if (p && !soap_tag_cmp(tmp, "Domain"))
     { if (p->domain)
-        SOAP_FREE(p->domain);
+        SOAP_FREE(soap, p->domain);
       s = soap_decode_val(tmp, sizeof(tmp), s);
       if (*tmp)
-      { if ((p->domain = (char*)SOAP_MALLOC(strlen(tmp)+1)))
+      { if ((p->domain = (char*)SOAP_MALLOC(soap, strlen(tmp)+1)))
           strcpy(p->domain, tmp);
       }
@@ -9948 +12630 @@
         a[0] = tmp[8];
         a[1] = tmp[9];
-        T.tm_mon = (strstr(mns, a) - mns) / 2;
+        T.tm_mon = (int)(strstr(mns, a) - mns) / 2;
         a[0] = tmp[11];
         a[1] = tmp[12];
@@ -9968 +12650 @@
     else
     { if (p)
-      { 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:"", p->domain?p->domain:"", p->path?p->path:"", p->expire, p->secure));
+      { 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));
         if ((q = soap_set_cookie(soap, p->name, p->value, p->domain, p->path)))
         { q->version = p->version;
@@ -9976 +12658 @@
         }
         if (p->name)
-          SOAP_FREE(p->name);
+          SOAP_FREE(soap, p->name);
         if (p->value)
-          SOAP_FREE(p->value);
+          SOAP_FREE(soap, p->value);
         if (p->domain)
-          SOAP_FREE(p->domain);
+          SOAP_FREE(soap, p->domain);
         if (p->path)
-          SOAP_FREE(p->path);
-        SOAP_FREE(p);
-      }
-      if ((p = (struct soap_cookie*)SOAP_MALLOC(sizeof(struct soap_cookie))))
-      { p->name = (char*)SOAP_MALLOC(strlen(tmp)+1);
+          SOAP_FREE(soap, p->path);
+        SOAP_FREE(soap, p);
+      }
+      if ((p = (struct soap_cookie*)SOAP_MALLOC(soap, sizeof(struct soap_cookie))))
+      { p->name = (char*)SOAP_MALLOC(soap, strlen(tmp)+1);
         strcpy(p->name, tmp);
         s = soap_decode_val(tmp, sizeof(tmp), s);
         if (*tmp)
-        { p->value = (char*)SOAP_MALLOC(strlen(tmp)+1);
+        { p->value = (char*)SOAP_MALLOC(soap, strlen(tmp)+1);
           strcpy(p->value, tmp);
         }
         else
           p->value = NULL;
-        p->domain = domain;
-        p->path = path;
+        if (domain)
+          p->domain = domain;
+        else if (*soap->host)
+        { p->domain = (char*)SOAP_MALLOC(soap, strlen(soap->host)+1);
+          strcpy(p->domain, soap->host);
+        }
+        else
+          p->domain = NULL;
+        if (path)
+          p->path = path;
+        else if (soap->path && *soap->path)
+        { p->path = (char*)SOAP_MALLOC(soap, strlen(soap->path)+1);
+          strcpy(p->path, soap->path);
+        }
+        else
+        { p->path = (char*)SOAP_MALLOC(soap, 2);
+          strcpy(p->path, "/");
+        }
         p->expire = 0;
         p->secure = 0;
@@ -10004 +12702 @@
   }
   if (p)
-  { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Got cookie %s=%s domain=%s path=%s expire=%ld secure=%d\n", p->name, p->value?p->value:"", p->domain?p->domain:"", p->path?p->path:"", p->expire, p->secure));
+  { 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));
     if ((q = soap_set_cookie(soap, p->name, p->value, p->domain, p->path)))
     { q->version = p->version;
       q->expire = p->expire;
       q->secure = p->secure;
+      q->env = 1;
     }
     if (p->name)
-      SOAP_FREE(p->name);
+      SOAP_FREE(soap, p->name);
     if (p->value)
-      SOAP_FREE(p->value);
+      SOAP_FREE(soap, p->value);
     if (p->domain)
-      SOAP_FREE(p->domain);
+      SOAP_FREE(soap, p->domain);
     if (p->path)
-      SOAP_FREE(p->path);
-    SOAP_FREE(p);
+      SOAP_FREE(soap, p->path);
+    SOAP_FREE(soap, p);
   }
   if (domain)
-    SOAP_FREE(domain);
+    SOAP_FREE(soap, domain);
   if (path)
-    SOAP_FREE(path);
+    SOAP_FREE(soap, path);
 }
 
@@ -10050 +12749 @@
 struct soap_cookie*
 SOAP_FMAC2
-soap_copy_cookies(struct soap *soap)
+soap_copy_cookies(struct soap *copy, const struct soap *soap)
 { struct soap_cookie *p, **q, *r;
   q = &r;
   for (p = soap->cookies; p; p = p->next)
-  { if (!(*q = (struct soap_cookie*)SOAP_MALLOC(sizeof(struct soap_cookie))))
+  { if (!(*q = (struct soap_cookie*)SOAP_MALLOC(copy, sizeof(struct soap_cookie))))
       return r;
     **q = *p;
     if (p->name)
-    { if (((*q)->name = (char*)SOAP_MALLOC(strlen(p->name)+1)))
+    { if (((*q)->name = (char*)SOAP_MALLOC(copy, strlen(p->name)+1)))
         strcpy((*q)->name, p->name);
     }
     if (p->value)
-    { if (((*q)->value = (char*)SOAP_MALLOC(strlen(p->value)+1)))
+    { if (((*q)->value = (char*)SOAP_MALLOC(copy, strlen(p->value)+1)))
         strcpy((*q)->value, p->value);
     }
     if (p->domain)
-    { if (((*q)->domain = (char*)SOAP_MALLOC(strlen(p->domain)+1)))
+    { if (((*q)->domain = (char*)SOAP_MALLOC(copy, strlen(p->domain)+1)))
         strcpy((*q)->domain, p->domain);
     }
     if (p->path)
-    { if (((*q)->path = (char*)SOAP_MALLOC(strlen(p->path)+1)))
+    { if (((*q)->path = (char*)SOAP_MALLOC(copy, strlen(p->path)+1)))
         strcpy((*q)->path, p->path);
     }
@@ -10087 +12786 @@
   for (p = soap->cookies; p; p = soap->cookies)
   { soap->cookies = p->next;
-    SOAP_FREE(p->name);
+    SOAP_FREE(soap, p->name);
     if (p->value)
-      SOAP_FREE(p->value);
+      SOAP_FREE(soap, p->value);
     if (p->domain)
-      SOAP_FREE(p->domain);
+      SOAP_FREE(soap, p->domain);
     if (p->path)
-      SOAP_FREE(p->path);
-    SOAP_FREE(p);
+      SOAP_FREE(soap, p->path);
+    SOAP_FREE(soap, p);
   }
 }
@@ -10107 +12806 @@
 soap_getgziphdr(struct soap *soap)
 { int i;
-  soap_wchar c, f = 0;
+  soap_wchar c = 0, f = 0;
   DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Get gzip header\n"));
   for (i = 0; i < 9; i++)
@@ -10117 +12816 @@
   if (f & 0x04) /* FEXTRA */
   { for (i = soap_get1(soap) | (soap_get1(soap) << 8); i; i--)
-      if ((int)soap_get1(soap) == EOF)
+    { if ((int)soap_get1(soap) == EOF)
         return soap->error = SOAP_EOF;
+    }
   }
   if (f & 0x08) /* FNAME */
-    do
+  { do
       c = soap_get1(soap);
     while (c && (int)c != EOF);
+  }
   if ((int)c != EOF && (f & 0x10)) /* FCOMMENT */
-    do
+  { do
       c = soap_get1(soap);
-    while (c && (int)f != EOF);
+    while (c && (int)c != EOF);
+  }
   if ((int)c != EOF && (f & 0x01)) /* FHCRC */
   { if ((int)(c = soap_get1(soap)) != EOF)
@@ -10146 +12848 @@
 soap_begin_recv(struct soap *soap)
 { soap_wchar c;
+  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Initializing for input\n"));
   soap->error = SOAP_OK;
-  soap_free(soap);
+  soap_free_temp(soap);
   soap_set_local_namespaces(soap);
   soap->version = 0;    /* don't assume we're parsing SOAP content by default */
+#ifndef WITH_NOIDREF
   soap_free_iht(soap);
+#endif
   if ((soap->imode & SOAP_IO) == SOAP_IO_CHUNK)
     soap->omode |= SOAP_IO_CHUNK;
@@ -10170 +12875 @@
   soap->cdata = 0;
   *soap->endpoint = '\0';
-  soap->userid = NULL;
-  soap->passwd = NULL;
   soap->action = NULL;
-  soap->authrealm = NULL;
+  soap->header = NULL;
+  soap->fault = NULL;
+  soap->status = 0;
+#ifndef WITH_LEANER
+  soap->dom = NULL;
   soap->dime.chunksize = 0;
   soap->dime.buflen = 0;
@@ -10184 +12891 @@
   soap->mime.boundary = NULL;
   soap->mime.start = NULL;
+  soap->xlist = NULL;
+#endif
 #ifdef WIN32
 #ifndef UNDER_CE
@@ -10189 +12898 @@
   if (!soap_valid_socket(soap->socket))
 #ifdef __BORLANDC__
-    setmode((SOAP_SOCKET)soap->recvfd, O_BINARY);
+    setmode(soap->recvfd, O_BINARY);
 #else
-    _setmode((SOAP_SOCKET)soap->recvfd, _O_BINARY);
+    _setmode(soap->recvfd, _O_BINARY);
 #endif
 #endif
@@ -10200 +12909 @@
   soap->zlib_in = SOAP_ZLIB_NONE;
   soap->zlib_out = SOAP_ZLIB_NONE;
-  soap->d_stream.next_in = Z_NULL;
-  soap->d_stream.avail_in = 0;
-  soap->d_stream.next_out = (Byte*)soap->buf;
-  soap->d_stream.avail_out = SOAP_BUFLEN;
+  soap->d_stream->next_in = Z_NULL;
+  soap->d_stream->avail_in = 0;
+  soap->d_stream->next_out = (Byte*)soap->buf;
+  soap->d_stream->avail_out = SOAP_BUFLEN;
   soap->z_ratio_in = 1.0;
+#endif
+#ifdef WITH_OPENSSL
+  if (soap->ssl)
+    ERR_clear_error();
+#endif
+#ifndef WITH_LEANER
   if (soap->fprepareinit)
     soap->fprepareinit(soap);
@@ -10213 +12928 @@
   { if (soap_getgziphdr(soap))
       return soap->error;
-    if (inflateInit2(&soap->d_stream, -MAX_WBITS) != Z_OK)
+    if (inflateInit2(soap->d_stream, -MAX_WBITS) != Z_OK)
       return soap->error = SOAP_ZLIB_ERROR;
     soap->zlib_state = SOAP_ZLIB_INFLATE;
@@ -10220 +12935 @@
     soap->z_crc = crc32(0L, NULL, 0);
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "gzip initialized\n"));
+    if (!soap->z_buf)
+      soap->z_buf = (char*)SOAP_MALLOC(soap, SOAP_BUFLEN);
     memcpy(soap->z_buf, soap->buf, SOAP_BUFLEN);
     /* should not chunk over plain transport, so why bother to check? */
@@ -10225 +12942 @@
     /*   soap->z_buflen = soap->bufidx; */
     /* else */
-    soap->d_stream.next_in = (Byte*)(soap->z_buf + soap->bufidx);
-    soap->d_stream.avail_in = soap->buflen - soap->bufidx;
+    soap->d_stream->next_in = (Byte*)(soap->z_buf + soap->bufidx);
+    soap->d_stream->avail_in = soap->buflen - soap->bufidx;
     soap->z_buflen = soap->buflen;
     soap->buflen = soap->bufidx;
@@ -10232 +12949 @@
   }  
 #endif
+#ifndef WITH_LEANER
   if (c == '-' && soap_get0(soap) == '-')
     soap->mode |= SOAP_ENC_MIME;
@@ -10237 +12955 @@
     soap->mode |= SOAP_ENC_DIME;
   else
+#endif
   { while (soap_blank(c))
       c = soap_getchar(soap);
@@ -10243 +12962 @@
     return soap->error = SOAP_EOF;
   soap_unget(soap, c);
-  if (c != '<' && !(soap->mode & (SOAP_ENC_DIME | SOAP_ENC_ZLIB)))
+#ifndef WITH_NOHTTP
+  /* if not XML or (start of)BOM or MIME/DIME/ZLIB, assume HTTP header */
+  if (c != '<' && c != 0xEF && !(soap->mode & (SOAP_ENC_MIME | SOAP_ENC_DIME | SOAP_ENC_ZLIB)))
   { soap->mode &= ~SOAP_IO;
-    if ((soap->error = soap->fparse(soap)))
+    soap->error = soap->fparse(soap);
+    if (soap->error && soap->error < SOAP_STOP)
     { soap->keep_alive = 0; /* force close later */
       return soap->error;
     }
+    if (soap->error == SOAP_STOP)
+      return soap->error;
+    soap->mode = soap->imode; /* if imode is changed, copy */
     if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK)
     { soap->chunkbuflen = soap->buflen;
@@ -10254 +12979 @@
       soap->chunksize = 0;
     }
+#ifndef WITH_LEANER
     else if (soap->fpreparerecv && soap->buflen != soap->bufidx)
       soap->fpreparerecv(soap, soap->buf + soap->bufidx, soap->buflen - soap->bufidx);
+#endif
+    /* Note: fparse should not use soap_unget to push back last char */
+    if (soap_get0(soap) == (int)EOF)
+    { if (soap->status == 200)
+        return soap->error = SOAP_NO_DATA;
+      return soap->error = soap->status;
+    }
 #ifdef WITH_ZLIB
-    if (soap->zlib_in)
-    { /* fparse should not use soap_unget to push back last char */
+    if (soap->zlib_in != SOAP_ZLIB_NONE)
+    {
 #ifdef WITH_GZIP
-      c = soap_get1(soap);
-      if (c == 0x1F)
-      { if (soap_getgziphdr(soap))
-          return soap->error;
-        if (inflateInit2(&soap->d_stream, -MAX_WBITS) != Z_OK)
-          return soap->error = SOAP_ZLIB_ERROR;
-        soap->zlib_state = SOAP_ZLIB_INFLATE;
-        soap->z_crc = crc32(0L, NULL, 0);
-        DBGLOG(TEST, SOAP_MESSAGE(fdebug, "gzip initialized\n"));
+      if (soap->zlib_in != SOAP_ZLIB_DEFLATE)
+      { c = soap_get1(soap);
+        if (c == 0x1F)
+        { if (soap_getgziphdr(soap))
+            return soap->error;
+          if (inflateInit2(soap->d_stream, -MAX_WBITS) != Z_OK)
+            return soap->error = SOAP_ZLIB_ERROR;
+          soap->z_crc = crc32(0L, NULL, 0);
+          DBGLOG(TEST, SOAP_MESSAGE(fdebug, "gzip initialized\n"));
+        }
+        else
+        { soap_revget1(soap);
+          if (inflateInit(soap->d_stream) != Z_OK)
+            return soap->error = SOAP_ZLIB_ERROR;
+          soap->zlib_in = SOAP_ZLIB_DEFLATE;
+        }
       }
       else
-      { soap_revget1(soap);
-#else
-      {
-#endif
-        if (inflateInit(&soap->d_stream) != Z_OK)
-          return soap->error = SOAP_ZLIB_ERROR;
-        soap->zlib_state = SOAP_ZLIB_INFLATE;
-        DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflate initialized\n"));
-      }
+#endif
+      if (inflateInit(soap->d_stream) != Z_OK)
+        return soap->error = SOAP_ZLIB_ERROR;
+      soap->zlib_state = SOAP_ZLIB_INFLATE;
+      DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflate initialized\n"));
       soap->mode |= SOAP_ENC_ZLIB;
+      if (!soap->z_buf)
+        soap->z_buf = (char*)SOAP_MALLOC(soap, SOAP_BUFLEN);
       memcpy(soap->z_buf, soap->buf, SOAP_BUFLEN);
-      soap->d_stream.next_in = (Byte*)(soap->z_buf + soap->bufidx);
-      soap->d_stream.avail_in = soap->buflen - soap->bufidx;
+      soap->d_stream->next_in = (Byte*)(soap->z_buf + soap->bufidx);
+      soap->d_stream->avail_in = soap->buflen - soap->bufidx;
       soap->z_buflen = soap->buflen;
       soap->buflen = soap->bufidx;
     }
 #endif
-  }
+    if (soap->error)
+    { if (soap->error == SOAP_FORM && soap->fform)
+      { soap->error = soap->fform(soap);
+        if (soap->error == SOAP_OK)
+          soap->error = SOAP_STOP; /* prevents further processing */
+      }
+      return soap->error;
+    }
+  }
+#endif
 #ifndef WITH_LEANER
   if (soap->mode & SOAP_ENC_MIME)
   { if (soap_getmimehdr(soap))
       return soap->error;
+    if (soap->mime.start)
+    { do
+      { if (!soap->mime.last->id)
+          break;
+        if (!soap_match_cid(soap, soap->mime.start, soap->mime.last->id))
+          break;
+      } while (soap_get_mime_attachment(soap, NULL));
+    }
     if (soap_get_header_attribute(soap, soap->mime.first->type, "application/dime"))
       soap->mode |= SOAP_ENC_DIME;
@@ -10317 +13072 @@
 
 /******************************************************************************/
+#ifndef WITH_NOHTTP
 #ifndef PALM_1
 static int
 http_parse(struct soap *soap)
 { char header[SOAP_HDRLEN], *s;
-  unsigned short g = 0, k;
-  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Waiting for response...\n"));
+  unsigned short httpcmd = 0, status = 0, k = 0;
+  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Waiting for HTTP request/response...\n"));
   *soap->endpoint = '\0';
   soap->length = 0;
+  soap->userid = NULL;
+  soap->passwd = NULL;
+  soap->action = NULL;
+  soap->authrealm = NULL;
+  soap->proxy_from = NULL;
+  soap->http_content = NULL;
+  soap->status = 0;
   do
   { if (soap_getline(soap, soap->msgbuf, sizeof(soap->msgbuf)))
-      return soap->error;
+    { if (soap->error == SOAP_EOF)
+        return SOAP_EOF;
+      return soap->error = 414;
+    }
     DBGLOG(TEST,SOAP_MESSAGE(fdebug, "HTTP status: %s\n", soap->msgbuf));
     for (;;)
     { if (soap_getline(soap, header, SOAP_HDRLEN))
+      { if (soap->error == SOAP_EOF)
+        { soap->error = SOAP_OK;
+          DBGLOG(TEST,SOAP_MESSAGE(fdebug, "EOF in HTTP header, continue anyway\n"));
+          break;
+        }
         return soap->error;
+      }
       if (!*header)
         break;
@@ -10337 +13109 @@
       s = strchr(header, ':');
       if (s)
-      { *s = '\0';
+      { char *t;
+        *s = '\0';
         do s++;
         while (*s && *s <= 32);
+        if (*s == '"')
+          s++;
+        t = s + strlen(s) - 1;
+        while (t > s && *t <= 32)
+          t--;
+        if (t >= s && *t == '"')
+          t--;
+        t[1] = '\0';
         if ((soap->error = soap->fparsehdr(soap, header, s)))
-          return soap->error;
+        { if (soap->error < SOAP_STOP)
+            return soap->error;
+          status = soap->error;
+          soap->error = SOAP_OK;
+        }
       }
     }
     if ((s = strchr(soap->msgbuf, ' ')))
-      k = (unsigned short)soap_strtoul(s, NULL, 10);
+    { k = (unsigned short)soap_strtoul(s, &s, 10);
+      if (!soap_blank(*s))
+        k = 0;
+    }
     else
       k = 0;
   } while (k == 100);
-  DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Finished HTTP header parsing\n"));
+  DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Finished HTTP header parsing, status = %d\n", k));
   s = strstr(soap->msgbuf, "HTTP/");
   if (s && s[7] != '1')
@@ -10362 +13150 @@
     soap->keep_alive = 1;
   DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Keep alive connection = %d\n", soap->keep_alive));
-  if (s && (((g = !strncmp(soap->msgbuf, "GET ", 4))) || !strncmp(soap->msgbuf, "POST ", 5)))
-  { size_t m = strlen(soap->endpoint);
-    size_t n = m + (s - soap->msgbuf) - 5 - (!g);
-    if (n >= sizeof(soap->endpoint))
-      n = sizeof(soap->endpoint) - 1;
-    strncpy(soap->path, soap->msgbuf + 4 + (!g), n - m);
-    soap->path[n - m] = '\0';
-    strcat(soap->endpoint, soap->path);
-    DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Target endpoint='%s'\n", soap->endpoint));
-    if (g)
-    { soap->error = soap->fget(soap);
-      if (soap->error == SOAP_OK)
-        soap->error = SOAP_STOP; /* prevents further processing */
-      return soap->error;
-    }
+  if (k == 0)
+  { size_t l = 0;
+    if (s)
+    { if (!strncmp(soap->msgbuf, "POST ", l = 5))
+        httpcmd = 1;
+      else if (!strncmp(soap->msgbuf, "GET ", l = 4))
+        httpcmd = 2;
+      else if (!strncmp(soap->msgbuf, "PUT ", l = 4))
+        httpcmd = 3;
+      else if (!strncmp(soap->msgbuf, "DELETE ", l = 7))
+        httpcmd = 4;
+      else if (!strncmp(soap->msgbuf, "HEAD ", l = 5))
+        httpcmd = 5;
+    }
+    if (s && httpcmd) 
+    { size_t m = strlen(soap->endpoint);
+      size_t n = m + (s - soap->msgbuf) - l - 1;
+      if (m > n)
+        m = n;
+      if (n >= sizeof(soap->endpoint))
+        n = sizeof(soap->endpoint) - 1;
+      strncpy(soap->path, soap->msgbuf + l, n - m);
+      soap->path[n - m] = '\0';
+      strcat(soap->endpoint, soap->path);
+      DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Target endpoint='%s'\n", soap->endpoint));
+      if (httpcmd > 1)
+      { switch (httpcmd)
+        { case  2: soap->error = soap->fget(soap); break;
+          case  3: soap->error = soap->fput(soap); break;
+          case  4: soap->error = soap->fdel(soap); break;
+          case  5: soap->error = soap->fhead(soap); break;
+          default: soap->error = SOAP_HTTP_METHOD; break;
+        }
+        if (soap->error == SOAP_OK)
+          soap->error = SOAP_STOP; /* prevents further processing */
+        return soap->error;
+      }
+      if (status)
+        return soap->error = status;
+    }
+    else if (status)
+      return soap->error = status;
+    else if (s)
+      return soap->error = 405;
+  }
+  soap->status = k;
+  /* Status OK (HTTP 200) */
+  if (k == 0 || k == 200)
     return SOAP_OK;
-  }
-  if (k == 0 || (k >= 200 && k <= 299) || k == 400 || k == 500)
+  /* Status 201 (Created), 202 (Accepted), ... and HTTP 400 and 500 errors.
+     Only keep parsing HTTP body when content-length>0 or chunked is set.
+  */
+  if (((k > 200 && k <= 299) || k == 400 || k == 500) && (soap->length > 0 || (soap->imode & SOAP_IO) == SOAP_IO_CHUNK))
     return SOAP_OK;
-  return soap_set_receiver_error(soap, "HTTP error", soap->msgbuf, k);
-}
-#endif
-
-/******************************************************************************/
+  /* HTTP 400 and 500 headers are supposed to set content-length or chunked.
+     For those that don't we keep parsing the body only if content type is
+     given and connection closes.
+  */
+  if ((k == 400 || k == 500) && (soap->http_content || soap->keep_alive == 0))
+    return SOAP_OK;
+  DBGLOG(TEST,SOAP_MESSAGE(fdebug, "HTTP error %d\n", k));
+  return soap_set_receiver_error(soap, "HTTP Error", soap->msgbuf, k);
+}
+#endif
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOHTTP
 #ifndef PALM_1
 static int
@@ -10402 +13234 @@
 #ifndef WITH_LEANER
   else if (!soap_tag_cmp(key, "Content-Type"))
-  { if (soap_get_header_attribute(soap, val, "application/dime"))
-      soap->mode |= SOAP_ENC_DIME;
-    else if (soap_get_header_attribute(soap, val, "multipart/related"))
+  { const char *action;
+    soap->http_content = soap_strdup(soap, val);
+    if (soap_get_header_attribute(soap, val, "application/dime"))
+      soap->imode |= SOAP_ENC_DIME;
+    else if (soap_get_header_attribute(soap, val, "multipart/related")
+          || soap_get_header_attribute(soap, val, "multipart/form-data"))
     { soap->mime.boundary = soap_strdup(soap, soap_get_header_attribute(soap, val, "boundary"));
       soap->mime.start = soap_strdup(soap, soap_get_header_attribute(soap, val, "start"));
-      soap->mode |= SOAP_ENC_MIME;
+      soap->imode |= SOAP_ENC_MIME;
+    }
+    action = soap_get_header_attribute(soap, val, "action");
+    if (action)
+    { if (*action == '"')
+      { soap->action = soap_strdup(soap, action + 1);
+        soap->action[strlen(soap->action) - 1] = '\0';
+      }
+      else
+        soap->action = soap_strdup(soap, action);
     }
   }
 #endif
   else if (!soap_tag_cmp(key, "Content-Length"))
-    soap->length = soap_strtoul(val, NULL, 10);
+  { soap->length = soap_strtoul(val, NULL, 10);
+  }
   else if (!soap_tag_cmp(key, "Content-Encoding"))
   { if (!soap_tag_cmp(val, "deflate"))
@@ -10442 +13287 @@
 #endif
   else if (!soap_tag_cmp(key, "Transfer-Encoding"))
-  { soap->mode &= ~SOAP_IO;
+  { soap->imode &= ~SOAP_IO;
     if (!soap_tag_cmp(val, "chunked"))
-      soap->mode |= SOAP_IO_CHUNK;
+      soap->imode |= SOAP_IO_CHUNK;
   }
   else if (!soap_tag_cmp(key, "Connection"))
@@ -10455 +13300 @@
   else if (!soap_tag_cmp(key, "Authorization"))
   { if (!soap_tag_cmp(val, "Basic *"))
-    { size_t n;
+    { int n;
       char *s;
       soap_base642s(soap, val + 6, soap->tmpbuf, sizeof(soap->tmpbuf) - 1, &n);
@@ -10461 +13306 @@
       if ((s = strchr(soap->tmpbuf, ':')))
       { *s = '\0';
-        soap->userid = soap_strdup(soap, soap->tmpbuf);
-        soap->passwd = soap_strdup(soap, s + 1);
+        soap->userid = soap_strdup(soap, soap->tmpbuf);
+        soap->passwd = soap_strdup(soap, s + 1);
       }
     }
   }
   else if (!soap_tag_cmp(key, "WWW-Authenticate"))
-    soap->authrealm = soap_strdup(soap, soap_get_header_attribute(soap, val+6, "realm"));
+  { soap->authrealm = soap_strdup(soap, soap_get_header_attribute(soap, val + 6, "realm"));
+  }
   else if (!soap_tag_cmp(key, "Expect"))
   { if (!soap_tag_cmp(val, "100-continue"))
@@ -10477 +13323 @@
 #endif
   else if (!soap_tag_cmp(key, "SOAPAction"))
-  { if (val[0] && val[1])
+  { if (*val == '"')
     { soap->action = soap_strdup(soap, val + 1);
       soap->action[strlen(soap->action) - 1] = '\0';
     }
+    else
+      soap->action = soap_strdup(soap, val);
   }
   else if (!soap_tag_cmp(key, "Location"))
@@ -10486 +13334 @@
     soap->endpoint[sizeof(soap->endpoint) - 1] = '\0';
   }
+  else if (!soap_tag_cmp(key, "X-Forwarded-For"))
+  { soap->proxy_from = soap_strdup(soap, val);
+  }
 #ifdef WITH_COOKIES
-  else if (!soap_tag_cmp(key, "Cookie") || !soap_tag_cmp(key, "Set-Cookie"))
-    soap_getcookies(soap, val);
+  else if (!soap_tag_cmp(key, "Cookie")
+   || !soap_tag_cmp(key, "Cookie2")
+   || !soap_tag_cmp(key, "Set-Cookie")
+   || !soap_tag_cmp(key, "Set-Cookie2"))
+  { soap_getcookies(soap, val);
+  }
 #endif
   return SOAP_OK;
 }
 #endif
-
-/******************************************************************************/
+#endif
+
+/******************************************************************************/
+#if !defined(WITH_NOHTTP) || !defined(WITH_LEANER)
 #ifndef PALM_1
 SOAP_FMAC1
@@ -10514 +13371 @@
 }
 #endif
-
-/******************************************************************************/
+#endif
+
+/******************************************************************************/
+#if !defined(WITH_NOHTTP) || !defined(WITH_LEANER)
 #ifndef PALM_1
 SOAP_FMAC1
@@ -10524 +13383 @@
 }
 #endif
-
-/******************************************************************************/
+#endif
+
+/******************************************************************************/
+#if !defined(WITH_NOHTTP) || !defined(WITH_LEANER)
 #ifndef PALM_1
 SOAP_FMAC1
@@ -10538 +13399 @@
 }
 #endif
-
-/******************************************************************************/
+#endif
+
+/******************************************************************************/
+#if !defined(WITH_NOHTTP) || !defined(WITH_LEANER)
 #ifndef PALM_1
 static const char*
@@ -10554 +13417 @@
   }
   else
-  { while (soap_notblank(*s) && !strchr(sep, *s) && --len)
+  { while (*s && !soap_blank(*s) && !strchr(sep, *s) && --len)
     { if (*s == '%')
       { *t++ = ((s[1] >= 'A' ? (s[1] & 0x7) + 9 : s[1] - '0') << 4)
@@ -10570 +13433 @@
 }
 #endif
+#endif
 
 /******************************************************************************/
@@ -10580 +13444 @@
 #ifndef WITH_LEANER
   size_t n = 0;
-  if ((soap->mode & SOAP_ENC_MIME) && soap->mime.boundary && soap->mime.start)
+  if ((soap->mode & SOAP_ENC_MIME) && soap->mime.boundary && soap->mime.start && strlen(soap->mime.boundary) + strlen(soap->mime.start) < sizeof(soap->tmpbuf) - 80 )
   { const char *s;
-    if (soap->mode & SOAP_ENC_DIME)
+    if ((soap->mode & SOAP_ENC_DIME) && !(soap->mode & SOAP_ENC_MTOM))
       s = "application/dime";
     else if (soap->version == 2)
-      s = "application/soap+xml; charset=utf-8";
+    { if (soap->mode & SOAP_ENC_MTOM)
+        s = "application/xop+xml; charset=utf-8; type=\"application/soap+xml\"";
+      else
+        s = "application/soap+xml; charset=utf-8";
+    }
+    else if (soap->mode & SOAP_ENC_MTOM)
+      s = "application/xop+xml; text/xml; charset=utf-8";
     else
       s = "text/xml; charset=utf-8";
@@ -10614 +13484 @@
     return soap->error;
 #ifndef WITH_LEANER
-  if ((soap->mode & SOAP_IO_LENGTH) && (soap->mode & SOAP_ENC_DIME))
+  if ((soap->mode & SOAP_IO_LENGTH) && (soap->mode & SOAP_ENC_DIME) && !(soap->mode & SOAP_ENC_MTOM))
   { soap->dime.size = soap->count - soap->dime.size;    /* DIME in MIME correction */
     sprintf(soap->id, soap->dime_id_format, 0);
@@ -10628 +13498 @@
     if (!soap->dime.first)
       soap->dime.flags |= SOAP_DIME_ME;
-    soap->count += 12 + ((strlen(soap->dime.id)+3)&(~3)) + ((strlen(soap->dime.type)+3)&(~3));
-  }
-  if (soap->mode & SOAP_ENC_DIME)
+    soap->count += 12 + ((strlen(soap->dime.id)+3)&(~3)) + (soap->dime.type ? ((strlen(soap->dime.type)+3)&(~3)) : 0);
+  }
+  if ((soap->mode & SOAP_ENC_DIME) && !(soap->mode & SOAP_ENC_MTOM))
     return soap_send_raw(soap, SOAP_STR_PADDING, -(long)soap->dime.size&3);
 #endif
@@ -10646 +13516 @@
 { register struct Namespace *p;
   soap->part = SOAP_IN_ENVELOPE;
-  if (soap_element_begin_in(soap, "SOAP-ENV:Envelope", 0))
-    return soap->error = SOAP_VERSIONMISMATCH;
+  if (soap_element_begin_in(soap, "SOAP-ENV:Envelope", 0, NULL))
+  { 
+#ifndef WITH_LEAN
+    if (soap->error == SOAP_TAG_MISMATCH && !soap_element_begin_in(soap, "html", 0, NULL))
+    { /* get HTML from buffer, stop receiving to avoid HTML parsing issues */
+      char *s;
+#ifndef WITH_NOIO
+      size_t (*f)(struct soap*, char*, size_t) = soap->frecv;
+      soap->frecv = frecv_stop;
+#endif
+      soap_revert(soap);
+      s = soap_string_in(soap, 1, -1, -1);
+#ifndef WITH_NOIO
+      soap->frecv = f;
+#endif
+      return soap_set_receiver_error(soap, "HTTP Error", s, SOAP_HTTP_ERROR);
+    }
+#endif
+    if (soap->error == SOAP_TAG_MISMATCH)
+      return soap->error = SOAP_VERSIONMISMATCH;
+    return soap->error;
+  }
   p = soap->local_namespaces;
   if (p)
@@ -10656 +13546 @@
     { soap->version = 1; /* make sure we use SOAP 1.1 */
       if (p[1].out)
-        SOAP_FREE(p[1].out);
-      if ((p[1].out = (char*)SOAP_MALLOC(sizeof(soap_enc1))))
+        SOAP_FREE(soap, p[1].out);
+      if ((p[1].out = (char*)SOAP_MALLOC(soap, sizeof(soap_enc1))))
         strcpy(p[1].out, soap_enc1);
     }
@@ -10663 +13553 @@
     { soap->version = 2; /* make sure we use SOAP 1.2 */
       if (p[1].out)
-        SOAP_FREE(p[1].out);
-      if ((p[1].out = (char*)SOAP_MALLOC(sizeof(soap_enc2))))
+        SOAP_FREE(soap, p[1].out);
+      if ((p[1].out = (char*)SOAP_MALLOC(soap, sizeof(soap_enc2))))
         strcpy(p[1].out, soap_enc2);
     }
@@ -10678 +13568 @@
 SOAP_FMAC2
 soap_envelope_end_in(struct soap *soap)
-{ if (soap_element_end_in(soap, "SOAP-ENV:Envelope"))
-    return soap->error;
-  soap->part = SOAP_END_ENVELOPE;
-  return SOAP_OK;
+{ soap->part = SOAP_END_ENVELOPE;
+  return soap_element_end_in(soap, "SOAP-ENV:Envelope");
 }
 #endif
@@ -10694 +13582 @@
   if (soap->version == 1)
     soap->encoding = 1;
+#ifndef WITH_LEAN
+  if ((soap->mode & SOAP_XML_SEC) && soap_set_attr(soap, "wsu:Id", "Body"))
+    return soap->error;
+#endif
   if (soap_element(soap, "SOAP-ENV:Body", 0, NULL))
-    return soap->error;
-  if ((soap->mode & SOAP_XML_SEC) && soap_attribute(soap, "id", "_0"))
     return soap->error;
   return soap_element_start_end_out(soap, NULL);
@@ -10710 +13600 @@
 { if (soap_element_end_out(soap, "SOAP-ENV:Body"))
     return soap->error;
-  soap->part = SOAP_IN_BODY;
+  soap->part = SOAP_END_BODY;
   return SOAP_OK;
 }
@@ -10722 +13612 @@
 soap_body_begin_in(struct soap *soap)
 { soap->part = SOAP_IN_BODY;
-  return soap_element_begin_in(soap, "SOAP-ENV:Body", 0);
+  if (soap_element_begin_in(soap, "SOAP-ENV:Body", 0, NULL))
+    return soap->error;
+  if (!soap->body)
+    soap->part = SOAP_NO_BODY;
+  return SOAP_OK;
 }
 #endif
@@ -10732 +13626 @@
 SOAP_FMAC2
 soap_body_end_in(struct soap *soap)
-{ if (soap_element_end_in(soap, "SOAP-ENV:Body"))
-    return soap->error;
+{ if (soap->part == SOAP_NO_BODY)
+    return SOAP_OK;
   soap->part = SOAP_END_BODY;
-  return SOAP_OK;
+  return soap_element_end_in(soap, "SOAP-ENV:Body");
 }
 #endif
@@ -10747 +13641 @@
 { if (soap_getheader(soap) && soap->error == SOAP_TAG_MISMATCH)
     soap->error = SOAP_OK;
+  else if (soap->error == SOAP_OK && soap->fheader)
+    soap->error = soap->fheader(soap);
   return soap->error;
 }
@@ -10759 +13655 @@
 { register const char *s;
   register size_t i, n;
-  *soap->endpoint = '\0';
-  *soap->host = '\0';
-  *soap->path = '\0';
+  soap->endpoint[0] = '\0';
+  soap->host[0] = '\0';
+  soap->path[0] = '/';
+  soap->path[1] = '\0';
   soap->port = 80;
   if (!endpoint || !*endpoint)
     return;
 #ifdef WITH_OPENSSL
-  if (!strncmp(endpoint, "https:", 6))
+  if (!soap_tag_cmp(endpoint, "https:*"))
     soap->port = 443;
 #endif
   strncpy(soap->endpoint, endpoint, sizeof(soap->endpoint) - 1);
+  soap->endpoint[sizeof(soap->endpoint) - 1] = '\0';
   s = strchr(endpoint, ':');
   if (s && s[1] == '/' && s[2] == '/')
@@ -10778 +13676 @@
   if (n >= sizeof(soap->host))
     n = sizeof(soap->host) - 1;
-/* WR[ */
 #ifdef WITH_IPV6
-  if ('[' == s[0])
+  if (s[0] == '[')
   { s++;
     for (i = 0; i < n; i++)
-    { soap->host[i] = s[i];
-      if (']' == s[i])
-      {
-        s++;
+    { if (s[i] == ']')
+      { s++;
+        --n;
         break; 
       }
+      soap->host[i] = s[i];
     }
   }
@@ -10798 +13695 @@
     }
   }
-#else /* WITH_IPV6 */
-/* ]WR */
+#else
   for (i = 0; i < n; i++)
   { soap->host[i] = s[i];
@@ -10805 +13701 @@
       break; 
   }
-/* WR[ */
-#endif /* WITH_IPV6 */
-/* ]WR */
+#endif
   soap->host[i] = '\0';
   if (s[i] == ':')
@@ -10815 +13709 @@
         break;
   }
-  if (s[i])
-  { strncpy(soap->path, s + i + 1, sizeof(soap->path));
+  if (i < n && s[i])
+  { strncpy(soap->path, s + i, sizeof(soap->path));
     soap->path[sizeof(soap->path) - 1] = '\0';
   }
@@ -10842 +13736 @@
   size_t count;
   soap->error = SOAP_OK;
-  strcpy(host, soap->host); /* save to compare */
-  port = soap->port; /* save to compare */
+  strcpy(host, soap->host); /* save previous host name to compare */
+  port = soap->port; /* save previous port to compare */
+  soap->status = http_command;
   soap_set_endpoint(soap, endpoint);
-  if (action)
-    soap->action = soap_strdup(soap, action);
+#ifndef WITH_LEANER
   if (soap->fconnect)
-    if ((soap->error = soap->fconnect(soap, endpoint, soap->host, soap->port)))
+  { if ((soap->error = soap->fconnect(soap, endpoint, soap->host, soap->port)))
       return soap->error;
-  if (*soap->host)
-  { soap->status = http_command;
-    if (!soap_valid_socket(soap->socket) || strcmp(soap->host, host) || soap->port != port)
-    { soap->keep_alive = 0; /* force close */
+  }
+  else
+#endif
+  if (soap->fopen && *soap->host)
+  { if (!soap->keep_alive || !soap_valid_socket(soap->socket) || strcmp(soap->host, host) || soap->port != port || !soap->fpoll || soap->fpoll(soap))
+    { soap->keep_alive = 0; /* to force close */
+      soap->omode &= ~SOAP_IO_UDP; /* to force close */
       soap_closesock(soap);
-      DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Connect to host='%s' path='%s' port=%d\n", soap->host, soap->path, soap->port));
+      DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Connect/reconnect to host='%s' path='%s' port=%d\n", soap->host, soap->path, soap->port));
+#ifndef WITH_LEAN
+      if (!strncmp(endpoint, "soap.udp:", 9))
+        soap->omode |= SOAP_IO_UDP;
+#endif
       soap->socket = soap->fopen(soap, endpoint, soap->host, soap->port);
       if (soap->error)
@@ -10861 +13762 @@
       soap->keep_alive = ((soap->omode & SOAP_IO_KEEPALIVE) != 0);
     }
-    else if (!soap->keep_alive || !soap->fpoll || soap->fpoll(soap))
-    { soap->keep_alive = 0; /* force close */
-      soap_closesock(soap);
-      DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Reconnect to host='%s' path='%s' port=%d\n", soap->host, soap->path, soap->port));
-      soap->socket = soap->fopen(soap, endpoint, soap->host, soap->port);
-      if (soap->error)
-        return soap->error;
-    }
-  }
+  }
+  count = soap_count_attachments(soap);
   if (soap_begin_send(soap))
     return soap->error;
-  count = soap_count_attachments(soap);
+  if (http_command != SOAP_POST)
+  { soap->mode &= ~SOAP_IO;
+    soap->mode |= SOAP_IO_BUFFER;
+  }
+#ifndef WITH_NOHTTP
+  soap->action = soap_strdup(soap, action);
   if ((soap->mode & SOAP_IO) != SOAP_IO_STORE && !(soap->mode & SOAP_ENC_XML) && endpoint)
   { unsigned int k = soap->mode;
@@ -10880 +13779 @@
     if ((soap->error = soap->fpost(soap, endpoint, soap->host, soap->port, soap->path, action, count)))
       return soap->error;
+#ifndef WITH_LEANER
     if ((k & SOAP_IO) == SOAP_IO_CHUNK)
     { if (soap_flush(soap))
         return soap->error;
     }
+#endif
     soap->mode = k;
   }
   if (http_command != SOAP_POST)
     return soap_end_send(soap);
+#endif
   return SOAP_OK;
 }
@@ -10897 +13799 @@
 char*
 SOAP_FMAC2
-soap_s2base64(struct soap *soap, const unsigned char *s, char *t, size_t n)
-{ register size_t i;
+soap_s2base64(struct soap *soap, const unsigned char *s, char *t, int n)
+{ register int i;
   register unsigned long m;
   register char *p;
@@ -10904 +13806 @@
     t = (char*)soap_malloc(soap, (n + 2) / 3 * 4 + 1);
   if (!t)
-  { soap->error = SOAP_EOM;
     return NULL;
-  }
   p = t;
   t[0] = '\0';
@@ -10941 +13841 @@
 const char*
 SOAP_FMAC2
-soap_base642s(struct soap *soap, const char *s, char *t, size_t l, size_t *n)
+soap_base642s(struct soap *soap, const char *s, char *t, size_t l, int *n)
 { register int i, j, c;
   register unsigned long m;
-  char *p = t;
+  register const char *p;
+  if (!s || !*s)
+  { if (n)
+      *n = 0;
+    if (soap->error)
+      return NULL;
+    return SOAP_NON_NULL;
+  }
+  if (!t)
+  { l = (strlen(s) + 3) / 4 * 3;
+    t = (char*)soap_malloc(soap, l);
+  }
+  if (!t)
+    return NULL;
+  p = t;
   if (n)
     *n = 0;
@@ -10966 +13880 @@
           }
           if (n)
-            *n += i;
+            *n += i;
           return p;
         }
         c -= '+';
         if (c >= 0 && c <= 79)
-        { m = (m << 6) + soap_base64i[c];
+        { int b = soap_base64i[c];
+          if (b >= 64)
+          { soap->error = SOAP_TYPE;
+            return NULL;  
+          }
+          m = (m << 6) + b;
           j++;
+        }
+        else if (!soap_blank(c + '+'))
+        { soap->error = SOAP_TYPE;
+          return NULL;  
         }
       }
@@ -10980 +13903 @@
       if (l < 3)
       { if (n)
-          *n += i;
+          *n += i;
         return p;
       }
@@ -10992 +13915 @@
 
 /******************************************************************************/
+#ifndef WITH_LEAN
+SOAP_FMAC1
+char*
+SOAP_FMAC2
+soap_s2hex(struct soap *soap, const unsigned char *s, char *t, int n)
+{ register char *p;
+  if (!t)
+    t = (char*)soap_malloc(soap, 2 * n + 1);
+  if (!t)
+    return NULL;
+  p = t;
+  t[0] = '\0';
+  if (s)
+  { for (; n > 0; n--)
+    { register int m = *s++;
+      *t++ = (char)((m >> 4) + (m > 159 ? 'a' - 10 : '0'));
+      m &= 0x0F;
+      *t++ = (char)(m + (m > 9 ? 'a' - 10 : '0'));
+    }
+  }
+  *t++ = '\0';
+  return p;
+}
+#endif
+
+/******************************************************************************/
+#ifndef WITH_LEAN
+SOAP_FMAC1
+const char*
+SOAP_FMAC2
+soap_hex2s(struct soap *soap, const char *s, char *t, size_t l, int *n)
+{ register const char *p;
+  if (!s || !*s)
+  { if (n)
+      *n = 0;
+    if (soap->error)
+      return NULL;
+    return SOAP_NON_NULL;
+  }
+  if (!t)
+  { l = strlen(s) / 2;
+    t = (char*)soap_malloc(soap, l);
+  }
+  if (!t)
+    return NULL;
+  p = t;
+  while (l)
+  { register int d1, d2;
+    d1 = *s++;
+    if (!d1)
+      break;
+    d2 = *s++;
+    if (!d2)
+      break;
+    *t++ = ((d1 >= 'A' ? (d1 & 0x7) + 9 : d1 - '0') << 4) + (d2 >= 'A' ? (d2 & 0x7) + 9 : d2 - '0');
+    l--;
+  }
+  if (n)
+    *n = (int)(t - p);
+  return p;
+}
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOHTTP
 #ifndef PALM_1
 SOAP_FMAC1
@@ -10997 +13985 @@
 SOAP_FMAC2
 soap_puthttphdr(struct soap *soap, int status, size_t count)
-{ register const char *s;
-  register int err;
-  if (status == SOAP_FILE)
-    s = soap->http_content;
-  else if (status == SOAP_HTML)
-    s = "text/html; charset=utf-8";
+{ if (soap->status != SOAP_GET)
+  { register const char *s = "text/xml; charset=utf-8";
+    register int err = SOAP_OK;
 #ifndef WITH_LEANER
-  else if (soap->mode & SOAP_ENC_DIME)
-    s = "application/dime";
-#endif
-  else if (soap->version == 2)
-    s = "application/soap+xml; charset=utf-8";
-  else
-    s = "text/xml; charset=utf-8";
+    register const char *r = NULL;
+#endif
+    if (status == SOAP_FILE && soap->http_content)
+      s = soap->http_content;
+    else if (status == SOAP_HTML)
+      s = "text/html; charset=utf-8";
+    else if (count || ((soap->omode & SOAP_IO) == SOAP_IO_CHUNK))
+    { if (soap->version == 2)
+        s = "application/soap+xml; charset=utf-8";
+    }
 #ifndef WITH_LEANER
-  if ((soap->mode & SOAP_ENC_MIME) && soap->mime.boundary && soap->mime.start && soap->status != SOAP_GET)
-  { sprintf(soap->tmpbuf, "multipart/related; boundary=\"%s\"; type=%s; start=\"%s\"", soap->mime.boundary, s, soap->mime.start);
-    s = soap->tmpbuf;
-  }
-#endif
-  if ((err = soap->fposthdr(soap, "Content-Type", s)))
-    return err;
+    if (soap->mode & (SOAP_ENC_DIME | SOAP_ENC_MTOM))
+    { if (soap->mode & SOAP_ENC_MTOM)
+      { r = s;
+        s = "application/xop+xml; charset=utf-8";
+      }
+      else
+        s = "application/dime";
+    }
+    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)
+    { register const char *t = strchr(s, ';');
+      sprintf(soap->tmpbuf, "multipart/related; boundary=\"%s\"; type=\"", soap->mime.boundary);
+      if (t)
+      { strncat(soap->tmpbuf, s, t - s);
+        soap->tmpbuf[sizeof(soap->tmpbuf)-1] = '\0';
+      }
+      else
+        strcat(soap->tmpbuf, s);
+      if (soap->mime.start)
+      { strcat(soap->tmpbuf, "\"; start=\"");
+        strcat(soap->tmpbuf, soap->mime.start);
+      }
+      strcat(soap->tmpbuf, "\"");
+      if (r)
+      { strcat(soap->tmpbuf, "; start-info=\"");
+        strcat(soap->tmpbuf, r);
+        strcat(soap->tmpbuf, "\"");
+      }
+      s = soap->tmpbuf;
+    }
+#endif
+    if (s && (err = soap->fposthdr(soap, "Content-Type", s)))
+      return err;
 #ifdef WITH_ZLIB
-  if (soap->omode & SOAP_ENC_ZLIB)
-  {
+    if ((soap->omode & SOAP_ENC_ZLIB))
+    { 
 #ifdef WITH_GZIP
-    err = soap->fposthdr(soap, "Content-Encoding", "gzip");
+      err = soap->fposthdr(soap, "Content-Encoding", soap->zlib_out == SOAP_ZLIB_DEFLATE ? "deflate" : "gzip");
 #else
-    err = soap->fposthdr(soap, "Content-Encoding", "deflate");
-#endif
+      err = soap->fposthdr(soap, "Content-Encoding", "deflate");
+#endif
+      if (err)
+        return err;
+    }
+#endif
+#ifndef WITH_LEANER
+    if ((soap->omode & SOAP_IO) == SOAP_IO_CHUNK)
+      err = soap->fposthdr(soap, "Transfer-Encoding", "chunked");
+    else
+#endif
+    if (s)
+    { sprintf(soap->tmpbuf, "%lu", (unsigned long)count);
+      err = soap->fposthdr(soap, "Content-Length", soap->tmpbuf);
+    }
     if (err)
       return err;
   }
-#endif
-  if ((soap->omode & SOAP_IO) == SOAP_IO_CHUNK)
-    err = soap->fposthdr(soap, "Transfer-Encoding", "chunked");
-  else if (count > 0)
-  { sprintf(soap->tmpbuf, "%lu", (unsigned long)count);
-    err = soap->fposthdr(soap, "Content-Length", soap->tmpbuf);
-  }
-  if (err)
-    return err;
   return soap->fposthdr(soap, "Connection", soap->keep_alive ? "keep-alive" : "close");
 }
 #endif
-
-/******************************************************************************/
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOHTTP
 #ifndef PALM_1
 static int
@@ -11050 +14069 @@
 }
 #endif
-
-/******************************************************************************/
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOHTTP
+#ifndef PALM_1
+static int
+http_put(struct soap *soap)
+{ return SOAP_PUT_METHOD;
+}
+#endif
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOHTTP
+#ifndef PALM_1
+static int
+http_del(struct soap *soap)
+{ return SOAP_DEL_METHOD;
+}
+#endif
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOHTTP
+#ifndef PALM_1
+static int
+http_head(struct soap *soap)
+{ return SOAP_HEAD_METHOD;
+}
+#endif
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOHTTP
 #ifndef PALM_1
 static int
@@ -11058 +14109 @@
   register int err;
   if (soap->status == SOAP_GET)
-  { s = "GET";
-    count = 0;
-  }
+    s = "GET";
   else
     s = "POST";
 #ifdef PALM
-  if (!endpoint || (strncmp(endpoint, "http:", 5) && strncmp(endpoint, "https:", 6) && strncmp(endpoint, "httpg:", 6)) && strncmp(endpoint, "_beam:", 6) && strncmp(endpoint, "_local:", 7) && strncmp(endpoint, "_btobex:", 8))
+  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))
 #else
-  if (!endpoint || (strncmp(endpoint, "http:", 5) && strncmp(endpoint, "https:", 6) && strncmp(endpoint, "httpg:", 6)))
+  if (!endpoint || (soap_tag_cmp(endpoint, "http:*") && soap_tag_cmp(endpoint, "https:*") && strncmp(endpoint, "httpg:", 6)))
 #endif
     return SOAP_OK;
-  if (soap->proxy_host && strncmp(endpoint, "https:", 6))
+  if (strlen(endpoint) + strlen(soap->http_version) > sizeof(soap->tmpbuf) - 80)
+    return soap->error = SOAP_EOM;
+  if (soap->proxy_host && soap_tag_cmp(endpoint, "https:*"))
     sprintf(soap->tmpbuf, "%s %s HTTP/%s", s, endpoint, soap->http_version);
   else
-    sprintf(soap->tmpbuf, "%s /%s HTTP/%s", s, path, soap->http_version);
+    sprintf(soap->tmpbuf, "%s /%s HTTP/%s", s, (*path == '/' ? path + 1 : path), soap->http_version);
   if ((err = soap->fposthdr(soap, soap->tmpbuf, NULL)))
     return err;
+#ifdef WITH_OPENSSL
+  if ((soap->ssl && soap->port != 443) || (!soap->ssl && soap->port != 80))
+    sprintf(soap->tmpbuf, "%s:%d", host, port);
+  else
+    strcpy(soap->tmpbuf, host); 
+#else
   if (port != 80)
     sprintf(soap->tmpbuf, "%s:%d", host, port);
   else
     strcpy(soap->tmpbuf, host); 
+#endif
   if ((err = soap->fposthdr(soap, "Host", soap->tmpbuf))
    || (err = soap->fposthdr(soap, "User-Agent", "gSOAP/2.7"))
@@ -11095 +14153 @@
   { sprintf(soap->tmpbuf + 262, "%s:%s", soap->userid, soap->passwd);
     strcpy(soap->tmpbuf, "Basic ");
-    soap_s2base64(soap, (const unsigned char*)(soap->tmpbuf + 262), soap->tmpbuf + 6, strlen(soap->tmpbuf + 262));
+    soap_s2base64(soap, (const unsigned char*)(soap->tmpbuf + 262), soap->tmpbuf + 6, (int)strlen(soap->tmpbuf + 262));
     if ((err = soap->fposthdr(soap, "Authorization", soap->tmpbuf)))
       return err;
@@ -11102 +14160 @@
   { sprintf(soap->tmpbuf + 262, "%s:%s", soap->proxy_userid, soap->proxy_passwd);
     strcpy(soap->tmpbuf, "Basic ");
-    soap_s2base64(soap, (const unsigned char*)(soap->tmpbuf + 262), soap->tmpbuf + 6, strlen(soap->tmpbuf + 262));
+    soap_s2base64(soap, (const unsigned char*)(soap->tmpbuf + 262), soap->tmpbuf + 6, (int)strlen(soap->tmpbuf + 262));
     if ((err = soap->fposthdr(soap, "Proxy-Authorization", soap->tmpbuf)))
       return err;
@@ -11116 +14174 @@
 #endif
 #endif
-  if (action && soap->version == 1)
-  { sprintf(soap->tmpbuf, "\"%s\"", action);
+  if (soap->status != SOAP_GET && (soap->version == 1 || (action && *action)))
+  { sprintf(soap->tmpbuf, "\"%s\"", action && strlen(action) < sizeof(soap->tmpbuf) - 3 ? action : SOAP_STR_EOS);
     if ((err = soap->fposthdr(soap, "SOAPAction", soap->tmpbuf)))
       return err;
@@ -11124 +14182 @@
 }
 #endif
-
-/******************************************************************************/
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOHTTP
 #ifndef PALM_1
 static int
@@ -11141 +14201 @@
 }
 #endif
-
-/******************************************************************************/
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOHTTP
 #ifndef PALM_1
 static int
@@ -11155 +14217 @@
 }
 #endif
-
-/******************************************************************************/
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOHTTP
 #ifndef PALM_1
 static int
 http_response(struct soap *soap, int status, size_t count)
 { register int err;
-/* WR[ */
 #ifdef WMW_RPM_IO
   if (soap->rpmreqid)
     httpOutputEnable(soap->rpmreqid);
-#endif  /* WMW_RPM_IO */
-/* ]WR */
+#endif
+  if (strlen(soap->http_version) > 4)
+    return soap->error = SOAP_EOM;
   if (!status || status == SOAP_HTML || status == SOAP_FILE)
-  { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "OK 200\n"));
-/* WR[ */
+  { const char *s;
+    if (count || ((soap->omode & SOAP_IO) == SOAP_IO_CHUNK))
+      s = "200 OK";
+    else
+      s = "202 ACCEPTED";
+    DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Status = %s\n", s));
 #ifdef WMW_RPM_IO
     if (soap->rpmreqid || soap_valid_socket(soap->master) || soap_valid_socket(soap->socket)) /* RPM behaves as if standalone */
 #else
-/* ]WR */
     if (soap_valid_socket(soap->master) || soap_valid_socket(soap->socket)) /* standalone application */
-/* WR[ */
-#endif /* WMW_RPM_IO */
-/* ]WR */
-    { sprintf(soap->tmpbuf, "HTTP/%s 200 OK", soap->http_version);
+#endif
+    { sprintf(soap->tmpbuf, "HTTP/%s %s", soap->http_version, s);
       if ((err = soap->fposthdr(soap, soap->tmpbuf, NULL)))
         return err;
     }
-    else if ((err = soap->fposthdr(soap, "Status", "200 OK")))
+    else if ((err = soap->fposthdr(soap, "Status", s)))
       return err;
   }
-  else if (status > 200 && status < 600)
+  else if (status >= 200 && status < 600)
   { sprintf(soap->tmpbuf, "HTTP/%s %d %s", soap->http_version, status, http_error(soap, status));
     if ((err = soap->fposthdr(soap, soap->tmpbuf, NULL)))
       return err;
+#ifndef WITH_LEAN 
     if (status == 401)
-    { sprintf(soap->tmpbuf, "Basic realm=\"%s\"", soap->authrealm ? soap->authrealm : "gSOAP Web Service");
+    { sprintf(soap->tmpbuf, "Basic realm=\"%s\"", (soap->authrealm && strlen(soap->authrealm) < sizeof(soap->tmpbuf) - 14) ? soap->authrealm : "gSOAP Web Service");
       if ((err = soap->fposthdr(soap, "WWW-Authenticate", soap->tmpbuf)))
         return err;
@@ -11198 +14264 @@
         return err;
     }
+#endif
   }
   else
   { const char *s = *soap_faultcode(soap);
-    if (soap->version == 2 && !strcmp(s, "SOAP-ENV:Sender"))
+    if (soap->version == 2 && (!s || !strcmp(s, "SOAP-ENV:Sender")))
       s = "400 Bad Request";
     else
       s = "500 Internal Server Error";
     DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Error %s (status=%d)\n", s, status));
-/* WR[ */
 #ifdef WMW_RPM_IO
     if (soap->rpmreqid || soap_valid_socket(soap->master) || soap_valid_socket(soap->socket)) /* RPM behaves as if standalone */
 #else
-/* ]WR */
     if (soap_valid_socket(soap->master) || soap_valid_socket(soap->socket)) /* standalone application */
-/* WR[ */
-#endif /* WMW_RPM_IO */
-/* ]WR */
+#endif
     { sprintf(soap->tmpbuf, "HTTP/%s %s", soap->http_version, s);
       if ((err = soap->fposthdr(soap, soap->tmpbuf, NULL)))
         return err;
     }
-    else if ((err = soap->fposthdr(soap, "Status", s)))
+    else if ((err = soap->fposthdr(soap, "Status", s))) /* CGI */
       return err;
   }
@@ -11232 +14295 @@
 }
 #endif
+#endif
 
 /******************************************************************************/
@@ -11242 +14306 @@
   if (!(soap->omode & (SOAP_ENC_XML | SOAP_IO_STORE /* this tests for chunking too */))
    && (status == SOAP_HTML || status == SOAP_FILE))
-  { soap->omode &= ~SOAP_IO;
-    soap->omode |= SOAP_IO_STORE;
-  }
+    soap->omode = (soap->omode & ~SOAP_IO) | SOAP_IO_STORE;
   soap->status = status;
   count = soap_count_attachments(soap);
   if (soap_begin_send(soap))
     return soap->error;
+#ifndef WITH_NOHTTP
   if ((soap->mode & SOAP_IO) != SOAP_IO_STORE && !(soap->mode & SOAP_ENC_XML))
   { register int n = soap->mode;
@@ -11256 +14319 @@
     if ((soap->error = soap->fresponse(soap, status, count)))
       return soap->error;
+#ifndef WITH_LEANER
     if ((n & SOAP_IO) == SOAP_IO_CHUNK)
     { if (soap_flush(soap))
         return soap->error;
     }
+#endif
     soap->mode = n;
   }
+#endif
   return SOAP_OK;
 }
@@ -11270 +14336 @@
 static const char*
 soap_set_validation_fault(struct soap *soap, const char *s, const char *t)
-{ sprintf(soap->msgbuf, "Validation constraint violation: %s%s in element <%s>", s, t?t:SOAP_STR_EOS, soap->tag);
+{ if (*soap->tag)
+    sprintf(soap->msgbuf, "Validation constraint violation: %s%s in element <%s>", s, t?t:SOAP_STR_EOS, soap->tag);
+  else
+    sprintf(soap->msgbuf, "Validation constraint violation: %s%s", s, t?t:SOAP_STR_EOS);
   return soap->msgbuf;
 }
@@ -11283 +14352 @@
 { const char **c = soap_faultcode(soap);
   const char **s = soap_faultstring(soap);
+  if (soap->fseterror)
+    soap->fseterror(soap, c, s);
   if (!*c)
   { if (soap->version == 2)
@@ -11303 +14374 @@
       *s = soap_set_validation_fault(soap, "tag name or namespace mismatch", NULL);
       break;
-    case SOAP_TAG_END:
-      *s = soap_set_validation_fault(soap, "incorrect end tag", NULL);
-      break;
     case SOAP_TYPE:
       *s = soap_set_validation_fault(soap, "data type mismatch ", soap->type);
       break;
     case SOAP_SYNTAX_ERROR:
-      *s = "Well-formedness constraint violation";
+      *s = "Well-formedness violation";
       break;
     case SOAP_NO_TAG:
-      *s = "No XML element tag found";
+      *s = "No XML element tag";
       break;
     case SOAP_MUSTUNDERSTAND:
@@ -11322 +14390 @@
     case SOAP_VERSIONMISMATCH:
       *c = "SOAP-ENV:VersionMismatch";
-      *s = "SOAP version mismatch or invalid SOAP message";
+      *s = "Invalid SOAP message or SOAP version mismatch";
       break;
     case SOAP_DATAENCODINGUNKNOWN:
@@ -11329 +14397 @@
       break;
     case SOAP_NAMESPACE:
-      *s = soap_set_validation_fault(soap, "namespace mismatch", NULL);
+      *s = soap_set_validation_fault(soap, "namespace error", NULL);
+      break;
+    case SOAP_USER_ERROR:
+      *s = "User error";
       break;
     case SOAP_FATAL_ERROR:
@@ -11338 +14409 @@
       *s = soap->msgbuf;
       break;
+    case SOAP_NO_DATA:
+      *s = "Data required for operation";
+      break;
     case SOAP_GET_METHOD:
       *s = "HTTP GET method not implemented";
       break;
+    case SOAP_PUT_METHOD:
+      *s = "HTTP PUT method not implemented";
+      break;
+    case SOAP_HEAD_METHOD:
+      *s = "HTTP HEAD method not implemented";
+      break;
+    case SOAP_HTTP_METHOD:
+      *s = "HTTP method not implemented";
+      break;
     case SOAP_EOM:
       *s = "Out of memory";
+      break;
+    case SOAP_MOE:
+      *s = "Memory overflow or memory corruption error";
+      break;
+    case SOAP_HDR:
+      *s = "Header line too long";
       break;
     case SOAP_IOB:
@@ -11350 +14439 @@
       *s = soap_set_validation_fault(soap, "nil not allowed", NULL);
       break;
-    case SOAP_MULTI_ID:
+    case SOAP_DUPLICATE_ID:
       *s = soap_set_validation_fault(soap, "multiple definitions of id ", soap->id);
+      if (soap->version == 2)
+        *soap_faultsubcode(soap) = "SOAP-ENC:DuplicateID";
       break;
     case SOAP_MISSING_ID:
       *s = soap_set_validation_fault(soap, "missing id for ref ", soap->id);
+      if (soap->version == 2)
+        *soap_faultsubcode(soap) = "SOAP-ENC:MissingID";
       break;
     case SOAP_HREF:
-      *s = soap_set_validation_fault(soap, "incompatible object ref ", soap->id);
+      *s = soap_set_validation_fault(soap, "incompatible object type ref/id pair ", soap->id);
       break;
     case SOAP_FAULT:
+      break;
+#ifndef WITH_NOIO
+    case SOAP_UDP_ERROR:
+      *s = "Message too large for UDP packet";
       break;
     case SOAP_TCP_ERROR:
       *s = tcp_error(soap);
       break;
+#endif
     case SOAP_HTTP_ERROR:
-      *s = "HTTP error";
+      *s = "An HTTP processing error occurred";
       break;
     case SOAP_SSL_ERROR:
+#ifdef WITH_OPENSSL
       *s = "SSL error";
+#else
+      *s = "OpenSSL not installed: recompile with -DWITH_OPENSSL";
+#endif
       break;
     case SOAP_PLUGIN_ERROR:
       *s = "Plugin registry error";
+      break;
+    case SOAP_DIME_ERROR:
+      *s = "DIME format error";
+      break;
+    case SOAP_DIME_HREF:
+      *s = "DIME href to missing attachment";
       break;
     case SOAP_DIME_MISMATCH:
@@ -11379 +14487 @@
       *s = "End of DIME error";
       break;
-    case SOAP_DIME_ERROR:
-      *s = "DIME format error";
-      break;
     case SOAP_MIME_ERROR:
       *s = "MIME format error";
       break;
+    case SOAP_MIME_HREF:
+      *s = "MIME href to missing attachment";
+      break;
+    case SOAP_MIME_END:
+      *s = "End of MIME error";
+      break;
     case SOAP_ZLIB_ERROR:
 #ifdef WITH_ZLIB
-      sprintf(soap->msgbuf, "Zlib/gzip error: '%s'", soap->d_stream.msg?soap->d_stream.msg:"");
+      sprintf(soap->msgbuf, "Zlib/gzip error: '%s'", soap->d_stream->msg?soap->d_stream->msg:SOAP_STR_EOS);
       *s = soap->msgbuf;
 #else
-      *s = "Zlib not installed for required message (de)compression";
+      *s = "Zlib/gzip not installed for (de)compression: recompile with -DWITH_GZIP";
 #endif
       break;
@@ -11400 +14511 @@
       break;
     case SOAP_OCCURS:
-      *s = soap_set_validation_fault(soap, "a min/maxOccurs violation was detected", NULL);
+      *s = soap_set_validation_fault(soap, "occurrence violation", NULL);
       break;
     case SOAP_LENGTH:
       *s = soap_set_validation_fault(soap, "content length violation", NULL);
       break;
+    case SOAP_FD_EXCEEDED:
+      *s = "Maximum number of open connections was reached";
+      break;
+    case SOAP_STOP:
+      *s = "Stopped: no response sent";
+      break;
 #endif
     case SOAP_EOF:
-      sprintf(soap->msgbuf, "End of file or no input: '%s'", soap_strerror(soap));
+#ifndef WITH_NOIO
+      strcpy(soap->msgbuf, soap_strerror(soap));
+#ifndef WITH_LEAN
+      if (strlen(soap->msgbuf) + 25 < sizeof(soap->msgbuf))
+      { memmove(soap->msgbuf + 25, soap->msgbuf, strlen(soap->msgbuf) + 1);
+        memcpy(soap->msgbuf, "End of file or no input: ", 25);
+      }
+#endif
       *s = soap->msgbuf;
       break;
+#else
+      *s = "End of file or no input";
+      break;
+#endif
     default:
+#ifndef WITH_NOHTTP
+#ifndef WITH_LEAN
       if (soap->error > 200 && soap->error < 600)
-      { sprintf(soap->msgbuf, "HTTP Error: '%s'", http_error(soap, soap->error));
+      { sprintf(soap->msgbuf, "HTTP Error: %d %s", soap->error, http_error(soap, soap->error));
         *s = soap->msgbuf;
       }
       else
-      { sprintf(soap->msgbuf, "Error code %d", soap->error);
+#endif
+#endif
+      { sprintf(soap->msgbuf, "Error %d", soap->error);
         *s = soap->msgbuf;
       }
@@ -11430 +14562 @@
 soap_send_fault(struct soap *soap)
 { register int status = soap->error;
+  int r = 1;
   if (status == SOAP_STOP)
     return status;
@@ -11435 +14568 @@
   soap->keep_alive = 0; /* to terminate connection */
   soap_set_fault(soap);
-  if ((status != SOAP_EOF || (!soap->recv_timeout && !soap->send_timeout)) && (!soap->fpoll || soap->fpoll(soap) == SOAP_OK))
+#ifndef WITH_NOIO
+#ifndef WITH_LEAN
+  if (soap_valid_socket(soap->socket))
+  { struct timeval timeout;
+    fd_set rfd, sfd;
+    timeout.tv_sec = 0;
+    timeout.tv_usec = 0;
+    FD_ZERO(&rfd);
+    FD_ZERO(&sfd);
+    FD_SET(soap->socket, &rfd);
+    FD_SET(soap->socket, &sfd);
+    r = select((int)soap->socket + 1, &rfd, &sfd, NULL, &timeout);
+    if (r > 0)
+    { if (!FD_ISSET(soap->socket, &sfd)
+       || (FD_ISSET(soap->socket, &rfd)
+        && recv(soap->socket, soap->tmpbuf, 1, MSG_PEEK) < 0))
+        r = 0;
+    }
+  }
+#endif
+#endif
+  if ((status != SOAP_EOF || (!soap->recv_timeout && !soap->send_timeout)) && r > 0)
   { soap->error = SOAP_OK;
     soap_serializeheader(soap);
@@ -11448 +14602 @@
       soap_envelope_end_out(soap);
     }
+    soap_end_count(soap);
     if (soap_response(soap, status)
      || soap_envelope_begin_out(soap)
@@ -11503 +14658 @@
 
 /******************************************************************************/
+#ifndef WITH_NOHTTP
+#ifndef PALM_1
+SOAP_FMAC1
+int
+SOAP_FMAC2
+soap_send_empty_response(struct soap *soap, int httpstatuscode)
+{ register soap_mode m = soap->omode;
+  soap->count = 0;
+  if ((m & SOAP_IO) == SOAP_IO_CHUNK)
+    soap->omode = (m & ~SOAP_IO) | SOAP_IO_BUFFER;
+  if (soap_response(soap, httpstatuscode) || soap_end_send(soap))
+  { soap->omode = m;
+    return soap_closesock(soap);
+  }
+  soap->omode = m;
+  return SOAP_OK;
+}
+#endif
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOHTTP
+#ifndef PALM_1
+SOAP_FMAC1
+int
+SOAP_FMAC2
+soap_recv_empty_response(struct soap *soap)
+{ if (soap_begin_recv(soap) || soap_end_recv(soap))
+  { if (soap->error != 202)
+      return soap_closesock(soap);
+    soap->error = SOAP_OK;
+  }
+  return SOAP_OK;
+}
+#endif
+#endif
+
+/******************************************************************************/
+#ifndef WITH_NOIO
 #ifndef PALM_1
 static const char*
 soap_strerror(struct soap *soap)
-{ int err = soap->errnum;
-  if (!err)
-    err = soap_errno;
+{ register int err = soap->errnum;
   if (err)
   {
-#ifndef UNDER_CE
+#ifndef WIN32
     return strerror(err);
 #else
-    FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS, NULL, err, 0, (LPTSTR)&soap->werrorstr, sizeof(soap->werrorstr), NULL);
-    wcstombs(soap->errorstr, soap->werrorstr, sizeof(soap->errorstr));
-    return soap->errorstr;
-#endif
-  }
+#ifndef UNDER_CE
+    DWORD len;
+    *soap->msgbuf = '\0';
+    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);
+#else
+    DWORD i, len;
+    *soap->msgbuf = '\0';
+    len = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, err, 0, (LPTSTR)soap->msgbuf, (DWORD)(sizeof(soap->msgbuf)/sizeof(TCHAR)), NULL);
+    for (i = 0; i <= len; i++)
+    { if (((TCHAR*)soap->msgbuf)[i] < 0x80)
+        soap->msgbuf[i] = (char)((TCHAR*)soap->msgbuf)[i];
+      else
+        soap->msgbuf[i] = '?';
+    }
+#endif
+    return soap->msgbuf;
+#endif
+  }
+#ifndef WITH_LEAN
+  if (soap->recv_timeout > 0)
+  { if (soap->send_timeout > 0)
+      sprintf(soap->msgbuf, "Operation interrupted or timed out after %ds send or %ds receive delay", soap->send_timeout, soap->recv_timeout);
+    else
+      sprintf(soap->msgbuf, "Operation interrupted or timed out after %ds receive delay", soap->recv_timeout);
+    return soap->msgbuf;
+  }
+#endif
   return "Operation interrupted or timed out";
 }
 #endif
+#endif 
 
 /******************************************************************************/
 #ifndef PALM_2
 static int
-soap_set_error(struct soap *soap, const char *faultcode, const char *faultstring, const char *faultdetail, int soaperror)
+soap_set_error(struct soap *soap, const char *faultcode, const char *faultsubcodeQName, const char *faultstring, const char *faultdetailXML, int soaperror)
 { *soap_faultcode(soap) = faultcode;
+  if (faultsubcodeQName)
+    *soap_faultsubcode(soap) = faultsubcodeQName;
   *soap_faultstring(soap) = faultstring;
-  if (faultdetail && *faultdetail)
+  if (faultdetailXML && *faultdetailXML)
   { register const char **s = soap_faultdetail(soap);
     if (s)
-      *s = faultdetail;
+      *s = faultdetailXML;
   }
   return soap->error = soaperror;
@@ -11543 +14760 @@
 int
 SOAP_FMAC2
-soap_set_sender_error(struct soap *soap, const char *faultstring, const char *faultdetail, int soaperror)
-{ return soap_set_error(soap, soap->version == 2 ? "SOAP-ENV:Sender" : "SOAP-ENV:Client", faultstring, faultdetail, soaperror);
+soap_set_sender_error(struct soap *soap, const char *faultstring, const char *faultdetailXML, int soaperror)
+{ return soap_set_error(soap, soap->version == 2 ? "SOAP-ENV:Sender" : "SOAP-ENV:Client", NULL, faultstring, faultdetailXML, soaperror);
 }
 #endif
@@ -11553 +14770 @@
 int
 SOAP_FMAC2
-soap_set_receiver_error(struct soap *soap, const char *faultstring, const char *faultdetail, int soaperror)
-{ return soap_set_error(soap, soap->version == 2 ? "SOAP-ENV:Receiver" : "SOAP-ENV:Server", faultstring, faultdetail, soaperror);
+soap_set_receiver_error(struct soap *soap, const char *faultstring, const char *faultdetailXML, int soaperror)
+{ return soap_set_error(soap, soap->version == 2 ? "SOAP-ENV:Receiver" : "SOAP-ENV:Server", NULL, faultstring, faultdetailXML, soaperror);
 }
 #endif
@@ -11561 +14778 @@
 #ifndef PALM_2
 static int
-soap_copy_fault(struct soap *soap, const char *faultcode, const char *faultstring, const char *faultdetail)
-{ char *s = NULL, *t = NULL;
+soap_copy_fault(struct soap *soap, const char *faultcode, const char *faultsubcodeQName, const char *faultstring, const char *faultdetailXML)
+{ char *r = NULL, *s = NULL, *t = NULL;
+  if (faultsubcodeQName)
+    r = soap_strdup(soap, faultsubcodeQName);
   if (faultstring)
     s = soap_strdup(soap, faultstring);
-  if (faultdetail)
-    t = soap_strdup(soap, faultdetail);
-  return soap_set_error(soap, faultcode, s, t, SOAP_FAULT);
+  if (faultdetailXML)
+    t = soap_strdup(soap, faultdetailXML);
+  return soap_set_error(soap, faultcode, r, s, t, SOAP_FAULT);
 }
 #endif
@@ -11576 +14795 @@
 int
 SOAP_FMAC2
-soap_sender_fault(struct soap *soap, const char *faultstring, const char *faultdetail)
-{ return soap_copy_fault(soap, soap->version == 2 ? "SOAP-ENV:Sender" : "SOAP-ENV:Client", faultstring, faultdetail);
+soap_sender_fault(struct soap *soap, const char *faultstring, const char *faultdetailXML)
+{ return soap_sender_fault_subcode(soap, NULL, faultstring, faultdetailXML);
 }
 #endif
@@ -11586 +14805 @@
 int
 SOAP_FMAC2
-soap_receiver_fault(struct soap *soap, const char *faultstring, const char *faultdetail)
-{ return soap_copy_fault(soap, soap->version == 2 ? "SOAP-ENV:Receiver" : "SOAP-ENV:Server", faultstring, faultdetail);
+soap_sender_fault_subcode(struct soap *soap, const char *faultsubcodeQName, const char *faultstring, const char *faultdetailXML)
+{ return soap_copy_fault(soap, soap->version == 2 ? "SOAP-ENV:Sender" : "SOAP-ENV:Client", faultsubcodeQName, faultstring, faultdetailXML);
 }
 #endif
@@ -11594 +14813 @@
 #ifndef PALM_2
 SOAP_FMAC1
+int
+SOAP_FMAC2
+soap_receiver_fault(struct soap *soap, const char *faultstring, const char *faultdetailXML)
+{ return soap_receiver_fault_subcode(soap, NULL, faultstring, faultdetailXML);
+}
+#endif
+
+/******************************************************************************/
+#ifndef PALM_2
+SOAP_FMAC1
+int
+SOAP_FMAC2
+soap_receiver_fault_subcode(struct soap *soap, const char *faultsubcodeQName, const char *faultstring, const char *faultdetailXML)
+{ return soap_copy_fault(soap, soap->version == 2 ? "SOAP-ENV:Receiver" : "SOAP-ENV:Server", faultsubcodeQName, faultstring, faultdetailXML);
+}
+#endif
+
+/******************************************************************************/
+#ifndef PALM_2
+#ifndef WITH_NOSTDLIB
+SOAP_FMAC1
 void
 SOAP_FMAC2
 soap_print_fault(struct soap *soap, FILE *fd)
-{ if (soap->error)
-  { const char **s;
-    if (!*soap_faultcode(soap))
+{ if (soap_check_state(soap))
+    fprintf(fd, "Error: soap struct state not initialized\n");
+  else if (soap->error)
+  { const char *c, *v = NULL, *s, **d;
+    d = soap_faultcode(soap);
+    if (!*d)
       soap_set_fault(soap);
-    fprintf(fd, "SOAP FAULT: %s\n\"%s\"\n", *soap_faultcode(soap), *soap_faultstring(soap));
-    s = soap_faultdetail(soap);
-    if (s && *s)
-      fprintf(fd, "Detail: %s\n", *s);
-  }
-}
+    c = *d;
+    if (soap->version == 2)
+      v = *soap_faultsubcode(soap);
+    s = *soap_faultstring(soap);
+    d = soap_faultdetail(soap);
+    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]");
+  }
+}
+#endif
 #endif
  
 /******************************************************************************/
-#ifndef PALM_1
+#ifdef __cplusplus
+#ifndef WITH_LEAN
+#ifndef WITH_NOSTDLIB
+SOAP_FMAC1
+void
+SOAP_FMAC2
+soap_stream_fault(struct soap *soap, std::ostream& os)
+{ if (soap_check_state(soap))
+    os << "Error: soap struct state not initialized\n";
+  else if (soap->error)
+  { const char *c, *v = NULL, *s, **d;
+    d = soap_faultcode(soap);
+    if (!*d)
+      soap_set_fault(soap);
+    c = *d;
+    if (soap->version == 2)
+      v = *soap_faultsubcode(soap);
+    s = *soap_faultstring(soap);
+    d = soap_faultdetail(soap);
+    os << (soap->version ? "SOAP 1." : "Error ")
+       << (soap->version ? (int)soap->version : soap->error)
+       << " fault: " << c
+       << "[" << (v ? v : "no subcode") << "]"
+       << std::endl
+       << "\"" << (s ? s : "[no reason]") << "\""
+       << std::endl
+       << "Detail: " << (d && *d ? *d : "[no detail]")
+       << std::endl;
+  }
+}
+#endif
+#endif
+#endif
+ 
+/******************************************************************************/
+#ifndef WITH_LEAN
+#ifndef WITH_NOSTDLIB
+SOAP_FMAC1
+char*
+SOAP_FMAC2
+soap_sprint_fault(struct soap *soap, char *buf, size_t len)
+{ if (soap_check_state(soap))
+    strncpy(buf, "Error: soap struct not initialized", len);
+  else if (soap->error)
+  { const char *c, *v = NULL, *s, **d;
+    d = soap_faultcode(soap);
+    if (!*d)
+      soap_set_fault(soap);
+    c = *d;
+    if (soap->version == 2)
+      v = *soap_faultsubcode(soap);
+    s = *soap_faultstring(soap);
+    d = soap_faultdetail(soap);
+#ifdef WIN32
+    _snprintf
+#else
+    snprintf
+#endif
+      (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]");
+  }
+  return buf;
+}
+#endif
+#endif
+ 
+/******************************************************************************/
+#ifndef PALM_1
+#ifndef WITH_NOSTDLIB
 SOAP_FMAC1
 void
@@ -11617 +14930 @@
 { 
 #ifndef WITH_LEAN
-  int c;
-  if (soap->error && soap->buflen > 0)
-  { if (soap->bufidx == 0)
-      soap->bufidx = 1;
-    c = soap->buf[soap->bufidx - 1];
-    soap->buf[soap->bufidx - 1] = '\0';
-    if (soap->buflen - soap->bufidx > 1024)
-      soap->buf[soap->bufidx + 1024] = '\0';
+  int i, j, c1, c2;
+  if (soap->error && soap->bufidx <= soap->buflen && soap->buflen > 0 && soap->buflen <= SOAP_BUFLEN)
+  { i = (int)soap->bufidx - 1;
+    if (i <= 0)
+      i = 0;
+    c1 = soap->buf[i];
+    soap->buf[i] = '\0';
+    if ((int)soap->buflen >= i + 1024)
+      j = i + 1023;
     else
-      soap->buf[soap->buflen - 1] = '\0';
-    fprintf(fd, "%s%c\n** HERE **\n", soap->buf, c);
+      j = (int)soap->buflen - 1;
+    c2 = soap->buf[j];
+    soap->buf[j] = '\0';
+    fprintf(fd, "%s%c\n<!-- ** HERE ** -->\n", soap->buf, c1);
     if (soap->bufidx < soap->buflen)
       fprintf(fd, "%s\n", soap->buf + soap->bufidx);
-  }
-#endif
-}
+    soap->buf[i] = c1;
+    soap->buf[j] = c2;
+  }
+#endif
+}
+#endif
 #endif
  
@@ -11643 +14962 @@
 { register struct soap_plugin *p;
   register int r;
-  if (!(p = (struct soap_plugin*)SOAP_MALLOC(sizeof(struct soap_plugin))))
+  if (!(p = (struct soap_plugin*)SOAP_MALLOC(soap, sizeof(struct soap_plugin))))
     return soap->error = SOAP_EOM;
   p->id = NULL;
@@ -11657 +14976 @@
   }
   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));
-  SOAP_FREE(p);
+  SOAP_FREE(soap, p);
   return r;
 }
@@ -11689 +15008 @@
 #endif
 
+/******************************************************************************\
+ *
+ *      C++ soap struct methods
+ *
+\******************************************************************************/
+
+#ifdef __cplusplus
+soap::soap()
+{ soap_init(this);
+}
+#endif
+
+/******************************************************************************/
+#ifdef __cplusplus
+soap::soap(soap_mode m)
+{ soap_init1(this, m);
+}
+#endif
+
+/******************************************************************************/
+#ifdef __cplusplus
+soap::soap(soap_mode im, soap_mode om)
+{ soap_init2(this, im, om);
+}
+#endif
+
+/******************************************************************************/
+#ifdef __cplusplus
+soap::soap(struct soap& soap)
+{ soap_copy_context(this, &soap);
+}
+#endif
+
+/******************************************************************************/
+#ifdef __cplusplus
+soap::~soap()
+{ soap_destroy(this);
+  soap_end(this);
+  soap_done(this);
+}
+#endif
+
+/******************************************************************************/