Data Structures

struct garbage
Garbage collection data structure. More...
struct rpc_ctx
The context of the xhttp_rpc request being processed. More...
struct rpc_struct
The structure represents a XML-RPC document structure. More...
struct xmlrpc_reply
Representation of the XML-RPC reply being constructed. More...

Files

file http.c
XML-RPC requests are carried in the body of HTTP requests, but HTTP requests does not contain some mandatory SIP headers and thus cannot be processed by SER directly.
file xmlrpc.c
This is the main file of XMLRPC SER module which contains all the functions related to XML-RPC processing, as well as the module interface.

Defines

#define FAULT_BODY
The text of XML document indicating error that goes between reason code and reason phrase.
#define FAULT_PREFIX
The beginning of XML document indicating an error.
#define FAULT_SUFFIX
The end of XML document that indicates an error.
#define SUCCESS_PREFIX
The beginning of XML-RPC reply sent to the client.
#define SUCCESS_SUFFIX
The closing part of XML-RPC reply document sent to the client.

Typedefs

typedef struct rpc_ctx rpc_ctx_t
The context of the XML-RPC request being processed.

Functions

static int add_garbage (int type, void *ptr, struct xmlrpc_reply *reply)
Add a memory registion to the list of memory blocks that need to be re-claimed later.
static int add_xmlrpc_reply (struct xmlrpc_reply *reply, str *text)
Add arbitrary text to the XML-RPC reply being constructed, no escaping done.
static int add_xmlrpc_reply_esc (struct xmlrpc_reply *reply, str *text)
Adds arbitrary text to the XML-RPC reply being constructed, special characters < and & will be escaped.
static int add_xmlrpc_reply_offset (struct xmlrpc_reply *reply, unsigned int offset, str *text)
Adds arbitrary text to the XML-RPC reply being constructed, the text will be inserted at a specified offset within the XML-RPC reply.
static int build_fault_reply (struct xmlrpc_reply *reply)
Create XML-RPC reply that indicates an error to the caller.
static void clean_xmlrpc_reply (struct xmlrpc_reply *reply)
Free all memory used by the XML-RPC reply structure.
static void clear_xmlrpc_reply (struct xmlrpc_reply *reply)
Clear the XML-RPC reply code and sets it back to a success reply.
static void collect_garbage (void)
Re-claims all memory allocated in the process of building XML-RPC reply.
int create_via (sip_msg_t *msg, char *s1, char *s2)
Create a fake Via header field.
static int dispatch_rpc (sip_msg_t *msg, char *s1, char *s2)
The main processing function of xmlrpc module.
static int em_receive_request (sip_msg_t *orig_msg, char *new_buf, unsigned int new_len)
Emulate receive_msg for an XML-RPC request .
static int find_member (xmlNodePtr *value, xmlDocPtr doc, xmlNodePtr structure, struct xmlrpc_reply *reply, char *member_name)
Find a structure member by name.
static int get_double (double *val, struct xmlrpc_reply *reply, xmlDocPtr doc, xmlNodePtr value, int flags)
Converts an XML-RPC encoded parameter into double if possible.
static int get_int (int *val, struct xmlrpc_reply *reply, xmlDocPtr doc, xmlNodePtr value, int flags)
Converts an XML-RPC encoded parameter into integer if possible.
static unsigned int get_reply_len (struct xmlrpc_reply *reply)
Returns the current length of the XML-RPC reply body.
static int get_rpc_document (str *doc, sip_msg_t *msg)
Extract XML-RPC query from a SIP/HTTP message.
static int get_string (char **val, struct xmlrpc_reply *reply, xmlDocPtr doc, xmlNodePtr value, int flags)
Convert a parameter encoded in XML-RPC to a zero terminated string.
static char * http_xmlrpc2sip (sip_msg_t *msg, int *new_msg_len)
Creates a SIP message (in "buffer" form) from a HTTP XML-RPC request).
static int init_xmlrpc_reply (struct xmlrpc_reply *reply)
Initialize XML-RPC reply data structure.
static int insert_fake_via (sip_msg_t *msg, char *via, int via_len)
Insert fake Via header field into SIP message.
int mod_register (char *path, int *dlflags, void *p1, void *p2)
advertise that sip workers handle rpc commands
static struct rpc_struct * new_rpcstruct (xmlDocPtr doc, xmlNodePtr structure, struct xmlrpc_reply *reply)
Create and initialize a new rpc_structure data structure.
static int open_doc (rpc_ctx_t *ctx, sip_msg_t *msg)
Starts parsing XML-RPC document, get the name of the method to be called and position the cursor at the first parameter in the document.
static int print_value (struct xmlrpc_reply *res, struct xmlrpc_reply *err_reply, char fmt, va_list *ap)
Converts the variables provided in parameter ap according to formatting string provided in parameter fmt into parameters in XML-RPC format.
static int process_xmlrpc (sip_msg_t *msg)
The main handler that will be called when SER core receives a non-SIP request (i.e.
static int rpc_add (rpc_ctx_t *ctx, char *fmt,...)
Implementation of rpc_add function required by the management API in SER.
static rpc_capabilities_t rpc_capabilities (rpc_ctx_t *ctx)
Returns the RPC capabilities supported by the xmlrpc driver.
static void rpc_delayed_ctx_close (struct rpc_delayed_ctx *dctx)
Closes a "delayed reply" context and sends the reply.
static struct rpc_delayed_ctx * rpc_delayed_ctx_new (rpc_ctx_t *ctx)
Returns a new "delayed reply" context.
static void rpc_fault (rpc_ctx_t *ctx, int code, char *fmt,...)
Implementation of rpc_fault function required by the management API in SER.
static int rpc_printf (rpc_ctx_t *ctx, char *fmt,...)
Implementation of rpc_printf function required by the management API in SER.
static int rpc_scan (rpc_ctx_t *ctx, char *fmt,...)
Implementation of rpc->scan function required by the management API in SER.
static int rpc_send (rpc_ctx_t *ctx)
Implementation of rpc_send function required by the management API in SER.
static int rpc_struct_add (struct rpc_struct *s, char *fmt,...)
Adds a new member to structure.
static int rpc_struct_printf (struct rpc_struct *s, char *member_name, char *fmt,...)
Create a new member from formatting string and add it to a structure.
static int select_method (str *res, struct select *s, sip_msg_t *msg)
Implementation of @xmlrpc.method select that can be used in SER scripts to retrieve the method string from XML-RPC documents.
static int send_reply (sip_msg_t *msg, str *body)
Send a reply to the client with given body.
static enum xmlrpc_val_type xml_get_type (xmlNodePtr value)
Returns the XML-RPC value type.
static time_t xmlrpc2time (const char *str)
Convert time in XML-RPC format to time_t.
static int xmlrpc_reply (sip_msg_t *msg, char *p1, char *p2)
This function can be called from SER scripts to generate an XML-RPC reply.

Variables

static rpc_ctx_t ctx
The context of the XML-RPC request being processed.
static rpc_t func_param
Pointers to the functions that implement the RPC interface of xmlrpc SER module.
sl_api_t slb
Reference to the sl (stateless replies) module of SER The sl module of SER is needed so that the xmlrpc SER module can send replies back to clients.
static struct garbage * waste_bin
Garbage collection data structure.
static char * xmlrpc_route = 0
Enable/disable additional introspection methods.

Detailed Description

Overview of Operation

This module provides XML-RPC based interface to management functions in SER. You can send XML-RPC requests to SER when the module is loaded and configured and it will send XML-RPC replies back. XML-RPC requests are encoded as XML documents in the body of HTTP requests. Due to similarity between HTTP and SIP SER can easily parse HTTP requests and extract the XML document from their body.

When you load this module into SER, it will register a callback function that will be called whenever the SER core receives a request with method it does not understand. The main callback function is process_xmlrpc(). The function first verifies if the protocol identifier inside the request is HTTP and whether the request method is either GET or POST. If both conditions are met then it will signal to the SER core that it is processing the request, otherwise it will reject the request and the SER core will pass the requests to other callbacks if they exist.

As the next step the request will be converted from HTTP request to a SIP request to ensure that it can be processed by SER and its modules. The conversion will modify the URI in the Request-URI of the request, the new URI will be a SIP URI. In addition to that it will add a fake Via header field and copy all remaining header fields from the original HTTP request. The conversion is implemented in http_xmlrpc2sip() function.

After the conversion the module will execute the route statement whose number is configured in "route" module parameter. That route stament may perform additional security checks and when it ensures that the client is authorized to execute management functions then it will call dispatch_rpc() module function provided by this module.

dispatch_rpc() function extracts the XML-RPC document from the body of the request to determine the name of the method to be called and then it searches through the list of all management functions to find a function with matching name. If such a function is found then dispatch_rpc() will pass control to the function to handle the request. dispatch_rpc() will send a reply back to the client when the management function terminates, if the function did not do that explicitly.

Memory Management

The module provides implementation for all the functions required by the management interface in SER, such as rpc->printf, rpc->add, rpc->struct_add and so on. Whenever the management function calls one of the functions then corresponding function in this module will be called to handle the request.

The implementation functions build the reply, that will be sent to the client, as they execute and they need to allocate memory to do that. That memory must be freed again after the reply has been sent to the client. To remember all the memory regions allocated during the execution of the management function all functions within this module record all allocated memory in the global variable called waste_bin. dispatch_rpc() functions executes function collect_garbage() after the reply has been sent to the client to free all memory that was allocated from the management function. that was executed.

Request Context

Before the module calls a management function it prepares a structure called context. The context is defined in structure rpc_ctx and it is passed as one of parameter to the management function being called. The context contains all the data that is needed during the execution of the management function, such as the pointer to the request being processed, a pointer to the reply being built, and so on.

Another parameter to the management function being called is a structure that contains pointers to all implementation functions. This structure is of type rpc_t, this module keeps one global variable of that type called func_param and a pointer to that variable is passed to all management functions. The global variable is initialized in mod_init().

Define Documentation

#define FAULT_PREFIX

Value:

"<?xml version=\"1.0\"?>" LF \
"<methodResponse>" LF        \
"<fault>" LF                 \
"<value>" LF                 \
"<struct>" LF                \
"<member>" LF                \
"<name>faultCode</name>" LF  \
"<value><int>"

This is the beginning of the XML document that will be sent back to the client when the server encountered an error. It will be immediately followed by a reason phrase.

Definition at line 183 of file xmlrpc.c.

#define FAULT_SUFFIX

Value:

"</string></value>" LF \
"</member>" LF         \
"</struct>" LF         \
"</value>" LF          \
"</fault>" LF          \
"</methodResponse>"

This is the closing part of the XML-RPC document that indicates an error on the server.

Definition at line 210 of file xmlrpc.c.

Typedef Documentation

typedef struct rpc_ctx rpc_ctx_t

This is the data structure that contains all data related to the XML-RPC request being processed, such as the reply code and reason, data to be sent to the client in the reply, and so on.

There is always one context per XML-RPC request.

Function Documentation

static int add_garbage	(	int	type,
		void *	ptr,
		struct xmlrpc_reply *	reply
	)			`[static]`

Parameters:

	type	The type of the memory block (ordinary text or structure).
	ptr	A pointer to the memory block.
	reply	The XML-RPC the memory block is associated with.

Returns:: 0 on success, a negative number on error.

See also:: collect_garbage()

Definition at line 713 of file xmlrpc.c.

References garbage::next, garbage::ptr, garbage::type, and waste_bin.

Referenced by get_string(), and new_rpcstruct().

Here is the caller graph for this function:

static int add_xmlrpc_reply	(	struct xmlrpc_reply *	reply,
		str *	text
	)			`[static]`

This is a more efficient version of add_xmlrpc_reply_esc(), the function appends arbitrary text to the end of the XML-RPC reply being constructed, but the text must not contain any characters that need to be escaped in XML, such as < and & (or the characters must be escaped already).

Parameters:

	reply	Pointer to the structure representing the XML-RPC reply being constructed.
	text	The text to be appended to the XML-RPC reply.

Returns:: -1 on error, 0 if the text was added successfuly.

See also:: add_xmlrpc_reply_esc()

Definition at line 540 of file xmlrpc.c.

References xmlrpc_reply::body, xmlrpc_reply::buf, _str::len, and _str::s.

Referenced by build_fault_reply(), dispatch_rpc(), new_rpcstruct(), print_value(), rpc_add(), rpc_printf(), rpc_send(), rpc_struct_add(), rpc_struct_printf(), and xmlrpc_reply().

Here is the caller graph for this function:

static int add_xmlrpc_reply_esc	(	struct xmlrpc_reply *	reply,
		str *	text
	)			`[static]`

This function adds arbitrary text to the body of the XML-RPC reply being constructed. Note well that the function does not check whether the XML document being constructed is well-formed or valid. Use with care.

Parameters:

	reply	Pointer to the structure representing the XML-RPC reply being constructed.
	text	The text to be appended to the XML-RPC reply.

Returns:: -1 on error, 0 if the text was added successfuly.

See also:: add_xmlrpc_reply()

Definition at line 474 of file xmlrpc.c.

References xmlrpc_reply::body, xmlrpc_reply::buf, _str::len, and _str::s.

Referenced by build_fault_reply(), print_value(), rpc_printf(), rpc_struct_add(), rpc_struct_printf(), and xmlrpc_reply().

Here is the caller graph for this function:

static int add_xmlrpc_reply_offset	(	struct xmlrpc_reply *	reply,
		unsigned int	offset,
		str *	text
	)			`[static]`

This function inserts arbitrary text in the XML-RPC reply that is being constructed, unlike add_xmlrp_reply(), this function will not append the text at the end of the reply, but it will insert the text in the middle of the reply at the position provided to the function in "offset" parameter. The function does not escape special characters and thus the text must not contain such characters (or the must be escaped already).

Parameters:

	reply	The XML-RPC reply structure representing the reply being constructed.
	offset	The position of the first character where the text should be inserted.
	text	The text to be inserted.

Returns:: 0 of the text was inserted successfuly, a negative number on error.

Definition at line 578 of file xmlrpc.c.

References xmlrpc_reply::body, xmlrpc_reply::buf, _str::len, and _str::s.

static int build_fault_reply ( struct xmlrpc_reply * reply ) [static]

This function is used to build the XML-RPC reply body that indicates that an error ocurred on the server. It is called when a management function in SER reports an error. The reply will contain the reason code and reason phrase text provided by the management function that indicated the error.

Definition at line 687 of file xmlrpc.c.

References add_xmlrpc_reply(), add_xmlrpc_reply_esc(), xmlrpc_reply::code, int2str(), _str::len, xmlrpc_reply::reason, and _str::s.

Referenced by rpc_send(), and xmlrpc_reply().

Here is the call graph for this function:

Here is the caller graph for this function:

static void clean_xmlrpc_reply ( struct xmlrpc_reply * reply ) [static]

Definition at line 675 of file xmlrpc.c.

References xmlrpc_reply::buf, and _str::s.

Referenced by xmlrpc_reply().

Here is the caller graph for this function:

static void clear_xmlrpc_reply ( struct xmlrpc_reply * reply ) [static]

Parameters:

reply

XML-RPC reply structure to be cleared.

Definition at line 653 of file xmlrpc.c.

References xmlrpc_reply::code, and xmlrpc_reply::reason.

Referenced by rpc_scan().

Here is the caller graph for this function:

int create_via	(	sip_msg_t *	msg,
		char *	s1,
		char *	s2
	)

This function creates a fake Via header field and inserts the fake header field into the header of the HTTP request. The fake Via header field contains the source IP address and port of the TCP/IP connection.

Definition at line 164 of file http.c.

References insert_fake_via(), int2str(), _str::len, sip_msg::rcv, and _str::s.

Here is the call graph for this function:

static int dispatch_rpc	(	sip_msg_t *	msg,
		char *	s1,
		char *	s2
	)			`[static]`

This is the main function of this module. It extracts the name of the method to be called from XML-RPC request and then it searches through the list of all available management function, when a function with matching name is found then it will be executed.

Definition at line 2308 of file xmlrpc.c.

References add_xmlrpc_reply(), collect_garbage(), rpc_ctx::flags, func_param, rpc_ctx::method, rpc_ctx::reply, rpc_ctx::reply_sent, rpc_fault(), and rpc_send().

Here is the call graph for this function:

static int get_double	(	double *	val,
		struct xmlrpc_reply *	reply,
		xmlDocPtr	doc,
		xmlNodePtr	value,
		int	flags
	)			`[static]`

This function receives a pointer to a parameter encoded in XML-RPC format and tries to convert the value of the parameter into double. Only <i4>, <int>, <double> XML-RPC parameters can be converted to double, attempts to conver other types will fail.

Parameters:

	val	A pointer to an integer variable where the result will be stored.
	reply	A pointer to XML-RPC reply being constructed (used to indicate conversion errors).
	doc	A pointer to the XML-RPC request document.
	value	A pointer to the element containing the parameter to be converted within the document.
	flags	: GET_X_AUTOCONV - try autoconverting GET_X_NOREPLY - do not reply

Returns:: <0 on error, 0 on success

Definition at line 1269 of file xmlrpc.c.

References xml_get_type(), and xmlrpc2time().

Referenced by rpc_scan().

Here is the call graph for this function:

Here is the caller graph for this function:

static int get_int	(	int *	val,
		struct xmlrpc_reply *	reply,
		xmlDocPtr	doc,
		xmlNodePtr	value,
		int	flags
	)			`[static]`

This function receives a pointer to a parameter encoded in XML-RPC format and tries to convert the value of the parameter into integer. Only <i4>, <int>, <boolean>, <dateTime.iso8601> XML-RPC parameters can be converted to integer, attempts to conver other types will fail.

Parameters:

	val	A pointer to an integer variable where the result will be stored.
	reply	A pointer to XML-RPC reply being constructed (used to indicate conversion errors).
	doc	A pointer to the XML-RPC request document.
	value	A pointer to the element containing the parameter to be converted within the document.
	flags	: GET_X_AUTOCONV - try autoconverting GET_X_NOREPLY - do not reply

Returns:: <0 on error, 0 on success

Definition at line 1178 of file xmlrpc.c.

References xml_get_type(), and xmlrpc2time().

Referenced by rpc_scan().

Here is the call graph for this function:

Here is the caller graph for this function:

static unsigned int get_reply_len ( struct xmlrpc_reply * reply ) [static]

Parameters:

reply

The XML-RPC reply being constructed

Returns:: Number of bytes of the XML-RPC reply body.

Definition at line 607 of file xmlrpc.c.

References xmlrpc_reply::body, and _str::len.

Referenced by rpc_add(), and rpc_struct_add().

Here is the caller graph for this function:

static int get_rpc_document	(	str *	doc,
		sip_msg_t *	msg
	)			`[static]`

Parameters:

	doc	A pointer to string descriptor that will be filled with the pointer to the beginning of the XML-RPC document and length of the document.
	msg	A structure representing the SIP/HTTP message carrying the XML-RPC document in body.

Definition at line 776 of file xmlrpc.c.

References get_body(), _str::len, and _str::s.

Referenced by open_doc(), and select_method().

Here is the call graph for this function:

Here is the caller graph for this function:

static int get_string	(	char **	val,
		struct xmlrpc_reply *	reply,
		xmlDocPtr	doc,
		xmlNodePtr	value,
		int	flags
	)			`[static]`

Parameters:

	val	A pointer to a char* variable where the result will be stored (the result is dynamically allocated, but it's garbage collected, so it doesn't have to be freed)
	reply	A pointer to XML-RPC reply being constructed (used to indicate conversion errors).
	doc	A pointer to the XML-RPC request document.
	value	A pointer to the element containing the parameter to be converted within the document.
	flags	GET_X_AUTOCONV - try autoconverting GET_X_LFLF2CRLF - replace double '\n' with `\r\n' GET_X_NOREPLY - do not reply

Returns:: <0 on error, 0 on success

Definition at line 1353 of file xmlrpc.c.

References add_garbage(), sint2str(), and xml_get_type().

Referenced by rpc_scan().

Here is the call graph for this function:

Here is the caller graph for this function:

static char* http_xmlrpc2sip	(	sip_msg_t *	msg,
		int *	new_msg_len
	)			`[static]`

NOTE: the result must be pkg_free()'ed when not needed anymore.

Returns:: 0 on error, buffer allocated using pkg_malloc on success.

Definition at line 2091 of file xmlrpc.c.

References sip_msg::first_line, int2str(), sip_msg::len, _str::len, sip_msg::rcv, _str::s, and SIP_MSG_START.

Referenced by process_xmlrpc().

Here is the call graph for this function:

Here is the caller graph for this function:

static int init_xmlrpc_reply ( struct xmlrpc_reply * reply ) [static]

This function initializes the data structure that contains all data related to the XML-RPC reply being created. The function must be called before any other function that adds data to the reply.

Parameters:

reply

XML-RPC reply structure to be initialized.

Returns:: 0 on success, a negative number on error.

Definition at line 633 of file xmlrpc.c.

References xmlrpc_reply::body, xmlrpc_reply::buf, xmlrpc_reply::code, _str::len, xmlrpc_reply::reason, and _str::s.

Referenced by new_rpcstruct(), and xmlrpc_reply().

Here is the caller graph for this function:

static int insert_fake_via	(	sip_msg_t *	msg,
		char *	via,
		int	via_len
	)			`[static]`

This function takes a SIP message and a Via header field as text and inserts the Via header field into the SIP message, modifying the data structures within the SIP message to make it look that the Via header field was received with the message.

Parameters:

	msg	a pointer to the currently processed SIP message
	via	the Via header field text to be inserted
	via_len	size of the Via header field being inserted

Returns:: 0 on succes, a negative number on error.

Definition at line 66 of file http.c.

References hdr_field::body, sip_msg::headers, sip_msg::last_header, _str::len, hdr_field::name, hdr_field::next, parse_via(), hdr_field::parsed, _str::s, hdr_field::type, and sip_msg::via1.

Referenced by create_via().

Here is the call graph for this function:

Here is the caller graph for this function:

static struct rpc_struct* new_rpcstruct	(	xmlDocPtr	doc,
		xmlNodePtr	structure,
		struct xmlrpc_reply *	reply
	)			`[static, read]`

This function allocates and initializes memory for a new rpc_struct structure. If the caller provided non-NULL pointers in doc and structure parameters then the structure is coming from an XML-RPC request. If either of the pointers is NULL then we are creating a structure that will be attached to a XML-RPC reply sent to the client. The memory allocated in this function will be added to the garbage collection list.

Parameters:

	doc	A pointer to the XML-RPC request document or NULL if we create a structure that will be put in a reply.
	structure	A pointer to opening tag of the structure in the XML-RPC request document or NULL if we create a structure that will be put in a XML-RPC reply.
	reply	A pointer to xml_reply structure, NULL if it is a structure coming from a XML-RPC request.

Definition at line 931 of file xmlrpc.c.

References add_garbage(), add_xmlrpc_reply(), xmlrpc_reply::buf, rpc_struct::doc, init_xmlrpc_reply(), rpc_struct::n, rpc_struct::reply, _str::s, rpc_struct::struct_in, and rpc_struct::struct_out.

Referenced by rpc_add(), rpc_scan(), and rpc_struct_add().

Here is the call graph for this function:

Here is the caller graph for this function:

static int print_value	(	struct xmlrpc_reply *	res,
		struct xmlrpc_reply *	err_reply,
		char	fmt,
		va_list *	ap
	)			`[static]`

This function takes the parameters provided in ap parameter and creates XML-RPC formatted parameters that will be put in the document in res parameter. The format of input parameters is described in formatting string fmt which follows the syntax of the management API in SER. In the case of an error the function will generate an error reply in err_reply parameter instead.

Parameters:

	res	A pointer to the XML-RPC result structure where the parameters will be written.
	err_reply	An error reply document will be generated here if the function encounters a problem while processing input parameters.
	fmt	Formatting string of the management API in SER.
	ap	A pointer to the array of input parameters.

Definition at line 983 of file xmlrpc.c.

References add_xmlrpc_reply(), add_xmlrpc_reply_esc(), int2str(), _str::len, prefix, and _str::s.

Referenced by rpc_add(), and rpc_struct_add().

Here is the call graph for this function:

Here is the caller graph for this function:

static int process_xmlrpc ( sip_msg_t * msg ) [static]

HTTP request carrying XML-RPC document in the body).

Definition at line 2215 of file xmlrpc.c.

References sip_msg::buf, em_receive_request(), sip_msg::first_line, http_xmlrpc2sip(), sip_msg::len, and sip_msg::via1.

Here is the call graph for this function:

static int rpc_add	(	rpc_ctx_t *	ctx,
		char *	fmt,
			...
	)			`[static]`

This function will be called when a management function in SER calls rpc->add to add a parameter to the XML-RPC reply being generated.

Definition at line 1065 of file xmlrpc.c.

References add_xmlrpc_reply(), rpc_ctx::flags, get_reply_len(), new_rpcstruct(), rpc_struct::offset, print_value(), rpc_ctx::reply, and rpc_ctx::structs.

Here is the call graph for this function:

static void rpc_delayed_ctx_close ( struct rpc_delayed_ctx * dctx ) [static]

If no reply has been sent the reply will be built and sent automatically. See the notes from rpc_new_delayed_ctx()

Definition at line 1935 of file xmlrpc.c.

References sip_msg::add_rm, sip_msg::body_lumps, clean_hdr_field(), collect_garbage(), del_nonshm_lump(), rpc_ctx::flags, hdr_allocs_parse(), sip_msg::headers, rpc_ctx::msg, rpc_ctx::msg_shm_block_size, hdr_field::next, hdr_field::parsed, sip_msg::reply_lump, rpc_ctx::reply_sent, rpc_send(), and hdr_field::type.

Here is the call graph for this function:

static struct rpc_delayed_ctx* rpc_delayed_ctx_new ( rpc_ctx_t * ctx ) [static, read]

Creates a new delayed reply context in shm and returns it.

Returns:: 0 - not supported, already replied, or no more memory; !=0 pointer to the special delayed ctx. Note1: one should use the returned ctx reply context to build a reply and when finished call rpc_delayed_ctx_close(). Note2: adding pieces to the reply in different processes is not supported.

Definition at line 1889 of file xmlrpc.c.

References rpc_ctx::flags, func_param, sip_msg::len, rpc_ctx::msg, rpc_ctx::msg_shm_block_size, rpc_ctx::reply_sent, and sip_msg_shm_clone().

Here is the call graph for this function:

static void rpc_fault	(	rpc_ctx_t *	ctx,
		int	code,
		char *	fmt,
			...
	)			`[static]`

This function will be called whenever a management function in SER indicates that an error ocurred while it was processing the request. The function takes the reply code and reason phrase as parameters, these will be put in the body of the reply.

Parameters:

	ctx	A pointer to the context structure of the request being processed.
	code	Reason code.
	fmt	Formatting string used to build the reason phrase.

Definition at line 902 of file xmlrpc.c.

References xmlrpc_reply::buf, xhttp_rpc_reply::code, xhttp_rpc_reply::reason, and rpc_ctx::reply.

Referenced by dispatch_rpc().

Here is the caller graph for this function:

static int rpc_printf	(	rpc_ctx_t *	ctx,
		char *	fmt,
			...
	)			`[static]`

This function will be called whenever a management function in SER calls rpc-printf to add a parameter to the XML-RPC reply being constructed.

Definition at line 1574 of file xmlrpc.c.

References add_xmlrpc_reply(), add_xmlrpc_reply_esc(), rpc_ctx::flags, _str::len, rpc_struct::n, rpc_ctx::reply, and _str::s.

Here is the call graph for this function:

static int rpc_scan	(	rpc_ctx_t *	ctx,
		char *	fmt,
			...
	)			`[static]`

This is the function that will be called whenever a management function in SER calls rpc->scan to get the value of parameter from the XML-RPC request. This function will extract the current parameter from the XML-RPC document and attempts to convert it to the type requested by the management function that called it.

Definition at line 1467 of file xmlrpc.c.

References rpc_ctx::act_param, clear_xmlrpc_reply(), rpc_ctx::doc, get_double(), get_int(), get_string(), _str::len, new_rpcstruct(), rpc_ctx::reply, and _str::s.

Here is the call graph for this function:

static int rpc_send ( rpc_ctx_t * ctx ) [static]

This is the function that will be called whenever a management function in SER asks the management interface to send the reply to the client. The function will generate the XML-RPC document, put it in body of a SIP response and send the response to the client. The SIP/HTTP reply sent to the client will be always 200 OK, if an error ocurred on the server then it will be indicated in the XML document in body.

Parameters:

ctx

A pointer to the context structure of the XML-RPC request that generated the reply.

Returns:: 1 if the reply was already sent, 0 on success, a negative number on error

Definition at line 853 of file xmlrpc.c.

References add_xmlrpc_reply(), xmlrpc_reply::body, build_fault_reply(), xmlrpc_reply::code, rpc_ctx::flags, rpc_ctx::msg, rpc_ctx::reply, rpc_ctx::reply_sent, send_reply(), and rpc_ctx::structs.

Referenced by dispatch_rpc(), and rpc_delayed_ctx_close().

Here is the call graph for this function:

Here is the caller graph for this function:

static int send_reply	(	sip_msg_t *	msg,
		str *	body
	)			`[static]`

This function sends a 200 OK reply back to the client, the body of the reply will contain text provided to the function in "body" parameter.

Parameters:

	msg	The request that generated the reply.
	body	The text that will be put in the body of the reply.

Definition at line 796 of file xmlrpc.c.

References add_lump_rpl(), _str::len, and _str::s.

Here is the call graph for this function:

static enum xmlrpc_val_type xml_get_type ( xmlNodePtr value ) [static]

Returns:: value type (>= on success, XML_T_ERR on error/unknown type)

Definition at line 1141 of file xmlrpc.c.

Referenced by get_double(), get_int(), and get_string().

Here is the caller graph for this function:

Variable Documentation

rpc_ctx_t ctx [static]

This is a global variable that records the context of the XML-RPC request being currently processed.

See also:: rpc_ctx

Definition at line 372 of file xmlrpc.c.

sl_api_t slb

The pointer to the stateless reply function This is used to send a 422 reply if asked to with a Min-SE: header value to small.

SL binds.

SL API structure.

Definition at line 394 of file xmlrpc.c.

struct garbage * waste_bin [static]

This is the data structure used by the garbage collector in this module. When the xmlrpc SER module identifies the management function to be called, it calls corresponding function in SER. The function being called adds data to the reply, that will be later sent to the client, as it executes. This module needs to allocate memory for such data and the memory will be re-claimed after the reply was sent out. All the memory allocated this way is recorded in this data structure so that it can be identified and re-claimed later (when the reply is being sent out).

Referenced by add_garbage(), and collect_garbage().

char* xmlrpc_route = 0 [static]

If set to 1 then the functions defined in http://scripts.incutio.com/xmlrpc/introspection.html will be available on the server. If set to 0 then the functions will be disabled.

Definition at line 388 of file xmlrpc.c.

Xmlrpc

Data Structures

Files

Defines

Typedefs

Functions

Variables

Detailed Description

Overview of Operation

Memory Management

Request Context

Define Documentation

Typedef Documentation

Function Documentation

Variable Documentation