stdsoap2.cpp

linux下开发的soap协议。建议大家学习学习！

    *q = ip->ptr;
    q = (void**)p;
  }
}

/******************************************************************************/
static void
soap_resolve_copy(struct soap *soap, struct soap_ilist *ip)
{ void *p, **q;
  q = (void**)ip->copy;
  DBGLOG(TEST, if (q) SOAP_MESSAGE(fdebug,"\nTraversing copy chain to resolve type %s", ip->id));
  ip->copy = NULL;
  while (q) 
  { DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\nstep... move %p -> %p (%d bytes)", ip->ptr, q, ip->size));
    p = *q;
    soap_update_ptrs(soap, (char*)q, (char*)q + ip->size, (char*)q - (char*)ip->ptr);
    memcpy(q, ip->ptr, ip->size);
    q = (void**)p;
  }
}

/******************************************************************************/
SOAP_FMAC1
void
SOAP_FMAC2
soap_store_block(struct soap *soap, char *p)
{ size_t n;
  int i;
  char *q, *s;
  struct soap_blist *bp;
  struct soap_ilist *ip;
  DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\nStore all blocks, size = %d (%p->%p)", soap->blist->size, soap->blist->ptr, p));
  if (soap->blist->ptr)
  { n = *((size_t*)(soap->blist->ptr + sizeof(char*)));
    if (p)
    { if (n)
        n = soap->blist->size % n;
      p += soap->blist->size - n;
  DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\nNo fit: start at the end (%p) remainder = %d", p, n));
      s = soap->blist->ptr + sizeof(char*) + sizeof(size_t);
      DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\nCopy %d (%p->%p)", n, s, p));
      if (n)
      { soap_update_ptrs(soap, s, s+n, p-s);
        memcpy(p, s, n);
      }
      q = *((char**)soap->blist->ptr);
      free(soap->blist->ptr);
      DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\nCopying into contiguous area..."));
      for (soap->blist->ptr = q; soap->blist->ptr; soap->blist->ptr = q)
      { q = *((char**)soap->blist->ptr);
        n = *((size_t*)(soap->blist->ptr + sizeof(char*)));
        p -= n;
        s = soap->blist->ptr + sizeof(char*) + sizeof(size_t);
        DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\nCopy %d (%p->%p)", n, s, p));
        soap_update_ptrs(soap, s, s+n, p-s);
        memcpy(p, s, n);
        free(soap->blist->ptr);
      }
    }
    DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\nEnd of block sequence"));
  }
  bp = soap->blist;
  soap->blist = soap->blist->next;
  free(bp);
  DBGLOG(TEST, if (soap->blist) SOAP_MESSAGE(fdebug,"\nRestore previous block sequence size=%d", soap->blist->size));
  if (!soap->blist)
  { /* get "delayed" backward pointers resolved NOW, instead of later */
    for (i = 0; i < SOAP_IDHASH; i++)
      for (ip = soap->iht[i]; ip; ip = ip->next)
        if (ip->ptr)
          soap_resolve_ptr(ip);
  }
}

/******************************************************************************/
SOAP_FMAC1
int
SOAP_FMAC2
soap_push_namespace(struct soap *soap, const char *id, const char *ns)
{ int i;
  struct soap_nlist *np = (struct soap_nlist*)malloc(sizeof(struct soap_nlist));
  if (!np)
    return SOAP_EOM;
  np->level = soap->level;
  np->next = soap->nlist;
  soap->nlist = np;
  np->id = (char*)malloc(strlen(id)+1);
  if (!np->id)
    return SOAP_EOM;
  strcpy(np->id, id);
  np->index = -1;
  DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\nPush namespace binding (level=%d) '%s' '%s'", soap->level, id, ns));
  for (i = 0; soap->namespaces[i].id; i++)
  { if (soap->namespaces[i].ns)
      if (!soap_tag_cmp(ns, soap->namespaces[i].ns))
        break;
    if (soap->namespaces[i].in)
      if (!soap_tag_cmp(ns, soap->namespaces[i].in))
      { if (soap->namespaces[i].out)
          free(soap->namespaces[i].out);
        if ((soap->namespaces[i].out = (char*)malloc(strlen(ns)+1)))
          strcpy(soap->namespaces[i].out, ns);
        break;
      }
  }
  if (soap->namespaces[i].id)
  { DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\nPush OK (match=%s)", soap->namespaces[i].id));
    np->index = i;
  }
  else
  { DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\nPush NOT OK: no match found in namespace mapping table"));
  }
  return SOAP_OK;
}

/******************************************************************************/
SOAP_FMAC1
void
SOAP_FMAC2
soap_pop_namespace(struct soap *soap)
{ struct soap_nlist *np;
  while (soap->nlist && soap->nlist->level == soap->level)
  { np = soap->nlist->next;
    DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\nPopped namespace binding (level=%d) '%s'", soap->level, soap->nlist->id));
    free(soap->nlist->id);
    free(soap->nlist);
    soap->nlist = np;
  }
}

/******************************************************************************/
SOAP_FMAC1
int
SOAP_FMAC2
soap_match_namespace(struct soap *soap, const char *id1, const char *id2, int n1, int n2) 
{ 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->namespaces[np->index].id && (strncmp(soap->namespaces[np->index].id, id2, n2) || soap->namespaces[np->index].id[n2])))
      return SOAP_NAMESPACE;
    return SOAP_OK;
  }
  return SOAP_SYNTAX_ERROR; 
}

/******************************************************************************/
SOAP_FMAC1
int
SOAP_FMAC2
soap_match_tag(struct soap *soap, const char *tag1, const char *tag2)
{ const char *s, *t;
  if (tag1 == NULL || tag2 == NULL)
    return SOAP_OK;
  s = strchr(tag1, ':');
  t = strchr(tag2, ':');
  if (s)
  { if (t)
    { if (soap_match_namespace(soap, tag1, tag2, s-tag1, t-tag2))
      { DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\nNamespace mismatch in tag comparison: '%s' '%s'", tag1, tag2));
	return SOAP_TAG_MISMATCH;
      }
      t++;
    } 
    else
      t = tag2;
    s++;
  }
  else if (t)
  { s = tag1;
    t++;
  }
  else
  { s = tag1;
    t = tag2;
  }
  if (soap_tag_cmp(s, t))
    return SOAP_TAG_MISMATCH;
  DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\nTags match: '%s' '%s'", tag1, tag2));
  return SOAP_OK;
}

/******************************************************************************/
SOAP_FMAC1
int
SOAP_FMAC2
soap_match_array(struct soap *soap, const char *type)
{ if (*soap->type && *soap->arrayType)
    if (soap_match_tag(soap, soap->arrayType, type)
     && soap_match_tag(soap, soap->arrayType, "xsd:anyType")
     && soap_match_tag(soap, soap->arrayType, "xsd:ur-type")
    )
    { DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\nArray type mismatch: '%s' '%s'", soap->arrayType, type));
      return SOAP_TAG_MISMATCH;
    }
  return SOAP_OK;
}

/******************************************************************************/

#ifdef WITH_OPENSSL
/******************************************************************************/
static int
ssl_init()
{ static int done = 0;
  if (done)
    return 0;
  done = 1;
  SSL_library_init();
  SSL_load_error_strings();
  soap_ssl_ctx = SSL_CTX_new(SSLv23_method());
  return !soap_ssl_ctx;
}

/******************************************************************************/
static const char *
ssl_error(struct soap *soap, int ret)
{ switch (SSL_get_error(soap->ssl, ret))
  { 
#ifdef SSL_ERROR_NONE
    case SSL_ERROR_NONE:
      return "SSL_ERROR_NONE";
#endif
#ifdef SSL_ERROR_ZERO_RETURN
    case SSL_ERROR_ZERO_RETURN:
      return "SSL_ERROR_ZERO_RETURN";
#endif
#ifdef SSL_ERROR_WANT_READ
    case SSL_ERROR_WANT_READ:
      return "SSL_ERROR_WANT_READ";
#endif
#ifdef SSL_ERROR_WANT_WRITE
    case SSL_ERROR_WANT_WRITE:
      return "SSL_ERROR_WANT_WRITE";
#endif
#ifdef SSL_ERROR_WANT_CONNECT
    case SSL_ERROR_WANT_CONNECT:
      return "SSL_ERROR_WANT_CONNECT";
#endif
#ifdef SSL_ERROR_WANT_ACCEPT
    case SSL_ERROR_WANT_ACCEPT:
      return "SSL_ERROR_WANT_ACCEPT";
#endif
#ifdef SSL_ERROR_WANT_X509_LOOKUP
    case SSL_ERROR_WANT_X509_LOOKUP:
      return "SSL_ERROR_WANT_X509_LOOKUP";
#endif
#ifdef SSL_ERROR_SYSCALL
    case SSL_ERROR_SYSCALL:
      return "SSL_ERROR_SYSCALL";
#endif
#ifdef SSL_ERROR_SSL
    case SSL_ERROR_SSL:
      return "SSL_ERROR_SSL";
#endif
  }
  return "Unknown SSL error";
}

/******************************************************************************/
static int
fpassword(char *buf, int num, int rwflag, void *userdata)
{ if (num < strlen(soap_ssl_pw)+1)
    return(0);
  strcpy(buf, soap_ssl_pw);
  return strlen(soap_ssl_pw);
}

/******************************************************************************/
static int
ssl_auth_init(struct soap *soap)
{ ssl_init();
  if (soap->keyfile)
    if (!(SSL_CTX_use_certificate_chain_file(soap_ssl_ctx, soap->keyfile)))
    { *soap_faultcode(soap) = "SOAP-ENV:Server";
      *soap_faultstring(soap) = "Can't read certificate file";
      return SOAP_SSL_ERROR;
    }
  if (soap->password && soap->keyfile)
  { soap_ssl_pw = soap->password;
    SSL_CTX_set_default_passwd_cb(soap_ssl_ctx, fpassword);
    if (!(SSL_CTX_use_PrivateKey_file(soap_ssl_ctx, soap->keyfile, SSL_FILETYPE_PEM)))
    { *soap_faultcode(soap) = "SOAP-ENV:Server";
      *soap_faultstring(soap) = "Can't read key file";
      return SOAP_SSL_ERROR;
    }
  }
  if (soap->cafile)
    if (!(SSL_CTX_load_verify_locations(soap_ssl_ctx, soap->cafile, 0)))
    { *soap_faultcode(soap) = "SOAP-ENV:Server";
      *soap_faultstring(soap) = "Can't read CA list";
      return SOAP_SSL_ERROR;
    }
  if (soap->dhfile)
  { DH *r = 0;
    BIO *bio;
    bio = BIO_new_file(soap->dhfile, "r");
    if (!bio)
    { *soap_faultcode(soap) = "SOAP-ENV:Server";
      *soap_faultstring(soap) = "Can't read DH file";
      return SOAP_SSL_ERROR;
    }
    r = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
    BIO_free(bio);
    if (SSL_CTX_set_tmp_dh(soap_ssl_ctx, r) < 0)
    { *soap_faultcode(soap) = "SOAP-ENV:Server";
      *soap_faultstring(soap) = "Can't set DH parameters";
      return SOAP_SSL_ERROR;
    }
  }
#if (OPENSSL_VERSION_NUMBER < 0x00905100L)
  SSL_CTX_set_verify_depth(soap_ssl_ctx, 1); 
#endif  
  return SOAP_OK;
}

/******************************************************************************/
SOAP_FMAC1
int
SOAP_FMAC2
soap_ssl_accept(struct soap *soap)
{ int r;
  soap->error = ssl_auth_init(soap);
  if (soap->error)
    return soap->error;
  if (soap->socket <= 0)
  { *soap_faultcode(soap) = "SOAP-ENV:Server";
    *soap_faultstring(soap) = "No socket in soap_ssl_accept()";
    return soap->error = SOAP_SSL_ERROR;
  } 
  soap->ssl = SSL_new(soap_ssl_ctx);
  if (!soap->ssl)
  { *soap_faultcode(soap) = "SOAP-ENV:Server";
    *soap_faultstring(soap) = "SSL_new failed in soap_ssl_accept()";
    return soap->error = SOAP_SSL_ERROR;
  }
  soap->bio = BIO_new_socket(soap->socket, BIO_NOCLOSE);
  SSL_set_bio(soap->ssl, soap->bio, soap->bio);
  r = SSL_accept(soap->ssl);
  if (r <= 0)
  { *soap_faultcode(soap) = "SOAP-ENV:Server";
    *soap_faultstring(soap) = "SSL_accept failed in soap_ssl_accept()";
    *soap_faultdetail(soap) = ssl_error(soap, r);
    return soap->error = SOAP_SSL_ERROR;
  }
  return SOAP_OK;
}

/******************************************************************************/
#endif

/******************************************************************************/
static int
tcp_init(struct soap *soap)
{ soap->errmode = 1;
#ifdef WIN32
  if (tcp_done)
    return 0;
  tcp_done = 1;
  { WSADATA w;
    if (WSAStartup(MAKEWORD(1, 1), &w))
    { tcp_done = 0;
      return -1;
    }
  }
#endif
  return 0;
}

/******************************************************************************/
SOAP_FMAC1
void
SOAP_FMAC2
soap_done(struct soap *soap)
{ soap_closesock(soap);
  if (soap->master >= 0)
  { closesocket(soap->master);
    soap->master = -1;
  }
  soap->fpost = http_post;
  soap->fresponse = http_response;
  soap->fparse = http_parse;
  soap->fopen = tcp_connect;
  soap->fclose = tcp_disconnect;
  soap->fsend = fsend;
  soap->frecv = frecv;
  soap->fignore = fignore;
#ifdef WIN32
  if (!tcp_done)
    return;
  tcp_done = 0;
  WSACleanup();
#endif
}

/******************************************************************************/
static const char*
tcp_error(struct soap *soap)
{ const char *msg = NULL;
  switch (soap->errmode)
  { case 0:
      msg = soap_strerror(soap, soap->errnum);
      break;
    case 1:
      msg = "WSAStartup failed";
      break;
    case 2:
    { struct code_map *map = h_errno_codes;
      while (map->code && map->code != soap->errnum)
	map++;
      if (map->code)
	msg = map->string;
      else
      { sprintf(soap->msgbuf, "Unknown TCP error code %d\n", soap->errnum);
	msg = soap->msgbuf;
      }
    }
  }
  return msg;
}

/******************************************************************************/
static int
soap_gethost(struct soap *soap, const char *addr, struct in_addr *inaddr)
{ unsigned long iadd;
  struct hostent hostent, *host = &hostent;
  iadd = inet_addr(addr);
  if ((int)iadd != -1)
  { memcpy(inaddr, &iadd, sizeof(iadd));
    return 0;
  }
#ifdef __GLIBC__
  if (gethostbyname_r(addr, &hostent, soap->buf, SOAP_BUFLEN, &host, &soap->errnum) < 0)
    host = NULL;
#else
#if defined(WIN32) || defined(_AIXVERSION_431) || defined(__APPLE__)
  if (!(host = gethostbyname(addr)))
    soap->errnum = h_errno;
#else
  host = gethostbyname_r(addr, &hostent, soap->buf, SOAP_BUFLEN, &soap->errnum);
#endif
#endif
  if (!host)
  { DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\nHost name not found"));
    return -1;
  }
  memcpy(inaddr, host->h_addr, host->h_length);
  return 0;
}