Back to index

php5  5.3.10
Classes | Defines | Typedefs | Functions | Variables
xmlrpc-epi-php.c File Reference
#include "php.h"
#include "ext/standard/info.h"
#include "ext/standard/php_string.h"
#include "ext/date/php_date.h"
#include "php_ini.h"
#include "php_xmlrpc.h"
#include "xmlrpc.h"

Go to the source code of this file.

Classes

struct  _xmlrpc_server_data
struct  _php_output_options
struct  _xmlrpc_callback_data

Defines

#define PHP_EXT_VERSION   "0.51"
#define OUTPUT_TYPE_KEY   "output_type"
#define OUTPUT_TYPE_KEY_LEN   (sizeof(OUTPUT_TYPE_KEY) - 1)
#define OUTPUT_TYPE_VALUE_PHP   "php"
#define OUTPUT_TYPE_VALUE_XML   "xml"
#define VERBOSITY_KEY   "verbosity"
#define VERBOSITY_KEY_LEN   (sizeof(VERBOSITY_KEY) - 1)
#define VERBOSITY_VALUE_NO_WHITE_SPACE   "no_white_space"
#define VERBOSITY_VALUE_NEWLINES_ONLY   "newlines_only"
#define VERBOSITY_VALUE_PRETTY   "pretty"
#define ESCAPING_KEY   "escaping"
#define ESCAPING_KEY_LEN   (sizeof(ESCAPING_KEY) - 1)
#define ESCAPING_VALUE_CDATA   "cdata"
#define ESCAPING_VALUE_NON_ASCII   "non-ascii"
#define ESCAPING_VALUE_NON_PRINT   "non-print"
#define ESCAPING_VALUE_MARKUP   "markup"
#define VERSION_KEY   "version"
#define VERSION_KEY_LEN   (sizeof(VERSION_KEY) - 1)
#define VERSION_VALUE_SIMPLE   "simple"
#define VERSION_VALUE_XMLRPC   "xmlrpc"
#define VERSION_VALUE_SOAP11   "soap 1.1"
#define VERSION_VALUE_AUTO   "auto"
#define ENCODING_KEY   "encoding"
#define ENCODING_KEY_LEN   (sizeof(ENCODING_KEY) - 1)
#define ENCODING_DEFAULT   "iso-8859-1"
#define OBJECT_TYPE_ATTR   "xmlrpc_type"
#define OBJECT_VALUE_ATTR   "scalar"
#define OBJECT_VALUE_TS_ATTR   "timestamp"
#define FAULT_CODE   "faultCode"
#define FAULT_CODE_LEN   (sizeof(FAULT_CODE) - 1)
#define FAULT_STRING   "faultString"
#define FAULT_STRING_LEN   (sizeof(FAULT_STRING) - 1)
#define my_zend_hash_get_current_key(ht, my_key, num_index)   zend_hash_get_current_key(ht, my_key, num_index, 0)
#define XMLRPC_TYPE_COUNT   9
#define XMLRPC_VECTOR_TYPE_COUNT   4
#define TYPE_STR_MAP_SIZE   (XMLRPC_TYPE_COUNT + XMLRPC_VECTOR_TYPE_COUNT)

Typedefs

typedef struct _xmlrpc_server_data xmlrpc_server_data
typedef struct _php_output_options php_output_options
typedef struct
_xmlrpc_callback_data 
xmlrpc_callback_data

Functions

XMLRPC_VALUE_TYPE get_zval_xmlrpc_type (zval *value, zval **newvalue)
static void php_xmlrpc_introspection_callback (XMLRPC_SERVER server, void *data)
int sset_zval_xmlrpc_type (zval *value, XMLRPC_VALUE_TYPE type)
zval * decode_request_worker (char *xml_in, int xml_in_len, char *encoding_in, zval *method_name_out)
const char * xmlrpc_type_as_str (XMLRPC_VALUE_TYPE type, XMLRPC_VECTOR_TYPE vtype)
XMLRPC_VALUE_TYPE xmlrpc_str_as_type (const char *str)
XMLRPC_VECTOR_TYPE xmlrpc_str_as_vector_type (const char *str)
int set_zval_xmlrpc_type (zval *value, XMLRPC_VALUE_TYPE type)
static void destroy_server_data (xmlrpc_server_data *server TSRMLS_DC)
static void xmlrpc_server_destructor (zend_rsrc_list_entry *rsrc TSRMLS_DC)
 PHP_MINIT_FUNCTION (xmlrpc)
 PHP_MINFO_FUNCTION (xmlrpc)
static int add_zval (zval *list, const char *id, zval **val)
static void set_output_options (php_output_options *options, zval *output_opts)
static XMLRPC_VECTOR_TYPE determine_vector_type (HashTable *ht)
static XMLRPC_VALUE PHP_to_XMLRPC_worker (const char *key, zval *in_val, int depth TSRMLS_DC)
static XMLRPC_VALUE PHP_to_XMLRPC (zval *root_val TSRMLS_DC)
static zval * XMLRPC_to_PHP (XMLRPC_VALUE el)
 PHP_FUNCTION (xmlrpc_encode_request)
 PHP_FUNCTION (xmlrpc_encode)
 PHP_FUNCTION (xmlrpc_decode_request)
 PHP_FUNCTION (xmlrpc_decode)
 PHP_FUNCTION (xmlrpc_server_create)
 PHP_FUNCTION (xmlrpc_server_destroy)
static XMLRPC_VALUE php_xmlrpc_callback (XMLRPC_SERVER server, XMLRPC_REQUEST xRequest, void *data)
 PHP_FUNCTION (xmlrpc_server_register_method)
 PHP_FUNCTION (xmlrpc_server_register_introspection_callback)
 PHP_FUNCTION (xmlrpc_server_call_method)
 PHP_FUNCTION (xmlrpc_server_add_introspection_data)
 PHP_FUNCTION (xmlrpc_parse_method_descriptions)
static const char ** get_type_str_mapping (void)
 PHP_FUNCTION (xmlrpc_set_type)
 PHP_FUNCTION (xmlrpc_get_type)
 PHP_FUNCTION (xmlrpc_is_fault)

Variables

static int le_xmlrpc_server
const zend_function_entry xmlrpc_functions []
zend_module_entry xmlrpc_module_entry

Class Documentation

struct _xmlrpc_server_data

Definition at line 186 of file xmlrpc-epi-php.c.

Collaboration diagram for _xmlrpc_server_data:
Class Members
zval * introspection_map
zval * method_map
XMLRPC_SERVER server_ptr
struct _php_output_options

Definition at line 194 of file xmlrpc-epi-php.c.

Collaboration diagram for _php_output_options:
Class Members
int b_auto_version
int b_php_out
STRUCT_XMLRPC_REQUEST_OUTPUT_OPTIONS xmlrpc_out
struct _xmlrpc_callback_data

Definition at line 201 of file xmlrpc-epi-php.c.

Collaboration diagram for _xmlrpc_callback_data:
Class Members
zval * caller_params
char php_executed
zval * php_function
zval * return_data
xmlrpc_server_data * server
zval * xmlrpc_method

Define Documentation

#define ENCODING_DEFAULT   "iso-8859-1"

Definition at line 238 of file xmlrpc-epi-php.c.

#define ENCODING_KEY   "encoding"

Definition at line 236 of file xmlrpc-epi-php.c.

#define ENCODING_KEY_LEN   (sizeof(ENCODING_KEY) - 1)

Definition at line 237 of file xmlrpc-epi-php.c.

#define ESCAPING_KEY   "escaping"

Definition at line 222 of file xmlrpc-epi-php.c.

#define ESCAPING_KEY_LEN   (sizeof(ESCAPING_KEY) - 1)

Definition at line 223 of file xmlrpc-epi-php.c.

#define ESCAPING_VALUE_CDATA   "cdata"

Definition at line 224 of file xmlrpc-epi-php.c.

#define ESCAPING_VALUE_MARKUP   "markup"

Definition at line 227 of file xmlrpc-epi-php.c.

#define ESCAPING_VALUE_NON_ASCII   "non-ascii"

Definition at line 225 of file xmlrpc-epi-php.c.

#define ESCAPING_VALUE_NON_PRINT   "non-print"

Definition at line 226 of file xmlrpc-epi-php.c.

#define FAULT_CODE   "faultCode"

Definition at line 246 of file xmlrpc-epi-php.c.

#define FAULT_CODE_LEN   (sizeof(FAULT_CODE) - 1)

Definition at line 247 of file xmlrpc-epi-php.c.

#define FAULT_STRING   "faultString"

Definition at line 248 of file xmlrpc-epi-php.c.

#define FAULT_STRING_LEN   (sizeof(FAULT_STRING) - 1)

Definition at line 249 of file xmlrpc-epi-php.c.

#define my_zend_hash_get_current_key (   ht,
  my_key,
  num_index 
)    zend_hash_get_current_key(ht, my_key, num_index, 0)

Definition at line 360 of file xmlrpc-epi-php.c.

#define OBJECT_TYPE_ATTR   "xmlrpc_type"

Definition at line 241 of file xmlrpc-epi-php.c.

#define OBJECT_VALUE_ATTR   "scalar"

Definition at line 242 of file xmlrpc-epi-php.c.

#define OBJECT_VALUE_TS_ATTR   "timestamp"

Definition at line 243 of file xmlrpc-epi-php.c.

#define OUTPUT_TYPE_KEY   "output_type"

Definition at line 211 of file xmlrpc-epi-php.c.

#define OUTPUT_TYPE_KEY_LEN   (sizeof(OUTPUT_TYPE_KEY) - 1)

Definition at line 212 of file xmlrpc-epi-php.c.

#define OUTPUT_TYPE_VALUE_PHP   "php"

Definition at line 213 of file xmlrpc-epi-php.c.

#define OUTPUT_TYPE_VALUE_XML   "xml"

Definition at line 214 of file xmlrpc-epi-php.c.

#define PHP_EXT_VERSION   "0.51"

Definition at line 76 of file xmlrpc-epi-php.c.

Definition at line 1271 of file xmlrpc-epi-php.c.

#define VERBOSITY_KEY   "verbosity"

Definition at line 216 of file xmlrpc-epi-php.c.

#define VERBOSITY_KEY_LEN   (sizeof(VERBOSITY_KEY) - 1)

Definition at line 217 of file xmlrpc-epi-php.c.

#define VERBOSITY_VALUE_NEWLINES_ONLY   "newlines_only"

Definition at line 219 of file xmlrpc-epi-php.c.

#define VERBOSITY_VALUE_NO_WHITE_SPACE   "no_white_space"

Definition at line 218 of file xmlrpc-epi-php.c.

#define VERBOSITY_VALUE_PRETTY   "pretty"

Definition at line 220 of file xmlrpc-epi-php.c.

#define VERSION_KEY   "version"

Definition at line 229 of file xmlrpc-epi-php.c.

#define VERSION_KEY_LEN   (sizeof(VERSION_KEY) - 1)

Definition at line 230 of file xmlrpc-epi-php.c.

#define VERSION_VALUE_AUTO   "auto"

Definition at line 234 of file xmlrpc-epi-php.c.

#define VERSION_VALUE_SIMPLE   "simple"

Definition at line 231 of file xmlrpc-epi-php.c.

#define VERSION_VALUE_SOAP11   "soap 1.1"

Definition at line 233 of file xmlrpc-epi-php.c.

#define VERSION_VALUE_XMLRPC   "xmlrpc"

Definition at line 232 of file xmlrpc-epi-php.c.

#define XMLRPC_TYPE_COUNT   9

Definition at line 1269 of file xmlrpc-epi-php.c.

#define XMLRPC_VECTOR_TYPE_COUNT   4

Definition at line 1270 of file xmlrpc-epi-php.c.


Typedef Documentation


Function Documentation

static int add_zval ( zval *  list,
const char *  id,
zval **  val 
) [static]

Definition at line 341 of file xmlrpc-epi-php.c.

{
       if (list && val) {
              if (id) {
                     int id_len = strlen(id);
                     if (!(id_len > 1 && id[0] == '0') && is_numeric_string((char *)id, id_len, NULL, NULL, 0) == IS_LONG) {
                            long index = strtol(id, NULL, 0);
                            return zend_hash_index_update(Z_ARRVAL_P(list), index, (void *) val, sizeof(zval **), NULL);
                     } else {
                            return zend_hash_update(Z_ARRVAL_P(list), (char*) id, strlen(id) + 1, (void *) val, sizeof(zval **), NULL);
                     }
              } else {
                     return zend_hash_next_index_insert(Z_ARRVAL_P(list), (void *) val, sizeof(zval **), NULL); 
              }
       }
       /* what is the correct return on error? */
       return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

zval * decode_request_worker ( char *  xml_in,
int  xml_in_len,
char *  encoding_in,
zval *  method_name_out 
)

Definition at line 777 of file xmlrpc-epi-php.c.

{
       zval* retval = NULL;
       XMLRPC_REQUEST response;
       STRUCT_XMLRPC_REQUEST_INPUT_OPTIONS opts = {{0}};
       const char *method_name;
       opts.xml_elem_opts.encoding = encoding_in ? utf8_get_encoding_id_from_string(encoding_in) : ENCODING_DEFAULT;

       /* generate XMLRPC_REQUEST from raw xml */
       response = XMLRPC_REQUEST_FromXML(xml_in, xml_in_len, &opts);
       if (response) {
              /* convert xmlrpc data to native php types */
              retval = XMLRPC_to_PHP(XMLRPC_RequestGetData(response));

              if (XMLRPC_RequestGetRequestType(response) == xmlrpc_request_call) {
                     if (method_name_out) {
                            method_name = XMLRPC_RequestGetMethodName(response);
                            if (method_name) {
                                   zval_dtor(method_name_out);
                                   Z_TYPE_P(method_name_out) = IS_STRING;
                                   Z_STRVAL_P(method_name_out) = estrdup(method_name);
                                   Z_STRLEN_P(method_name_out) = strlen(Z_STRVAL_P(method_name_out));
                            } else if (retval) {
                                   zval_ptr_dtor(&retval);
                                   retval = NULL;
                            }
                     }
              }

              /* dust, sweep, and mop */
              XMLRPC_RequestFree(response, 1);
       }
       return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void destroy_server_data ( xmlrpc_server_data *server  TSRMLS_DC) [static]

Definition at line 267 of file xmlrpc-epi-php.c.

{
       if (server) {
              XMLRPC_ServerDestroy(server->server_ptr);

              zval_dtor(server->method_map);
              FREE_ZVAL(server->method_map);

              zval_dtor(server->introspection_map);
              FREE_ZVAL(server->introspection_map);

              efree(server);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 485 of file xmlrpc-epi-php.c.

{
       int bArray = 0, bStruct = 0, bMixed = 0;
       unsigned long num_index, last_num = 0;
       char* my_key;

       zend_hash_internal_pointer_reset(ht);
       while (1) {
              int res = my_zend_hash_get_current_key(ht, &my_key, &num_index);
              
              if (res == HASH_KEY_IS_LONG) {
                     if (bStruct) {
                            bMixed = 1;
                            break;
                     } else if (last_num > 0 && last_num != num_index-1) {
                            bStruct = 1;
                            break;
                     }
                     bArray = 1;
                     last_num = num_index;
              } else if (res == HASH_KEY_NON_EXISTANT) {
                     break;
              } else if (res == HASH_KEY_IS_STRING) {
                     if (bArray) {
                            bMixed = 1;
                            break;
                     }
                     bStruct = 1;
              }
              zend_hash_move_forward(ht);
       }
       return bMixed ? xmlrpc_vector_mixed : (bStruct ? xmlrpc_vector_struct : xmlrpc_vector_array);
}

Here is the caller graph for this function:

static const char** get_type_str_mapping ( void  ) [static]

Definition at line 1274 of file xmlrpc-epi-php.c.

{
       static const char* str_mapping[TYPE_STR_MAP_SIZE];
       static int first = 1;
       if (first) {
              /* warning. do not add/delete without changing size define */
              str_mapping[xmlrpc_none]     = "none";
              str_mapping[xmlrpc_empty]    = "empty";
              str_mapping[xmlrpc_base64]   = "base64";
              str_mapping[xmlrpc_boolean]  = "boolean";
              str_mapping[xmlrpc_datetime] = "datetime";
              str_mapping[xmlrpc_double]   = "double";
              str_mapping[xmlrpc_int]      = "int";
              str_mapping[xmlrpc_string]   = "string";
              str_mapping[xmlrpc_vector]   = "vector";
              str_mapping[XMLRPC_TYPE_COUNT + xmlrpc_vector_none]   = "none";
              str_mapping[XMLRPC_TYPE_COUNT + xmlrpc_vector_array]  = "array";
              str_mapping[XMLRPC_TYPE_COUNT + xmlrpc_vector_mixed]  = "mixed";
              str_mapping[XMLRPC_TYPE_COUNT + xmlrpc_vector_struct] = "struct";
              first = 0;
       }
       return (const char**)str_mapping;
}

Here is the caller graph for this function:

XMLRPC_VALUE_TYPE get_zval_xmlrpc_type ( zval *  value,
zval **  newvalue 
)

Definition at line 1404 of file xmlrpc-epi-php.c.

{
       XMLRPC_VALUE_TYPE type = xmlrpc_none;
       TSRMLS_FETCH();

       if (value) {
              switch (Z_TYPE_P(value)) {
                     case IS_NULL:
                            type = xmlrpc_base64;
                            break;
#ifndef BOOL_AS_LONG

                     /* Right thing to do, but it breaks some legacy code. */
                     case IS_BOOL:
                            type = xmlrpc_boolean;
                            break;
#else
                     case IS_BOOL:
#endif
                     case IS_LONG:
                     case IS_RESOURCE:
                            type = xmlrpc_int;
                            break;
                     case IS_DOUBLE:
                            type = xmlrpc_double;
                            break;
                     case IS_CONSTANT:
                            type = xmlrpc_string;
                            break;
                     case IS_STRING:
                            type = xmlrpc_string;
                            break;
                     case IS_ARRAY:
                     case IS_CONSTANT_ARRAY:
                            type = xmlrpc_vector;
                            break;
                     case IS_OBJECT:
                            {
                                   zval** attr;
                                   type = xmlrpc_vector;

                                   if (zend_hash_find(Z_OBJPROP_P(value), OBJECT_TYPE_ATTR, sizeof(OBJECT_TYPE_ATTR), (void**) &attr) == SUCCESS) {
                                          if (Z_TYPE_PP(attr) == IS_STRING) {
                                                 type = xmlrpc_str_as_type(Z_STRVAL_PP(attr));
                                          }
                                   }
                                   break;
                            }
              }

              /* if requested, return an unmolested (magic removed) copy of the value */
              if (newvalue) {
                     zval** val;

                     if ((type == xmlrpc_base64 && Z_TYPE_P(value) != IS_NULL) || type == xmlrpc_datetime) {
                            if (zend_hash_find(Z_OBJPROP_P(value), OBJECT_VALUE_ATTR, sizeof(OBJECT_VALUE_ATTR), (void**) &val) == SUCCESS) {
                                   *newvalue = *val;
                            }
                     } else {
                            *newvalue = value;
                     }
              }
       }

       return type;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHP_FUNCTION ( xmlrpc_encode_request  )

Definition at line 701 of file xmlrpc-epi-php.c.

{
       XMLRPC_REQUEST xRequest = NULL;
       char *outBuf;
       zval *vals, *out_opts = NULL;
       char *method = NULL;
       int method_len;
       php_output_options out;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s!z|a", &method, &method_len, &vals, &out_opts) == FAILURE) {
              return;
       }

       set_output_options(&out, out_opts ? out_opts : 0);

       if (return_value_used) {
              xRequest = XMLRPC_RequestNew();

              if (xRequest) {
                     XMLRPC_RequestSetOutputOptions(xRequest, &out.xmlrpc_out);
                     if (method == NULL) {
                            XMLRPC_RequestSetRequestType(xRequest, xmlrpc_request_response);
                     } else {
                            XMLRPC_RequestSetMethodName(xRequest, method);
                            XMLRPC_RequestSetRequestType(xRequest, xmlrpc_request_call);
                     }
                     if (Z_TYPE_P(vals) != IS_NULL) {
                            XMLRPC_RequestSetData(xRequest, PHP_to_XMLRPC(vals TSRMLS_CC));
                     }

                     outBuf = XMLRPC_REQUEST_ToXML(xRequest, 0);
                     if (outBuf) {
                            RETVAL_STRING(outBuf, 1);
                            free(outBuf);
                     }
                     XMLRPC_RequestFree(xRequest, 1);
              }
       }
       
       if (strcmp(out.xmlrpc_out.xml_elem_opts.encoding, ENCODING_DEFAULT) != 0) {
              efree((char *)out.xmlrpc_out.xml_elem_opts.encoding);
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( xmlrpc_encode  )

Definition at line 748 of file xmlrpc-epi-php.c.

{
       XMLRPC_VALUE xOut = NULL;
       zval **arg1;
       char *outBuf;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &arg1) == FAILURE) {
              return;
       }

       if (return_value_used) {
              /* convert native php type to xmlrpc type */
              xOut = PHP_to_XMLRPC(*arg1 TSRMLS_CC);

              /* generate raw xml from xmlrpc data */
              outBuf = XMLRPC_VALUE_ToXML(xOut, 0);

              if (xOut) {
                     if (outBuf) {
                            RETVAL_STRING(outBuf, 1);
                            free(outBuf);
                     }
                     /* cleanup */
                     XMLRPC_CleanupValue(xOut);
              }
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( xmlrpc_decode_request  )

Definition at line 815 of file xmlrpc-epi-php.c.

{
       char *xml, *encoding = NULL;
       zval **method;
       int xml_len, encoding_len = 0;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sZ|s", &xml, &xml_len, &method, &encoding, &encoding_len) == FAILURE) {
              return;
       }


       if (return_value_used) {
              zval* retval = decode_request_worker(xml, xml_len, encoding_len ? encoding : NULL, *method);
              if (retval) {
                     *return_value = *retval;
                     FREE_ZVAL(retval);
              }
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( xmlrpc_decode  )

Definition at line 838 of file xmlrpc-epi-php.c.

{
       char *arg1, *arg2 = NULL;
       int arg1_len, arg2_len = 0;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s", &arg1, &arg1_len, &arg2, &arg2_len) == FAILURE) {
              return;
       }

       if (return_value_used) {
              zval* retval = decode_request_worker(arg1, arg1_len, arg2_len ? arg2 : NULL, NULL);
              if (retval) {
                     *return_value = *retval;
                     FREE_ZVAL(retval);
              }
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( xmlrpc_server_create  )

Definition at line 863 of file xmlrpc-epi-php.c.

{
       if (zend_parse_parameters_none() == FAILURE) {
              return;
       }

       if (return_value_used) {
              zval *method_map, *introspection_map;
              xmlrpc_server_data *server = emalloc(sizeof(xmlrpc_server_data));
              MAKE_STD_ZVAL(method_map);
              MAKE_STD_ZVAL(introspection_map);
              
              array_init(method_map);
              array_init(introspection_map);
              
              /* allocate server data.  free'd in destroy_server_data() */
              server->method_map = method_map;
              server->introspection_map = introspection_map;
              server->server_ptr = XMLRPC_ServerCreate();

              XMLRPC_ServerRegisterIntrospectionCallback(server->server_ptr, php_xmlrpc_introspection_callback);

              /* store for later use */
              ZEND_REGISTER_RESOURCE(return_value,server, le_xmlrpc_server);
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( xmlrpc_server_destroy  )

Definition at line 893 of file xmlrpc-epi-php.c.

{
       zval *arg1;
       int bSuccess = FAILURE, type;
       xmlrpc_server_data *server;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &arg1) == FAILURE) {
              return;
       }

       server = zend_list_find(Z_LVAL_P(arg1), &type);

       if (server && type == le_xmlrpc_server) {
              bSuccess = zend_list_delete(Z_LVAL_P(arg1));

              /* called by hashtable destructor
               * destroy_server_data(server);
               */
       }
       RETVAL_LONG(bSuccess == SUCCESS);
}

Here is the call graph for this function:

PHP_FUNCTION ( xmlrpc_server_register_method  )

Definition at line 1026 of file xmlrpc-epi-php.c.

{
       char *method_key;
       int method_key_len;
       zval *handle, *method_name_save, **method_name;
       int type;
       xmlrpc_server_data* server;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsZ", &handle, &method_key, &method_key_len, &method_name) == FAILURE) {
              return;
       }

       server = zend_list_find(Z_LVAL_P(handle), &type);

       if (type == le_xmlrpc_server) {
              /* register with C engine. every method just calls our standard callback, 
               * and it then dispatches to php as necessary
               */
              if (XMLRPC_ServerRegisterMethod(server->server_ptr, method_key, php_xmlrpc_callback)) {
                     /* save for later use */
                     MAKE_STD_ZVAL(method_name_save);
                     *method_name_save = **method_name;
                     zval_copy_ctor(method_name_save);

                     /* register our php method */
                     add_zval(server->method_map, method_key, &method_name_save);

                     RETURN_BOOL(1);
              }
       }
       RETURN_BOOL(0);
}

Here is the call graph for this function:

PHP_FUNCTION ( xmlrpc_server_register_introspection_callback  )

Definition at line 1062 of file xmlrpc-epi-php.c.

{
       zval **method_name, *handle, *method_name_save;
       int type;
       xmlrpc_server_data* server;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &handle, &method_name) == FAILURE) {
              return;
       }

       server = zend_list_find(Z_LVAL_P(handle), &type);

       if (type == le_xmlrpc_server) {
              /* save for later use */
              MAKE_STD_ZVAL(method_name_save);
              *method_name_save = **method_name;
              zval_copy_ctor(method_name_save);

              /* register our php method */
              add_zval(server->introspection_map, NULL, &method_name_save);

              RETURN_BOOL(1);
       }
       RETURN_BOOL(0);
}

Here is the call graph for this function:

PHP_FUNCTION ( xmlrpc_server_call_method  )

Definition at line 1093 of file xmlrpc-epi-php.c.

{
       xmlrpc_callback_data data = {0};
       XMLRPC_REQUEST xRequest;
       STRUCT_XMLRPC_REQUEST_INPUT_OPTIONS input_opts;
       xmlrpc_server_data* server;
       zval **caller_params, *handle, *output_opts = NULL;
       char *rawxml;
       int rawxml_len, type;
       php_output_options out;
       int argc =ZEND_NUM_ARGS();
       
       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsZ|a", &handle, &rawxml, &rawxml_len, &caller_params, &output_opts) != SUCCESS) {
              return;
       }
       /* user output options */
       if (argc == 3) {
              set_output_options(&out, NULL);
       } else {
              set_output_options(&out, output_opts);
       }

       server = zend_list_find(Z_LVAL_P(handle), &type);

       if (type == le_xmlrpc_server) {
              /* HACK: use output encoding for now */
              input_opts.xml_elem_opts.encoding = utf8_get_encoding_id_from_string(out.xmlrpc_out.xml_elem_opts.encoding);

              /* generate an XMLRPC_REQUEST from the raw xml input */
              xRequest = XMLRPC_REQUEST_FromXML(rawxml, rawxml_len, &input_opts);

              if (xRequest) {
                     const char* methodname = XMLRPC_RequestGetMethodName(xRequest);
                     XMLRPC_VALUE xAnswer = NULL;
                     MAKE_STD_ZVAL(data.xmlrpc_method); /* init. very important.  spent a frustrating day finding this out. */
                     MAKE_STD_ZVAL(data.return_data);
                     Z_TYPE_P(data.return_data) = IS_NULL;  /* in case value is never init'd, we don't dtor to think it is a string or something */
                     Z_TYPE_P(data.xmlrpc_method) = IS_NULL;

                     /* setup some data to pass to the callback function */
                     data.caller_params = *caller_params;
                     data.php_executed = 0;
                     data.server = server;

                     /* We could just call the php method directly ourselves at this point, but we do this 
                      * with a C callback in case the xmlrpc library ever implements some cool usage stats,
                      * or somesuch.
                      */
                     xAnswer = XMLRPC_ServerCallMethod(server->server_ptr, xRequest, &data);
                     if (xAnswer && out.b_php_out) {
                            zval_dtor(data.return_data);
                            FREE_ZVAL(data.return_data);
                            data.return_data = XMLRPC_to_PHP(xAnswer);
                     } else if (data.php_executed && !out.b_php_out && !xAnswer) {
                            xAnswer = PHP_to_XMLRPC(data.return_data TSRMLS_CC);
                     }

                     /* should we return data as xml? */
                     if (!out.b_php_out) {
                            XMLRPC_REQUEST xResponse = XMLRPC_RequestNew();
                            if (xResponse) {
                                   char *outBuf = 0;
                                   int buf_len = 0;

                                   /* automagically determine output serialization type from request type */
                                   if (out.b_auto_version) { 
                                          XMLRPC_REQUEST_OUTPUT_OPTIONS opts = XMLRPC_RequestGetOutputOptions(xRequest);
                                          if (opts) {
                                                 out.xmlrpc_out.version = opts->version;
                                          }
                                   }
                                   /* set some required request hoojum */
                                   XMLRPC_RequestSetOutputOptions(xResponse, &out.xmlrpc_out);
                                   XMLRPC_RequestSetRequestType(xResponse, xmlrpc_request_response);
                                   XMLRPC_RequestSetData(xResponse, xAnswer);
                                   XMLRPC_RequestSetMethodName(xResponse, methodname);

                                   /* generate xml */
                                   outBuf = XMLRPC_REQUEST_ToXML(xResponse, &buf_len);
                                   if (outBuf) {
                                          RETVAL_STRINGL(outBuf, buf_len, 1);
                                          free(outBuf);
                                   }
                                   /* cleanup after ourselves.  what a sty! */
                                   XMLRPC_RequestFree(xResponse, 0);
                            }
                     } else { /* or as native php types? */
                            *return_value = *data.return_data;
                            zval_copy_ctor(return_value);
                     }

                     /* cleanup after ourselves.  what a sty! */
                     zval_ptr_dtor(&data.xmlrpc_method);

                     zval_dtor(data.return_data);
                     FREE_ZVAL(data.return_data);

                     if (xAnswer) {
                            XMLRPC_CleanupValue(xAnswer);
                     }

                     XMLRPC_RequestFree(xRequest, 1);
              }
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( xmlrpc_server_add_introspection_data  )

Definition at line 1202 of file xmlrpc-epi-php.c.

{
       zval *handle, *desc;
       int type;
       xmlrpc_server_data* server;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ra", &handle, &desc) == FAILURE) {
              return;
       }

       server = zend_list_find(Z_LVAL_P(handle), &type);

       if (type == le_xmlrpc_server) {
              XMLRPC_VALUE xDesc = PHP_to_XMLRPC(desc TSRMLS_CC);
              if (xDesc) {
                     int retval = XMLRPC_ServerAddIntrospectionData(server->server_ptr, xDesc);
                     XMLRPC_CleanupValue(xDesc);
                     RETURN_LONG(retval);
              }
       }
       RETURN_LONG(0);
}

Here is the call graph for this function:

PHP_FUNCTION ( xmlrpc_parse_method_descriptions  )

Definition at line 1228 of file xmlrpc-epi-php.c.

{
       zval *retval;
       char *arg1;
       int arg1_len;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arg1, &arg1_len) == FAILURE) {
              return;
       }

       if (return_value_used) {
              STRUCT_XMLRPC_ERROR err = {0};
              XMLRPC_VALUE xVal = XMLRPC_IntrospectionCreateDescription(arg1, &err);
              if (xVal) {
                     retval = XMLRPC_to_PHP(xVal);

                     if (retval) {
                            *return_value = *retval;
                            zval_copy_ctor(return_value);
                     }
                     /* dust, sweep, and mop */
                     XMLRPC_CleanupValue(xVal);
              } else {
                     /* could not create description */
                     if (err.xml_elem_error.parser_code) {
                            php_error_docref(NULL TSRMLS_CC, E_WARNING, "xml parse error: [line %ld, column %ld, message: %s] Unable to create introspection data", 
                                          err.xml_elem_error.column, err.xml_elem_error.line, err.xml_elem_error.parser_error);
                     } else {
                            php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid xml structure. Unable to create introspection data");
                     }

                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "xml parse error. no method description created");
              }
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( xmlrpc_set_type  )

Definition at line 1474 of file xmlrpc-epi-php.c.

{
       zval **arg;
       char *type;
       int type_len;
       XMLRPC_VALUE_TYPE vtype;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Zs", &arg, &type, &type_len) == FAILURE) {
              return;
       }

       vtype = xmlrpc_str_as_type(type);
       if (vtype != xmlrpc_none) {
              if (set_zval_xmlrpc_type(*arg, vtype) == SUCCESS) {
                     RETURN_TRUE;
              }
       } else {
              zend_error(E_WARNING,"invalid type '%s' passed to xmlrpc_set_type()", type);
       }
       RETURN_FALSE;
}

Here is the call graph for this function:

PHP_FUNCTION ( xmlrpc_get_type  )

Definition at line 1499 of file xmlrpc-epi-php.c.

{
       zval **arg;
       XMLRPC_VALUE_TYPE type;
       XMLRPC_VECTOR_TYPE vtype = xmlrpc_vector_none;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &arg) == FAILURE) {
              return;
       }

       type = get_zval_xmlrpc_type(*arg, 0);
       if (type == xmlrpc_vector) {
              vtype = determine_vector_type((Z_TYPE_PP(arg) == IS_OBJECT) ? Z_OBJPROP_PP(arg) : Z_ARRVAL_PP(arg));
       }
   
       RETURN_STRING((char*) xmlrpc_type_as_str(type, vtype), 1);
}

Here is the call graph for this function:

PHP_FUNCTION ( xmlrpc_is_fault  )

Definition at line 1520 of file xmlrpc-epi-php.c.

{
       zval *arg, **val;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &arg) == FAILURE) {
              return;
       }

       /* The "correct" way to do this would be to call the xmlrpc
        * library XMLRPC_ValueIsFault() func.  However, doing that
        * would require us to create an xmlrpc value from the php
        * array, which is rather expensive, especially if it was
        * a big array.  Thus, we resort to this not so clever hackery.
        */
       if (zend_hash_find(Z_ARRVAL_P(arg), FAULT_CODE, FAULT_CODE_LEN + 1, (void**) &val) == SUCCESS && 
              zend_hash_find(Z_ARRVAL_P(arg), FAULT_STRING, FAULT_STRING_LEN + 1, (void**) &val) == SUCCESS) {
              RETURN_TRUE;
       }

       RETURN_FALSE;
}

Here is the call graph for this function:

PHP_MINFO_FUNCTION ( xmlrpc  )

Definition at line 300 of file xmlrpc-epi-php.c.

{
       php_info_print_table_start();
       php_info_print_table_row(2, "core library version", XMLRPC_GetVersionString());
       php_info_print_table_row(2, "php extension version", PHP_EXT_VERSION);
       php_info_print_table_row(2, "author", "Dan Libby");
       php_info_print_table_row(2, "homepage", "http://xmlrpc-epi.sourceforge.net");
       php_info_print_table_row(2, "open sourced by", "Epinions.com");
       php_info_print_table_end();
}

Here is the call graph for this function:

PHP_MINIT_FUNCTION ( xmlrpc  )

Definition at line 292 of file xmlrpc-epi-php.c.

Here is the call graph for this function:

static XMLRPC_VALUE PHP_to_XMLRPC ( zval *root_val  TSRMLS_DC) [static]

Definition at line 624 of file xmlrpc-epi-php.c.

{
       return PHP_to_XMLRPC_worker(NULL, root_val, 0 TSRMLS_CC);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static XMLRPC_VALUE PHP_to_XMLRPC_worker ( const char *  key,
zval *  in_val,
int depth  TSRMLS_DC 
) [static]

Definition at line 520 of file xmlrpc-epi-php.c.

{
       XMLRPC_VALUE xReturn = NULL;

       if (in_val) {
              zval* val = NULL;
              XMLRPC_VALUE_TYPE type = get_zval_xmlrpc_type(in_val, &val);
       
              if (val) {
                     switch (type) {
                            case xmlrpc_base64:
                                   if (Z_TYPE_P(val) == IS_NULL) {
                                          xReturn = XMLRPC_CreateValueEmpty();
                                          XMLRPC_SetValueID(xReturn, key, 0);
                                   } else {
                                          xReturn = XMLRPC_CreateValueBase64(key, Z_STRVAL_P(val), Z_STRLEN_P(val));
                                   }
                                   break;
                            case xmlrpc_datetime:
                                   convert_to_string(val);
                                   xReturn = XMLRPC_CreateValueDateTime_ISO8601(key, Z_STRVAL_P(val));
                                   break;
                            case xmlrpc_boolean:
                                   convert_to_boolean(val);
                                   xReturn = XMLRPC_CreateValueBoolean(key, Z_LVAL_P(val));
                                   break;
                            case xmlrpc_int:
                                   convert_to_long(val);
                                   xReturn = XMLRPC_CreateValueInt(key, Z_LVAL_P(val));
                                   break;
                            case xmlrpc_double:
                                   convert_to_double(val);
                                   xReturn = XMLRPC_CreateValueDouble(key, Z_DVAL_P(val));
                                   break;
                            case xmlrpc_string:
                                   convert_to_string(val);
                                   xReturn = XMLRPC_CreateValueString(key, Z_STRVAL_P(val), Z_STRLEN_P(val));
                                   break;
                            case xmlrpc_vector:
                                   {
                                          unsigned long num_index;
                                          zval** pIter;
                                          char* my_key;
                                          HashTable *ht = NULL;
                                          zval *val_arr;
                                          XMLRPC_VECTOR_TYPE vtype;

                                          ht = HASH_OF(val);
                                          if (ht && ht->nApplyCount > 1) {
                                                 php_error_docref(NULL TSRMLS_CC, E_ERROR, "XML-RPC doesn't support circular references");
                                                 return NULL;
                                          }

                                          MAKE_STD_ZVAL(val_arr);
                                          MAKE_COPY_ZVAL(&val, val_arr);
                                          convert_to_array(val_arr);
                                          
                                          vtype = determine_vector_type(Z_ARRVAL_P(val_arr));
                                          xReturn = XMLRPC_CreateVector(key, vtype);

                                          zend_hash_internal_pointer_reset(Z_ARRVAL_P(val_arr));
                                          while(zend_hash_get_current_data(Z_ARRVAL_P(val_arr), (void**)&pIter) == SUCCESS) {
                                                 int res = my_zend_hash_get_current_key(Z_ARRVAL_P(val_arr), &my_key, &num_index);

                                                 switch (res) {
                                                        case HASH_KEY_NON_EXISTANT:
                                                               break;
                                                        case HASH_KEY_IS_STRING:
                                                        case HASH_KEY_IS_LONG:
                                                               ht = HASH_OF(*pIter);
                                                               if (ht) {
                                                                      ht->nApplyCount++;
                                                               }
                                                               if (res == HASH_KEY_IS_LONG) {
                                                                      char *num_str = NULL;
                                                                      
                                                                      if (vtype != xmlrpc_vector_array) {
                                                                             spprintf(&num_str, 0, "%ld", num_index);
                                                                      }
                                                                      XMLRPC_AddValueToVector(xReturn, PHP_to_XMLRPC_worker(num_str, *pIter, depth++ TSRMLS_CC));
                                                                      if (num_str) {
                                                                             efree(num_str);
                                                                      }
                                                               } else {
                                                                      XMLRPC_AddValueToVector(xReturn, PHP_to_XMLRPC_worker(my_key, *pIter, depth++ TSRMLS_CC));
                                                               }
                                                               if (ht) {
                                                                      ht->nApplyCount--;
                                                               }
                                                               break;
                                                 }
                                                 zend_hash_move_forward(Z_ARRVAL_P(val_arr));
                                          }      
                                          zval_ptr_dtor(&val_arr);
                                   }
                                   break;
                            default:
                                   break;
                     }
              }
       }
       return xReturn;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static XMLRPC_VALUE php_xmlrpc_callback ( XMLRPC_SERVER  server,
XMLRPC_REQUEST  xRequest,
void *  data 
) [static]

Definition at line 919 of file xmlrpc-epi-php.c.

{
       xmlrpc_callback_data* pData = (xmlrpc_callback_data*)data;
       zval** php_function;
       zval* xmlrpc_params;
       zval* callback_params[3];
       TSRMLS_FETCH();

       zval_dtor(pData->xmlrpc_method);
       zval_dtor(pData->return_data);

       /* convert xmlrpc to native php types */
       ZVAL_STRING(pData->xmlrpc_method, XMLRPC_RequestGetMethodName(xRequest), 1);
       xmlrpc_params = XMLRPC_to_PHP(XMLRPC_RequestGetData(xRequest));
       
       /* check if the called method has been previous registered */
       if(zend_hash_find(Z_ARRVAL_P(pData->server->method_map),
                      Z_STRVAL_P(pData->xmlrpc_method), 
                      Z_STRLEN_P(pData->xmlrpc_method) + 1, 
                      (void**)&php_function) == SUCCESS) {

              pData->php_function = *php_function;
       }

       /* setup data hoojum */
       callback_params[0] = pData->xmlrpc_method;
       callback_params[1] = xmlrpc_params;
       callback_params[2] = pData->caller_params;

       /* Use same C function for all methods */

       /* php func prototype: function user_func($method_name, $xmlrpc_params, $user_params) */
       call_user_function(CG(function_table), NULL, pData->php_function, pData->return_data, 3, callback_params TSRMLS_CC);

       pData->php_executed = 1;

       zval_ptr_dtor(&xmlrpc_params);

       return PHP_to_XMLRPC(pData->return_data TSRMLS_CC);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void php_xmlrpc_introspection_callback ( XMLRPC_SERVER  server,
void *  data 
) [static]

Definition at line 964 of file xmlrpc-epi-php.c.

{
       zval retval, **php_function;
       zval *callback_params[1];
       char *php_function_name;
       xmlrpc_callback_data* pData = (xmlrpc_callback_data*)data;
       TSRMLS_FETCH();

       /* setup data hoojum */
       callback_params[0] = pData->caller_params;

       /* loop through and call all registered callbacks */
       zend_hash_internal_pointer_reset(Z_ARRVAL_P(pData->server->introspection_map));
       while (1) {
              if (zend_hash_get_current_data(Z_ARRVAL_P(pData->server->introspection_map), (void**)&php_function) == SUCCESS) {
                     if (zend_is_callable(*php_function, 0, &php_function_name TSRMLS_CC)) {
                            /* php func prototype: function string user_func($user_params) */
                            if (call_user_function(CG(function_table), NULL, *php_function, &retval, 1, callback_params TSRMLS_CC) == SUCCESS) {
                                   XMLRPC_VALUE xData;
                                   STRUCT_XMLRPC_ERROR err = {0};

                                   /* return value should be a string */
                                   convert_to_string(&retval);

                                   xData = XMLRPC_IntrospectionCreateDescription(Z_STRVAL(retval), &err);

                                   if (xData) {
                                          if (!XMLRPC_ServerAddIntrospectionData(server, xData)) {
                                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to add introspection data returned from %s(), improper element structure", php_function_name);
                                          }
                                          XMLRPC_CleanupValue(xData);
                                   } else {
                                          /* could not create description */
                                          if (err.xml_elem_error.parser_code) {
                                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "xml parse error: [line %ld, column %ld, message: %s] Unable to add introspection data returned from %s()", 
                                                        err.xml_elem_error.column, err.xml_elem_error.line, err.xml_elem_error.parser_error, php_function_name);
                                          } else {
                                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to add introspection data returned from %s()", php_function_name);
                                          }
                                   }
                                   zval_dtor(&retval);
                            } else {
                                   /* user func failed */
                                   php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error calling user introspection callback: %s()", php_function_name);
                            }
                     } else {
                            php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid callback '%s' passed", php_function_name);
                     }
                     efree(php_function_name);
              } else {
                     break;
              }
              zend_hash_move_forward(Z_ARRVAL_P(pData->server->introspection_map));
       }
       
       /* so we don't call the same callbacks ever again */
       zend_hash_clean(Z_ARRVAL_P(pData->server->introspection_map));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void set_output_options ( php_output_options options,
zval *  output_opts 
) [static]

Definition at line 369 of file xmlrpc-epi-php.c.

{
       if (options) {

              /* defaults */
              options->b_php_out = 0;
              options->b_auto_version = 1;
              options->xmlrpc_out.version = xmlrpc_version_1_0;
              options->xmlrpc_out.xml_elem_opts.encoding = ENCODING_DEFAULT;
              options->xmlrpc_out.xml_elem_opts.verbosity = xml_elem_pretty;
              options->xmlrpc_out.xml_elem_opts.escaping = xml_elem_markup_escaping | xml_elem_non_ascii_escaping | xml_elem_non_print_escaping;

              if (output_opts && Z_TYPE_P(output_opts) == IS_ARRAY) {
                     zval** val;

                     /* type of output (xml/php) */
                     if (zend_hash_find(Z_ARRVAL_P(output_opts), OUTPUT_TYPE_KEY, OUTPUT_TYPE_KEY_LEN + 1, (void**) &val) == SUCCESS) {
                            if (Z_TYPE_PP(val) == IS_STRING) {
                                   if (!strcmp(Z_STRVAL_PP(val), OUTPUT_TYPE_VALUE_PHP)) {
                                          options->b_php_out = 1;
                                   } else if (!strcmp(Z_STRVAL_PP(val), OUTPUT_TYPE_VALUE_XML)) {
                                          options->b_php_out = 0;
                                   }
                            }
                     }

                     /* verbosity of generated xml */
                     if (zend_hash_find(Z_ARRVAL_P(output_opts), VERBOSITY_KEY, VERBOSITY_KEY_LEN + 1, (void**) &val) == SUCCESS) {
                            if (Z_TYPE_PP(val) == IS_STRING) {
                                   if (!strcmp(Z_STRVAL_PP(val), VERBOSITY_VALUE_NO_WHITE_SPACE)) {
                                          options->xmlrpc_out.xml_elem_opts.verbosity = xml_elem_no_white_space;
                                   } else if (!strcmp(Z_STRVAL_PP(val), VERBOSITY_VALUE_NEWLINES_ONLY)) {
                                          options->xmlrpc_out.xml_elem_opts.verbosity = xml_elem_newlines_only;
                                   } else if (!strcmp(Z_STRVAL_PP(val), VERBOSITY_VALUE_PRETTY)) {
                                          options->xmlrpc_out.xml_elem_opts.verbosity = xml_elem_pretty;
                                   }
                            }
                     }

                     /* version of xml to output */
                     if (zend_hash_find(Z_ARRVAL_P(output_opts), VERSION_KEY, VERSION_KEY_LEN + 1, (void**) &val) == SUCCESS) {
                            if (Z_TYPE_PP(val) == IS_STRING) {
                                   options->b_auto_version = 0;
                                   if (!strcmp(Z_STRVAL_PP(val), VERSION_VALUE_XMLRPC)) {
                                          options->xmlrpc_out.version = xmlrpc_version_1_0;
                                   } else if (!strcmp(Z_STRVAL_PP(val), VERSION_VALUE_SIMPLE)) {
                                          options->xmlrpc_out.version = xmlrpc_version_simple;
                                   } else if (!strcmp((*val)->value.str.val, VERSION_VALUE_SOAP11)) {
                                                 options->xmlrpc_out.version = xmlrpc_version_soap_1_1;
                                   } else { /* if(!strcmp((*val)->value.str.val, VERSION_VALUE_AUTO)) { */
                                                 options->b_auto_version = 1;
                                   }
                            }
                     }

                     /* encoding code set */
                     if (zend_hash_find(Z_ARRVAL_P(output_opts), ENCODING_KEY, ENCODING_KEY_LEN + 1, (void**)&val) == SUCCESS) {
                            if (Z_TYPE_PP(val) == IS_STRING) {
                                   options->xmlrpc_out.xml_elem_opts.encoding = estrdup(Z_STRVAL_PP(val));
                            }
                     }

                     /* escaping options */
                     if (zend_hash_find(Z_ARRVAL_P(output_opts), ESCAPING_KEY, ESCAPING_KEY_LEN + 1, (void**)&val) == SUCCESS) {
                            /* multiple values allowed.  check if array */
                            if (Z_TYPE_PP(val) == IS_ARRAY) {
                                   zval** iter_val;

                                   zend_hash_internal_pointer_reset(Z_ARRVAL_PP(val));
                                   options->xmlrpc_out.xml_elem_opts.escaping = xml_elem_no_escaping;

                                   while (1) {
                                          if (zend_hash_get_current_data(Z_ARRVAL_PP(val), (void**)&iter_val) == SUCCESS) {
                                                 if (Z_TYPE_PP(iter_val) == IS_STRING && Z_STRVAL_PP(iter_val)) {
                                                        if (!strcmp(Z_STRVAL_PP(iter_val), ESCAPING_VALUE_CDATA)) {
                                                               options->xmlrpc_out.xml_elem_opts.escaping |= xml_elem_cdata_escaping;
                                                        } else if (!strcmp(Z_STRVAL_PP(iter_val), ESCAPING_VALUE_NON_ASCII)) {
                                                               options->xmlrpc_out.xml_elem_opts.escaping |= xml_elem_non_ascii_escaping;
                                                        } else if (!strcmp(Z_STRVAL_PP(iter_val), ESCAPING_VALUE_NON_PRINT)) {
                                                               options->xmlrpc_out.xml_elem_opts.escaping |= xml_elem_non_print_escaping;
                                                        } else if (!strcmp(Z_STRVAL_PP(iter_val), ESCAPING_VALUE_MARKUP)) {
                                                               options->xmlrpc_out.xml_elem_opts.escaping |= xml_elem_markup_escaping;
                                                        }
                                                 }
                                          } else {
                                                 break;
                                          }
                                          zend_hash_move_forward(Z_ARRVAL_PP(val));
                                   }
                            /* else, check for single value */
                            } else if (Z_TYPE_PP(val) == IS_STRING) {
                                   if (!strcmp(Z_STRVAL_PP(val), ESCAPING_VALUE_CDATA)) {
                                          options->xmlrpc_out.xml_elem_opts.escaping = xml_elem_cdata_escaping;
                                   } else if (!strcmp(Z_STRVAL_PP(val), ESCAPING_VALUE_NON_ASCII)) {
                                          options->xmlrpc_out.xml_elem_opts.escaping = xml_elem_non_ascii_escaping;
                                   } else if (!strcmp(Z_STRVAL_PP(val), ESCAPING_VALUE_NON_PRINT)) {
                                          options->xmlrpc_out.xml_elem_opts.escaping = xml_elem_non_print_escaping;
                                   } else if (!strcmp(Z_STRVAL_PP(val), ESCAPING_VALUE_MARKUP)) {
                                          options->xmlrpc_out.xml_elem_opts.escaping = xml_elem_markup_escaping;
                                   }
                            }
                     }
              }
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

int set_zval_xmlrpc_type ( zval *  value,
XMLRPC_VALUE_TYPE  type 
)

Definition at line 1350 of file xmlrpc-epi-php.c.

{
       int bSuccess = FAILURE;
       TSRMLS_FETCH();

       /* we only really care about strings because they can represent
        * base64 and datetime.  all other types have corresponding php types
        */
       if (Z_TYPE_P(value) == IS_STRING) {
              if (newtype == xmlrpc_base64 || newtype == xmlrpc_datetime) {
                     const char* typestr = xmlrpc_type_as_str(newtype, xmlrpc_vector_none);
                     zval* type;

                     MAKE_STD_ZVAL(type);

                     Z_TYPE_P(type) = IS_STRING;
                     Z_STRVAL_P(type) = estrdup(typestr);
                     Z_STRLEN_P(type) = strlen(typestr);

                     if (newtype == xmlrpc_datetime) {
                            XMLRPC_VALUE v = XMLRPC_CreateValueDateTime_ISO8601(NULL, value->value.str.val);
                            if (v) {
                                   time_t timestamp = (time_t) php_parse_date((char *)XMLRPC_GetValueDateTime_ISO8601(v), NULL);
                                   if (timestamp != -1) {
                                          zval* ztimestamp;

                                          MAKE_STD_ZVAL(ztimestamp);

                                          ztimestamp->type = IS_LONG;
                                          ztimestamp->value.lval = timestamp;

                                          convert_to_object(value);
                                          if (SUCCESS == zend_hash_update(Z_OBJPROP_P(value), OBJECT_TYPE_ATTR, sizeof(OBJECT_TYPE_ATTR), (void *) &type, sizeof(zval *), NULL)) {
                                                 bSuccess = zend_hash_update(Z_OBJPROP_P(value), OBJECT_VALUE_TS_ATTR, sizeof(OBJECT_VALUE_TS_ATTR), (void *) &ztimestamp, sizeof(zval *), NULL);
                                          }
                                   } else {
                                          zval_ptr_dtor(&type);
                                   }
                                   XMLRPC_CleanupValue(v);
                            } else {
                                   zval_ptr_dtor(&type);
                            }
                     } else {
                            convert_to_object(value);
                            bSuccess = zend_hash_update(Z_OBJPROP_P(value), OBJECT_TYPE_ATTR, sizeof(OBJECT_TYPE_ATTR), (void *) &type, sizeof(zval *), NULL);
                     }
              }
       }

       return bSuccess;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int sset_zval_xmlrpc_type ( zval *  value,
XMLRPC_VALUE_TYPE  type 
)
static void xmlrpc_server_destructor ( zend_rsrc_list_entry *rsrc  TSRMLS_DC) [static]

Definition at line 284 of file xmlrpc-epi-php.c.

{
       if (rsrc && rsrc->ptr) {
              destroy_server_data((xmlrpc_server_data*) rsrc->ptr TSRMLS_CC);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

XMLRPC_VALUE_TYPE xmlrpc_str_as_type ( const char *  str)

Definition at line 1313 of file xmlrpc-epi-php.c.

{
       const char** str_mapping = get_type_str_mapping();
       int i;

       if (str) {
              for (i = 0; i < XMLRPC_TYPE_COUNT; i++) {
                     if (!strcmp(str_mapping[i], str)) {
                            return (XMLRPC_VALUE_TYPE) i;
                     }
              }
       }
       return xmlrpc_none;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1330 of file xmlrpc-epi-php.c.

{
       const char** str_mapping = get_type_str_mapping();
       int i;

       if (str) {
              for (i = XMLRPC_TYPE_COUNT; i < TYPE_STR_MAP_SIZE; i++) {
                     if (!strcmp(str_mapping[i], str)) {
                            return (XMLRPC_VECTOR_TYPE) (i - XMLRPC_TYPE_COUNT);
                     }
              }
       }
       return xmlrpc_none;
}

Here is the call graph for this function:

static zval* XMLRPC_to_PHP ( XMLRPC_VALUE  el) [static]

Definition at line 630 of file xmlrpc-epi-php.c.

{
       zval* elem = NULL;
       const char* pStr;

       if (el) {
              XMLRPC_VALUE_TYPE type = XMLRPC_GetValueType(el);

              MAKE_STD_ZVAL(elem); /* init. very important.  spent a frustrating day finding this out. */

              switch(type) {
                     case xmlrpc_empty:
                            Z_TYPE_P(elem) = IS_NULL;
                            break;
                     case xmlrpc_string:
                            pStr = XMLRPC_GetValueString(el);
                            if (pStr) {
                                   Z_STRLEN_P(elem) = XMLRPC_GetValueStringLen(el);
                                   Z_STRVAL_P(elem) = estrndup(pStr, Z_STRLEN_P(elem));
                                   Z_TYPE_P(elem) = IS_STRING;
                            }
                            break;
                     case xmlrpc_int:
                            Z_LVAL_P(elem) = XMLRPC_GetValueInt(el);
                            Z_TYPE_P(elem) = IS_LONG;
                            break;
                     case xmlrpc_boolean:
                            Z_LVAL_P(elem) = XMLRPC_GetValueBoolean(el);
                            Z_TYPE_P(elem) = IS_BOOL;
                            break;
                     case xmlrpc_double:
                            Z_DVAL_P(elem) = XMLRPC_GetValueDouble(el);
                            Z_TYPE_P(elem) = IS_DOUBLE;
                            break;
                     case xmlrpc_datetime:
                            Z_STRLEN_P(elem) = XMLRPC_GetValueStringLen(el);
                            Z_STRVAL_P(elem) = estrndup(XMLRPC_GetValueDateTime_ISO8601(el), Z_STRLEN_P(elem));
                            Z_TYPE_P(elem) = IS_STRING;
                            break;
                     case xmlrpc_base64:
                            pStr = XMLRPC_GetValueBase64(el);
                            if (pStr) {
                                   Z_STRLEN_P(elem) = XMLRPC_GetValueStringLen(el);
                                   Z_STRVAL_P(elem) = estrndup(pStr, Z_STRLEN_P(elem));
                                   Z_TYPE_P(elem) = IS_STRING;
                            }
                            break;
                     case xmlrpc_vector:
                            array_init(elem);
                            {
                                   XMLRPC_VALUE xIter = XMLRPC_VectorRewind(el);

                                   while( xIter ) {
                                          zval *val = XMLRPC_to_PHP(xIter);
                                          if (val) {
                                                 add_zval(elem, XMLRPC_GetValueID(xIter), &val);
                                          }
                                          xIter = XMLRPC_VectorNext(el);
                                   }
                            }
                            break;
                     default:
                            break;
              }
              set_zval_xmlrpc_type(elem, type);
       }
       return elem;
}

Here is the call graph for this function:

Here is the caller graph for this function:

const char * xmlrpc_type_as_str ( XMLRPC_VALUE_TYPE  type,
XMLRPC_VECTOR_TYPE  vtype 
)

Definition at line 1300 of file xmlrpc-epi-php.c.

{
       const char** str_mapping = get_type_str_mapping();

       if (vtype == xmlrpc_vector_none) {
              return str_mapping[type];
       } else {
              return str_mapping[XMLRPC_TYPE_COUNT + vtype];
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

Definition at line 78 of file xmlrpc-epi-php.c.

Initial value:

Definition at line 146 of file xmlrpc-epi-php.c.

zend_module_entry xmlrpc_module_entry
Initial value:

Definition at line 164 of file xmlrpc-epi-php.c.