stdsoap2.c

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

  }
  DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\nEnter location=%p type=%d id=%d", p, type, soap->idnum+1));
  *ppp = pp = (struct soap_plist*)malloc(sizeof(struct soap_plist));
  if (pp)
  { h = hash_ptr(p);
    pp->next = soap->pht[h];
    pp->type = type;
    if (soap->disable_href || soap->is_in_header)
    { pp->mark1 = 0;
      pp->mark2 = 0;
    }
    else
    { pp->mark1 = 1;
      pp->mark2 = 1;
    }
    pp->ptr = (void*)p;
    pp->id = ++soap->idnum;
    soap->pht[h] = pp;
  }
  else
    return 0;
  return pp->id;
}

/******************************************************************************/
SOAP_FMAC1
int
SOAP_FMAC2
soap_array_pointer_enter(struct soap *soap, const void *p, int type, struct soap_plist **ppp)
{ int h;
  struct soap_plist *pp;
  if (!p || !*(void**)p)
  { *ppp = NULL;
    return 0;
  }
  DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\nArray enter location=%p type=%d id=%d", p, type|1024, soap->idnum+1));
  pp = (struct soap_plist*)malloc(sizeof(struct soap_plist));
  *ppp = pp;
  if (pp)
  { h = hash_ptr(*(void**)p);
    pp->next = soap->pht[h];
    pp->type = type|1024;
    if (soap->disable_href || soap->is_in_header)
    { pp->mark1 = 0;
      pp->mark2 = 0;
    }
    else
    { pp->mark1 = 1;
      pp->mark2 = 1;
    }
    pp->ptr = (void*)p;
    pp->id = ++soap->idnum;
    soap->pht[h] = pp;
  }
  else
    return 0;
  return pp->id;
}

/******************************************************************************/
SOAP_FMAC1
void
SOAP_FMAC2
soap_begin_count(struct soap *soap)
{ soap->counting = 1;
  soap->count = 0;
  soap->ns = 0;
  soap->null = 0;
  soap->position = 0;
  soap->mustUnderstand = 0;
  soap->dime_count = 0;	/* count # of attachments */
  soap->dime_size = 0;	/* accumulate total size of attachments */
  DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\nBegin count"));
}

/******************************************************************************/
SOAP_FMAC1
void
SOAP_FMAC2
soap_begin_send(struct soap *soap)
{ soap->chunked = 0;
  soap->counting = 0;
  soap->ns = 0;
  if (soap->socket >= 0)
    soap->buffering = 1;
  soap->bufidx = 0;
  soap->null = 0;
  soap->position = 0;
  soap->mustUnderstand = 0;
  DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\nBegin send (socket=%d buffered=%d chunked=%d)", soap->socket, (int)soap->buffering, (int)soap->chunked));
}

/******************************************************************************/
SOAP_FMAC1
void
SOAP_FMAC2
soap_embedded(struct soap *soap, const void *p, int t)
{ struct soap_plist *pp;
  DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\nembedded %p type=%d", p, t));
  if (soap_pointer_lookup(soap, p, t, &pp))
  { pp->mark1 = 1;
    pp->mark2 = 1;
    DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\nembedded %p type=%d set to %d", p, t, (int)pp->mark1));
  }
}

/******************************************************************************/
SOAP_FMAC1
int
SOAP_FMAC2
soap_reference(struct soap *soap, const void *p, int t)
{ int i;
  struct soap_plist *pp;
  if (!p)
    return 1;
  i = soap_pointer_lookup(soap, p, t, &pp);
  if (i)
  { if (pp->mark1 == 0)
    { pp->mark1 = 2;
      pp->mark2 = 2;
    }
  }
  else
  { soap_pointer_enter(soap, p, t, &pp);
    pp->mark1 = 0;
    pp->mark2 = 0;
  }
  DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\nreference %p type = %d (%d %d)", p, t, (int)pp->mark1, (int)pp->mark2));
  return pp->mark1;
}

/******************************************************************************/
SOAP_FMAC1
int
SOAP_FMAC2
soap_array_reference(struct soap *soap, const void *p, int n, int t)
{ int i;
  struct soap_plist *pp;
  if (!p)
    return 1;
  i = soap_array_pointer_lookup(soap, p, n, t, &pp);
  if (i)
  { if (pp->mark1 == 0)
    { pp->mark1 = 2;
      pp->mark2 = 2;
    }
  }
  else
  { soap_array_pointer_enter(soap, p, t, &pp);
    pp->mark1 = 0;
    pp->mark2 = 0;
  }
  DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\narray reference %p type = %d (%d %d)", p, t, (int)pp->mark1, (int)pp->mark2));
  return pp->mark1;
}

/******************************************************************************/
SOAP_FMAC1
int
SOAP_FMAC2
soap_embedded_id(struct soap *soap, int id, const void *p, int t)
{ struct soap_plist *pp;
  DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\nembedded_id %p type=%d id=%d", p, t, id));
  if (!soap->enable_embedding && !soap->disable_href && !soap->is_in_header)
  { if (id < 0)
    { id = soap_pointer_lookup(soap, p, t, &pp);
      if (id > 0 && pp)
      { if (soap->counting)
          pp->mark1 = 2;
        else
          pp->mark2 = 2;
      }
      return -1;
    }
    return id;
  }
  if (id < 0)
    id = soap_pointer_lookup(soap, p, t, &pp);
  else
    soap_pointer_lookup(soap, p, t, &pp);
  if (id > 0 && pp)
  { if (soap->counting)
      pp->mark1 = 1;
    else
      pp->mark2 = 1;
  DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\nembedded_id id=%d %p type=%d = (%d %d)", id, p, t, (int)pp->mark1, (int)pp->mark2));
  }
  return id;
}

/******************************************************************************/
SOAP_FMAC1
int
SOAP_FMAC2
soap_is_embedded(struct soap *soap, struct soap_plist *pp)
{ DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\nis embedded? %d %d", (int)pp->mark1, (int)pp->mark2));
  if (!soap->enable_embedding && !soap->disable_href && !soap->is_in_header)
  { if (soap->counting)
      return pp->mark1 != 0;
    else
      return pp->mark2 != 0;
  }
  else if (soap->counting)
    return pp->mark1 == 1;
  else
    return pp->mark2 == 1;
}

/******************************************************************************/
SOAP_FMAC1
int
SOAP_FMAC2
soap_is_single(struct soap *soap, struct soap_plist *pp)
{ if (soap->disable_href || soap->is_in_header)
    return 1;
  else if (soap->counting)
    return pp->mark1 == 0;
  else
    return pp->mark2 == 0;
}

/******************************************************************************/
SOAP_FMAC1
int
SOAP_FMAC2
soap_is_multi(struct soap *soap, struct soap_plist *pp)
{ if (soap->counting)
    return pp->mark1 == 2;
  else
    return pp->mark2 == 2;
}

/******************************************************************************/
SOAP_FMAC1
void
SOAP_FMAC2
soap_set_embedded(struct soap *soap, struct soap_plist *pp)
{ if (soap->counting)
    pp->mark1 = 1;
  else
    pp->mark2 = 1;
}

/******************************************************************************/
SOAP_FMAC1
void
SOAP_FMAC2
soap_set_attached(struct soap *soap, struct soap_plist *pp, const char *id, const char *type, const char *options, size_t size)
{ if (soap->counting)
  { if (pp->mark1 != 3)
    { pp->mark1 = 3;
      soap->dime_count++;	/* one more attachment found */
      soap->dime_size += 12;	/* increase total size (DIME fields) */
      if (id)
        soap->dime_size += (strlen(id)+3)&-4;
      if (type)
        soap->dime_size += (strlen(type)+3)&-4;
      if (options)
        soap->dime_size += 4 + (((((unsigned char)options[2]<<8 | (unsigned char)options[3]))+3)&-4);
      soap->dime_size += (size+3)&-4;
    }
  }
  else if (pp->mark2 != 3)
    pp->mark2 = 3;
  soap->dime = 1;		/* mark to ensure DIME is used */
}

/******************************************************************************/
SOAP_FMAC1
void
SOAP_FMAC2
soap_init_iht(struct soap *soap)
{ int i;
  DBGLOG(TEST, SOAP_MESSAGE(fdebug, "\nInitializing ID hashtable"));
  for (i = 0; i < SOAP_IDHASH; i++)
    soap->iht[i] = NULL;
}

/******************************************************************************/
SOAP_FMAC1
void
SOAP_FMAC2
soap_free_iht(struct soap *soap)
{ int i;
  struct soap_ilist *ip, *next;
  for (i = 0; i < SOAP_IDHASH; i++)
  { for (ip = soap->iht[i]; ip; ip = next)
    { next = ip->next;
      free(ip);
    }
    soap->iht[i] = NULL;
  }
}

/******************************************************************************/
static struct soap_ilist*
lookup(struct soap *soap, const char *id)
{ struct soap_ilist *ip;
  for (ip = soap->iht[hash_id(id)]; ip; ip = ip->next)
    if (!strcmp(ip->id, id))
      return ip;
  return NULL;
}

/******************************************************************************/
static struct soap_ilist *
enter(struct soap *soap, const char *id)
{ int h;
  struct soap_ilist *ip;
  ip = (struct soap_ilist*)malloc(sizeof(struct soap_ilist)+strlen(id)-3);
  if (ip)
  { h = hash_id(id);
    strcpy(ip->id, id);
    ip->next = soap->iht[h];
    soap->iht[h] = ip;
    return ip;
  }
  return NULL;
}

/******************************************************************************/
SOAP_FMAC1
void*
SOAP_FMAC2
soap_malloc(struct soap *soap, size_t n)
{ char *p;
  if (!n)
    return NULL;
  if (!soap)
    return malloc(n);
  n += (-(int)n) & 7;
  if (!(p = (char*)malloc(n + 16)))
  { soap->error = SOAP_EOM;
    return NULL;
  }
  DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\nMallocing %d bytes", n));
  /* keep chain of alloced cells for later destruction */
  soap->alloced = 1;
  *(void**)(p + n) = soap->alist;
  *(size_t*)(p + n + 8) = n;
  soap->alist = p + n;
  DBGLOG(TEST, SOAP_MESSAGE(fdebug," -- location=%p", p));
  return p;
}

/******************************************************************************/
SOAP_FMAC1
void
SOAP_FMAC2
soap_dealloc(struct soap *soap, void *p)
{ if (!soap)
    return;
  if (p)
  { char **q;
    struct soap_clist **cp;
    for (q = (char**)&soap->alist; *q; q = *(char***)q)
    { if (p == (void*)(*q - *(size_t*)(*q + 8)))
      { *q = **(char***)q;
	free(p);
        DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\nFreed data %p", p));
        return;
      }
    }
    for (cp = &soap->clist; *cp; cp = &(*cp)->next)
    { if (p == (*cp)->ptr)
      { soap_delete(soap, p, (*cp)->type, (*cp)->size);
        DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\nDeleted class instance %p", p));
        p = (void*)*cp;
        *cp = (*cp)->next;
        free(p);
        return;
      }
    }
    DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\nCould not dealloc data %p: address not in list", p));
  }
  else
  { char *q;
    while (soap->alist)
    { q = (char*)soap->alist;
      soap->alist = *(void**)q;
      q -= *(size_t*)(q + 8);
      free(q);
      if (q == (char*)soap->fault)
        soap->fault = NULL;	/* this was deallocated */
      else if (q == (char*)soap->header)
        soap->header = NULL;	/* this was deallocated */
    }
    DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\ndealloced all data ok"));
  }
}

/******************************************************************************/
SOAP_FMAC1
void
SOAP_FMAC2
soap_destroy(struct soap *soap)
{ struct soap_clist *cp;
  DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\ndestroying class instances"));
  while (soap->clist)
  { cp = soap->clist;
    soap->clist = cp->next;
    if (cp->ptr)
    { DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\ndeleting class instance %p", cp->ptr));
      soap_delete(soap, cp->ptr, cp->type, cp->size);
    }
    free(cp);
  }
  DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\ndestruction ok"));
}

/******************************************************************************/
SOAP_FMAC1
void
SOAP_FMAC2
soap_unlink(struct soap *soap, void *p)
{ char **q;
  struct soap_clist **cp;
  if (!soap)
    return;
  for (q = (char**)&soap->alist; *q; q = *(char***)q)
  { if (p == (void*)(*q - *(size_t*)(*q + 8)))
    { *q = **(char***)q;
      DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\nunlinked data %p", p));
      return;
    }
  }
  for (cp = &soap->clist; *cp; cp = &(*cp)->next)
  { if (p == (*cp)->ptr)
    { DBGLOG(TEST, SOAP_MESSAGE(fdebug,"\nunlinked class instance %p", p));
      p = (void*)*cp;
      *cp = (*cp)->next;
      free(p);
      return;
    }
  }
}

/******************************************************************************/
SOAP_FMAC1
int
SOAP_FMAC2
soap_lookup_type(struct soap *soap, const char *id)
{ struct soap_ilist *ip;
  if (*id)
  { ip =