Context with engine state

This module defines the soap context structure with the engine state with API functions to allocate, initialize, copy, and delete contexts. More...

Classes
struct	soap
	Context with the engine state. More...

Functions
*Allocate and initialize a new ::soap context struct soap *soap_new *() * @returns pointer to allocated and initialized ` Allocate and initialize a new ::soap context with input and output ::soap_mode flags struct soap *soap_new1 *(soap_mode input_and_output_mode) * @returns pointer to allocated and initialized ` Allocate and initialize a new ::soap context with separate input and output ::soap_mode flags struct soap *soap_new2 *(soap_mode input_mode, soap_mode output_mode) * @returns pointer to allocated and initialized ` Initialize a stack allocated ::soap context void	soap_init (struct soap *soap)
*Initialize a stack allocated ::soap context with input and output ::soap_mode flags void	soap_init1 (struct soap *soap, soap_mode input_and_output_mode)
*Initialize a stack allocated ::soap context with input and output ::soap_mode flags void	soap_init2 (struct soap *soap, soap_mode input_mode, soap_mode output_mode)
*Set input and output ::soap_mode flags of the given ::soap context void	soap_set_mode (struct soap *soap, soap_mode input_and_output_mode)
*Set input ::soap_mode flags of the given ::soap context void	soap_set_imode (struct soap *soap, soap_mode input_mode)
*Set output ::soap_mode flags of the given ::soap context void	soap_set_omode (struct soap *soap, soap_mode output_mode)
*Clear input and output ::soap_mode flags of the given ::soap context void	soap_clr_mode (struct soap *soap, soap_mode input_and_output_mode)
*Clear input ::soap_mode flags of the given ::soap context void	soap_clr_imode (struct soap *soap, soap_mode input_mode)
*Clear output ::soap_mode flags of the given ::soap context void	soap_clr_omode (struct soap *soap, soap_mode output_mode)
*Copy the input output stream state of the given ::soap context to another context void	soap_copy_stream (struct soap *soap_destination, struct soap *soap_source)
*Free the input output stream state of the given ::soap context void	soap_free_stream (struct soap *soap)
*Finalize and free the given ::soap context from unmanaged heap memory void	soap_free (struct soap *soap)
*Finalize the given ::soap i e when the ::soap context is stack automatically invoked in C by the ::soap destructor on the ::soap context to delete void	soap_done (struct soap *soap)
*Allocate a block of heap memory managed by the specified ::soap context void *	soap_malloc (struct soap *soap, size_t len) * @returns pointer to the allocated block of memory or NULL on failure to allocate(out of memory)
*Copy a string to managed memory char *	soap_strdup (struct soap *soap, const char *string) * @returns copy of string or NULL when the specified string is NULL or on failure to allocate(out of memory)
*Copy a wide string to managed memory wchar_t *	soap_wstrdup (struct soap *soap, const wchar_t *string) * @returns copy of wide string or NULL when the specified wide string is NULL or on failure to allocate(out of memory)
*Unlink a block of heap memory managed by the specified ::soap to release the memory explicitly later int	soap_unlink (struct soap *soap, const void *ptr) * @returns `
*Delete all dynamically allocated C objects managed by the specified ::soap context void	soap_destroy (struct soap *soap)
*Explicitly dealllocates a block of managed memory that is managed by the specified ::soap context and release the free memory back to the heap void	soap_dealloc (struct soap *soap, void *ptr)
*Delete temporary data void	soap_free_temp (struct soap *soap)
*Delete all data from heap memory managed by the specified ::soap context and release the freed memory back to the heap void	soap_end (struct soap *soap)
*Delegate the deletion of all managed objects and data from the specified ::soap context to another ::soap context void	soap_delegate_deletion (struct soap *soap, struct soap *soap_to)
*Set SOAP	version (0=no SOAP, 1=SOAP 1.1, 2=SOAP 1.2) void soap_set_version(struct soap *soap

Variables
*A built in string type containing literal XML content in UTF format typedef char *	_XML
*A built in string type containing normalized QName contents typedef char *	_QName
*Allocate and initialize a new ::soap context as a copy of the given ::soap context struct soap *soap_copy *(struct soap *soap) * @returns pointer to allocated and initialized ` Copy a given ::soap context to an uninitialized destination ::soap context voi	soap_copy_context )(struct soap *soap_destination, struct soap *soap_source)
*Finalize the given ::soap	context
*Finalize the given ::soap i e when the ::soap context is stack	allocated
*Set SOAP short	version
	< soap contexr

Detailed Description

This module defines the soap context structure with the engine state with API functions to allocate, initialize, copy, and delete contexts.

View the context structure with the engine state (a separate page) for more details on the context structure member variables. The member variables used in this page and elsewhere in the documentation are hyperlinked. Most structure member variables may be changed directly as is documented with illustrative examples.

Function Documentation

soap_clr_imode()

*Clear input ::soap_mode flags of the given ::soap context void soap_clr_imode	(	struct soap *	soap,
		soap_mode	input_mode )

Parameters

soap	soap context
input_mode	input soap_mode flags

soap_clr_mode()

*Clear input and output ::soap_mode flags of the given ::soap context void soap_clr_mode	(	struct soap *	soap,
		soap_mode	input_and_output_mode )

Parameters

soap	soap context
input_and_output_mode	input and output soap_mode flags

soap_clr_omode()

*Clear output ::soap_mode flags of the given ::soap context void soap_clr_omode	(	struct soap *	soap,
		soap_mode	output_mode )

Parameters

soap	soap context
output_mode	output soap_mode flags

soap_copy_stream()

*Copy the input output stream state of the given ::soap context to another context void soap_copy_stream	(	struct soap *	soap_destination,
		struct soap *	soap_source )

This function copies the input/output state of the specified source context to the specified destination context. Both contexts will share the same input/output streams , i.e. soap::is, soap::os, soap::socket, soap::recvfd and soap::sendfd are shared and the current message buffer soap::buf content is copied. The destination context is set to the source context soap_mode flags and timeouts. To move the input/output state of one context to another, use this function and then call soap_free_stream on the source context to clear its input/output state.

Example:

#include "soapH.h"
 
struct soap *soap = soap_new();
struct soap *temp = soap_new();
... // send and receive messages etc.
// move the input/output state to another context
soap_copy_stream(temp, soap); 
soap_free_stream(soap);
soap_closesock(soap); // has no effect
... // send and receive messages etc.
soap_closesock(temp); // closes socket, if open

See also

soap_free_stream.

Parameters

soap_destination	destination soap context
soap_source	source soap context

soap_dealloc()

*Explicitly dealllocates a block of managed memory that is managed by the specified ::soap context and release the free memory back to the heap void soap_dealloc	(	struct soap *	soap,
		void *	ptr )

This function deallocates a managed block of memory from the managing soap context and releases the free memory back to the heap. This frees data allocated with soap_malloc and C++ objects allocated and instantiated with the soap_new_T functions. Normally this function should not be used to individually deallocate managed objects and data but rather soap_destroy and soap_end should be used to deallocate all objects and data managed by the context, which is much more efficient.

Parameters

soap	soap context
ptr	pointer to the block of managed heap memory to deallocate

soap_delegate_deletion()

*Delegate the deletion of all managed objects and data from the specified ::soap context to another ::soap context void soap_delegate_deletion	(	struct soap *	soap,
		struct soap *	soap_to )

This function delegates management of all dynamically-allocated data managed by the specified soap context to the target context soap_to for deletion by the target context using soap_destroy and soap_end in that order. Any pointers to the data remain valid (until deletion later) and can be safely used by an application. Only the management of the data is moved to the target context and is combined with any existing managed data.

Example:

#include "soapH.h"
 
struct soap *soap = soap_new();
struct soap *temp = soap_new(); // temp context to manage data
if (soap_call_ns__webmethod(soap, endpoint, NULL, ...))
{
  soap_print_fault(soap, stderr);
}
else
{
  // success, response contains deserialized data
  soap_delegate_deletion(soap, temp); // deserialized data is managed by temp context
}
soap_destroy(soap); // clean up 'soap' context
soap_end(soap);     // clean up 'soap' context
... // use deserialized data managed by 'temp' context, reuse 'soap' context as needed
soap_destroy(temp); // clean up 'temp' context, deletes deserialized data
soap_end(temp);     // clean up 'temp' context, deletes deserialized data
soap_free(temp);
soap_free(soap);

See also

::soap_copy, soap_copy_context, soap_destroy, soap_end.

Parameters

soap	source soap context
soap_to	target soap context

soap_destroy()

*Delete all dynamically allocated C objects managed by the specified ::soap context void soap_destroy

(

struct soap *

soap

)

This function deletes all dynamically-allocated C++ objects managed by the specified soap context, i.e. data allocated with soap_new_T calls. This call should be followed by soap_end to delete all other dynamically-allocated data managed by the soap context. Or just invoke soap::destroy to delete objects and data and release the freed memory back to the heap.

Note

C++ proxy and service classes generated by soapcpp2 -j option -j or option -i have an internal soap context that is either a base class (option -i) or a member variable pointing to a soap context (option -j). For convenience, use the destroy member function instead of soap_destroy and soap_end. For example:

#include "soapexampleProxy.h"
 
exampleProxy proxy(SOAP_XML_INDENT);
... // use proxy or proxy.soap (option -j)
proxy.destroy(); // delete managed C++ objects and memory

#include "soapexampleService.h"
 
exampleService service(SOAP_XML_INDENT);
... // use service or service.soap (option -j)
service.destroy(); // delete managed C++ objects and memory

Example:

#include "soapH.h"
 
struct soap *soap = soap_new();
... // send and receive messages etc.
soap_destroy(soap); // delete managed C++ objects
soap_end(soap);     // delete managed memory
soap_free(soap);    // free the context

See also

soap_malloc, soap_end, soap::destroy.

Parameters

soap	soap context

soap_done()

*Finalize the given ::soap i e when the ::soap context is stack automatically invoked in C by the ::soap destructor on the ::soap context to delete void soap_done

(

struct soap *

soap

)

This function finalizes the specified context. This function does not free memory managed by the context. To free memory managed by the context use soap_destroy and soap_end, or soap::destroy to call both.

Example:

#include "soapH.h"
 
struct soap soap;
soap_init(&soap);
... // send and receive messages etc.
soap_destroy(&soap);
soap_end(&soap);
soap_done(&soap);

See also

soap_free, soap_destroy, soap_end, soap::destroy.

Parameters

soap	soap context to finalize

soap_end()

*Delete all data from heap memory managed by the specified ::soap context and release the freed memory back to the heap void soap_end

(

struct soap *

soap

)

This function deletes all dynamically-allocated data managed by the specified soap context, i.e. data allocated with soap_malloc. This call suffices to delete all managed data from C applications and release the freed memory back to the heap. C++ applications however should call soap_destroy first before soap_end or just invoke soap::destroy (or C++ proxy and service class member function destroy) to delete objects and data and release the freed memory back to the heap.

Note

C++ proxy and service classes generated by soapcpp2 -j option -j or option -i have an internal soap context that is either a base class (option -i) or a member variable pointing to a soap context (option -j). For convenience, use the destroy member function instead of soap_destroy and soap_end. For example:

#include "soapexampleProxy.h"
 
exampleProxy proxy(SOAP_XML_INDENT);
... // use proxy or proxy.soap (option -j)
proxy.destroy(); // delete managed C++ objects and memory

#include "soapexampleService.h"
 
exampleService service(SOAP_XML_INDENT);
... // use service or service.soap (option -j)
service.destroy(); // delete managed C++ objects and memory

Example:

#include "soapH.h"
 
struct soap *soap = soap_new();
... // send and receive messages etc.
soap_destroy(soap); // delete managed C++ objects
soap_end(soap);     // delete managed memory
soap_free(soap);    // free the context

See also

soap_malloc, soap_destroy, soap::destroy.

Parameters

soap	soap context

soap_free()

*Finalize and free the given ::soap context from unmanaged heap memory void soap_free

(

struct soap *

soap

)

This function finalizes and frees the specified context. The finalization is done with soap_done before releasing its memory. This function does not free memory managed by the context. To free memory managed by the context use soap_destroy and soap_end, or soap::destroy to call both.

Note

C++ proxy and service classes generated by soapcpp2 -j option -j or option -i have an internal soap context that is either a base class (option -i) or a member variable pointing to a soap context (option -j). The C++ proxy and service classes allocate and deallocate this context, which means that ::soap_new and soap_free are not required. For example:

#include "soapexampleProxy.h"
 
exampleProxy proxy(SOAP_XML_INDENT);
... // use proxy or proxy.soap (option -j)
proxy.destroy(); // delete managed C++ objects and memory

#include "soapexampleService.h"
 
exampleService service(SOAP_XML_INDENT);
... // use service or service.soap (option -j)
service.destroy(); // delete managed C++ objects and memory

Example:

#include "soapH.h"
 
struct soap *soap = soap_new();
... // send and receive messages etc.
soap_destroy(soap);
soap_end(soap);
soap_free(soap);

See also

::soap_new, ::soap_new1, ::soap_new2, soap_done, soap_destroy, soap_end, soap::destroy.

Parameters

soap	soap context to free

soap_free_stream()

*Free the input output stream state of the given ::soap context void soap_free_stream

(

struct soap *

soap

)

See also

soap_copy_stream.

Parameters

soap	soap context

soap_free_temp()

*Delete temporary data void soap_free_temp

(

struct soap *

soap

)

This function deallocates temporary data such as buffers and hash tables but leaves deserialized managed data intact.

Parameters

soap	soap context

soap_init()

*Allocate and initialize a new ::soap context struct soap *soap_new *() *@returns pointer to allocated and initialized ` Allocate and initialize a new ::soap context with input and output ::soap_mode flags struct soap *soap_new1 *(soap_mode input_and_output_mode) *@returns pointer to allocated and initialized ` Allocate and initialize a new ::soap context with separate input and output ::soap_mode flags struct soap *soap_new2 *(soap_mode input_mode, soap_mode output_mode) *@returns pointer to allocated and initialized ` Initialize a stack allocated ::soap context void soap_init

(

struct soap *

soap

)

This function allocates and initializes a new context.

There is no need to call soap_init to initialize the context allocated with ::soap_new, since ::soap_new initializes the allocated context. To change the input/output mode flags, use soap_set_mode and soap_clr_mode.

Note

C++ proxy and service classes generated by soapcpp2 -j option -j or option -i have an internal soap context that is either a base class (option -i) or a member variable pointing to a soap context (option -j). The C++ proxy and service classes allocate and deallocate this context, which means that ::soap_new and soap_free are not required. For example:

#include "soapexampleProxy.h"
 
exampleProxy proxy(SOAP_XML_INDENT);
... // use proxy or proxy.soap (option -j)
proxy.destroy(); // delete managed C++ objects and memory

#include "soapexampleService.h"
 
exampleService service(SOAP_XML_INDENT);
... // use service or service.soap (option -j)
service.destroy(); // delete managed C++ objects and memory

Example:

#include "soapH.h"
 
struct soap *soap = soap_new();
... // send and receive messages etc.
soap_destroy(soap); // delete managed C++ objects
soap_end(soap);     // delete managed memory
soap_free(soap);    // free the context

See also

::soap_new1, ::soap_new2, ::soap_copy, soap_destroy, soap_end, soap_free. This function allocates and initializes a new context with the specified input and output soap_mode flags.

Example:

#include "soapH.h"
 
struct soap *soap = soap_new1(SOAP_XML_INDENT);
... // send and receive messages etc.
soap_destroy(soap); // delete managed C++ objects
soap_end(soap);     // delete managed memory
soap_free(soap);    // free the context

Note

There is no need to call soap_init to initialize the context allocated with ::soap_new1. To change the input/output mode flags, use soap_set_mode and soap_clr_mode.

See also

::soap_new, ::soap_new2, ::soap_copy, soap_destroy, soap_end, soap_free. This function allocates and initializes a new context with the specified input and output soap_mode flags. The separation of input and output mode flags is only useful for the SOAP_XML_TREE flag that affects both input and output behaviors.

Note

There is no need to call soap_init to initialize the context allocated with ::soap_new2.

See also

::soap_new, ::soap_new1, ::soap_copy, soap_destroy, soap_end, soap_free. This function initializes a context.

Examples:

#include "soapH.h"
 
struct soap soap;
soap_init(&soap);
... // send and receive messages etc.
soap_destroy(&soap); // delete managed C++ objects
soap_end(s&oap);     // delete managed memory
soap_done(&soap);    // finalize the context

The context can be re-initialized for reuse after soap_done by calling soap_init.

Note

Initialization should be done at most once before calling soap_done. To change the input/output mode flags, use soap_set_mode and soap_clr_mode.

See also

soap_init1, ::soap_new, ::soap_copy, soap_destroy, soap_end, soap_done.

Parameters

soap	soap context to initialize

soap_init1()

*Initialize a stack allocated ::soap context with input and output ::soap_mode flags void soap_init1	(	struct soap *	soap,
		soap_mode	input_and_output_mode )

This function initializes a context with the specified input and output soap_mode flags.

Examples:

#include "soapH.h"
 
struct soap soap;
soap_init1(&soap, SOAP_XML_INDENT);
... // send and receive messages etc.
soap_destroy(&soap); // delete managed C++ objects
soap_end(s&oap);     // delete managed memory
soap_done(&soap);    // finalize the context

The context can be re-initialized for reuse after soap_done by calling soap_init.

Note

Initialization should be done at most once before calling soap_done. To change the input/output mode flags, use soap_set_mode and soap_clr_mode.

See also

soap_init, ::soap_new, ::soap_copy, soap_destroy, soap_end, soap_done.

Parameters

soap	soap context to initialize
input_and_output_mode	input and output soap_mode flags

soap_init2()

*Initialize a stack allocated ::soap context with input and output ::soap_mode flags void soap_init2	(	struct soap *	soap,
		soap_mode	input_mode,
		soap_mode	output_mode )

This function initializes a context with the specified input and output soap_mode flags.

Note

Initialization should be done at most once before calling soap_done. To change the input/output mode flags, use soap_set_mode and soap_clr_mode.

See also

soap_init, ::soap_new, ::soap_copy, soap_destroy, soap_end, soap_done.

Parameters

soap	soap context to initialize
input_mode	input soap_mode flags
output_mode	output soap_mode flags

soap_malloc()

*Allocate a block of heap memory managed by the specified ::soap context void * soap_malloc	(	struct soap *	soap,
		size_t	len )

This function allocates a block of memory from the heap managed by the specified soap context. All such blocks allocated are deleted with a single call to soap_end. Returns a pointer to the allocated block of memory or NULL when out of memory without setting soap::error.

Note

The soapcpp2 tool generates soap_new_T functions for all serialiable types T. The soap_new_T functions allocate and default initializes the type T or an array of items of type T. Recommended is to use these more powerful soap_new_T functions instead of soap_malloc. For example:

#include "soapH.h"
 
struct soap *soap = soap_new();
struct ns__someElement *data = soap_new_ns__someElement(soap);       // allocate managed object
struct ns__someElement *array = soap_new_ns__someElement(soap, 100); // allocate array of 100 managed objects
... // send and receive messages etc.
soap_destroy(soap); // deletes data, array, and other managed C++ objects
soap_end(soap);     // delete managed memory
soap_free(soap);    // free the context

The soapcpp2 tool also generates soap_default_T functions to default initialize the type T. For example:

#include "soapH.h"
 
struct soap *soap = soap_new();
struct ns__someElement data;
soap_default_ns__someElement(soap, &data); // default initializes all public members
...

but objects of classes should use their soap_default method instead of the soap_default_T function.

Example:

#include "soapH.h"
 
struct soap *soap = soap_new();
char *s = (char*)soap_malloc(soap, 80); // allocate 80 bytes of memory managed by the context
strcpy(s, "Hello");                     // copy a string into it
... // send and receive messages etc.
soap_destroy(soap); // delete managed C++ objects
soap_end(soap);     // delete managed memory
soap_free(soap);    // free the context

See also

soap_strdup, soap_wstrdup, soap_unlink, soap_delegate_deletion, soap_destroy, soap_end, and the C and C++ XML data bindings documentation.

Parameters

soap	soap context
len	length of the block to allocate in number of bytes

soap_set_imode()

*Set input ::soap_mode flags of the given ::soap context void soap_set_imode	(	struct soap *	soap,
		soap_mode	input_mode )

Parameters

soap	soap context
input_mode	input soap_mode flags

soap_set_mode()

*Set input and output ::soap_mode flags of the given ::soap context void soap_set_mode	(	struct soap *	soap,
		soap_mode	input_and_output_mode )

Parameters

soap	soap context
input_and_output_mode	input and output soap_mode flags

soap_set_omode()

*Set output ::soap_mode flags of the given ::soap context void soap_set_omode	(	struct soap *	soap,
		soap_mode	output_mode )

Parameters

soap	soap context
output_mode	output soap_mode flags

soap_strdup()

*Copy a string to managed memory char * soap_strdup	(	struct soap *	soap,
		const char *	string )

This function copies the specified wide string to memory managed by the specified context. Returns a copy of the string or NULL when the specified string is NULL or when the function failed to allocate memory.

Example:

#include "soapH.h"
 
struct soap *soap = soap_new();
// allocate and assign a string in memory managed by the context
char *s = soap_strdup(soap, "Hello");
... // send and receive messages etc.
soap_destroy(soap); // delete managed C++ objects
soap_end(soap);     // delete managed memory
soap_free(soap);    // free the context

See also

soap_malloc, soap_wstrdup, soap_unlink, soap_delegate_deletion, soap_destroy, soap_end.

Parameters

soap	soap context
string	string to copy to managed memory

soap_unlink()

*Unlink a block of heap memory managed by the specified ::soap to release the memory explicitly later int soap_unlink	(	struct soap *	soap,
		const void *	ptr )

This function removes a managed block of memory from the managing soap context. This memory is not released but rather should be released explicitly later by the application logic using free or delete. Returns #SOAP_OK when successful or #SOAP_ERR when the block is not managed by the specified context.

Parameters

soap	soap context
ptr	pointer to the block of managed heap memory to unlink

soap_wstrdup()

*Copy a wide string to managed memory wchar_t * soap_wstrdup	(	struct soap *	soap,
		const wchar_t *	string )

This function copies the specified wide string to managed memory. Returns a copy of the wide string or NULL when the specified wide string is NULL or when the function failed to allocate memory.

Example:

#include "soapH.h"
 
struct soap *soap = soap_new();
// allocate and assign a wide string in memory managed by the context
wchar_t *s = soap_wstrdup(soap, L"Hello");
... // send and receive messages etc.
soap_destroy(soap); // delete managed C++ objects
soap_end(soap);     // delete managed memory
soap_free(soap);    // free the context

See also

soap_malloc, soap_strdup, soap_unlink, soap_delegate_deletion, soap_destroy, soap_end.

Parameters

soap	soap context
string	wide string to copy to managed memory or NULL

version()

*Set SOAP version	(	0	= no SOAP,
		1	= SOAP 1.1,
		2	= SOAP 1.2 )

This function sets (or overrides) the SOAP version to use when sending a message. This function can be used prior to a client-side call to select the SOAP version to use for the request message (assuming the generated code does not fix the version already) or in a service operation to select the SOAP version of the response message. The response message of a service operation normally uses the same SOAP version of the SOAP request message received.

Variable Documentation

_QName

* A built in string type containing normalized QName contents typedef char* _QName

_XML

* A built in string type containing literal XML content in UTF format typedef char* _XML

allocated

* Finalize the given ::soap i e when the ::soap context is stack allocated

context

*Unlink a block of heap memory managed by the specified::soap context

soap_copy_context

*Allocate and initialize a new ::soap context as a copy of the given ::soap context struct soap *soap_copy *(struct soap *soap) *@returns pointer to allocated and initialized ` Copy a given ::soap context to an uninitialized destination ::soap context voi soap_copy_context) (struct soap *soap_destination, struct soap *soap_source)	(	struct soap *	soap_destination,
		struct soap *	soap_source )

This function allocates a new context and copies the state of the specified source context, except heap-allocated data managed by the specified source context, such as deserialized data. To delegate and move managed data from one context to another, use soap_delegate_deletion. Data is deleted with soap_destroy and soap_end in that order, then soap_free to delete the allocated context. After the copy the contexts do not share any data and can therefore be safely used by separate threads without requiring synchronization or mutex locking.

Note

C++ proxy and service classes generated by soapcpp2 -j option -j or option -i have an internal soap context that is either a base class (option -i) or a member variable pointing to a soap context (option -j). For convenience, use the copy member function instead of ::soap_copy and delete the copied instance with delete. For example:

#include "soapexampleService.h" // generated by soapcpp2 option -j
 
int main()
{
  exampleService service(SOAP_XML_INDENT);
  service.soap->bind_flags = SO_REUSEADDR; // immediate port reuse
  service.soap->accept_timeout = 3600;     // let soap_accept time out after 1 hour
  ... // further initialize service.soap
  if (soap_valid_socket(service.bind(NULL, PORTNUM, BACKLOG)))
  {
    while (1)
    {
      if (soap_valid_socket(service.accept()))
      {
        THREAD_TYPE tid;
        exampleService *tservice = service.copy();
        if (!tservice)
          soap_closesock(service.soap);
        else
          while (THREAD_CREATE(&tid, (void*(*)(void*))&process_request, (void*)tservice))
            sleep(1); // failed, try again
      }
      else if (service.soap->errnum) // accept failed, try again after 1 second
      {
        service.soap_print_fault(stderr);
        sleep(1);
      }
      else // accept timed out, quit looping
      {
        break;
      }
      service.destroy();
    }
  }
}
void *process_request(exampleService *service)
{
  THREAD_DETACH(THREAD_ID);
  service.serve();
  service.destroy();
  delete service;
  return NULL;
}

Example:

#include "soapH.h"
#include "plugin/threads.h"
 
int main()
{
  struct soap *soap = soap_new1(SOAP_XML_INDENT);
  soap->bind_flags = SO_REUSEADDR;            // immediate port reuse
  soap->accept_timeout = 3600;                // exit loop when no request arrives in one hour
  soap->send_timeout = soap_recv_timeout = 5; // 5 seconds max socket stall time (unlimited by default)
  soap->transfer_timeout = 30;                // 30 seconds max message transfer time (unlimited by default)
  soap->recv_maxlength = 1048576;             // limit messages received to 1MB (2GB by default)
  if (soap_valid_socket(soap_bind(soap, NULL, PORTNUM, BACKLOG)))
  {
    while (1)
    {
      if (soap_valid_socket(soap_accept(soap)))
      {
        THREAD_TYPE tid;
        struct soap *tsoap = soap_copy(soap);
        if (!tsoap)
          soap_force_closesock(soap);
        else
          while (THREAD_CREATE(&tid, (void*(*)(void*))&process_request, (void*)tsoap))
            sleep(1); // failed, try again
      }
      else // accept failed, try again after 1 second
      {
        soap_print_fault(soap, stderr);
        sleep(1);
      }
      else // accept timed out, quit looping
      {
        break;
      }
      soap_destroy(soap);
      soap_end(soap);
    }
  }
  soap_free(soap);
}
void *process_request(struct soap *soap)
{
  THREAD_DETACH(THREAD_ID);
  soap_serve(soap);
  soap_destroy(soap);
  soap_end(soap);
  soap_free(soap);
  return NULL;
}

See also

soap_copy_context, soap_copy_stream, soap_free_stream, soap_delegate_deletion, soap_destroy, soap_end, soap_free. This function copies the state of the specified context to another uninitialized context (i.e. overriding it). If the destination context is initialized or active then call soap_done first to clean it up before overriding it. The entire state is copied except for the heap-allocated data managed by the specified context. After the copy the contexts do not share any data and can therefore be used by separate threads without requiring synchronization or mutex locking.

Example:

#include "soapH.h"
 
struct soap *soap = soap_new();
... // send and receive messages etc.
struct soap temp;
soap_copy_context(&temp, soap); 
...

See also

::soap_copy, soap_copy_stream, soap_free_stream, soap_delegate_deletion, soap_destroy, soap_end, soap_free.

Parameters

soap_destination	destination soap context to initialize
soap_source	source soap context to copy

version

*Set SOAP short version

< soap contexr

< SOAP version (0 = REST (no SOAP), 1 = SOAP 1.1, 2 = SOAP 1.2)