自学教程：C++ xmlrpc_build_value函数代码示例

static voidtest_value_invalid_struct(void) {    xmlrpc_value * v;    xmlrpc_env env;    /* Note that even though the format strings are invalid, we have       to supply the variable arguments that xmlrpc_build_value() will       be looking for as it tries to parse it.  Otherwise, we get wild       memory references and consequent Valgrind flags.    */        xmlrpc_env_init(&env);    v = xmlrpc_build_value(&env, "{s:ii", "key1", 9, 9);    TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);    v = xmlrpc_build_value(&env, "{si:", "key1", 9);    TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);    v = xmlrpc_build_value(&env, "{s", "key1");    TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);    xmlrpc_env_clean(&env);}

xmlrpc_value *tcos_lockscreen(xmlrpc_env *env, xmlrpc_value *in, void *ud)#endif {  char *user;  char *pass;  char *login_ok;  /* Parse app string */  xmlrpc_parse_value(env, in, "(ss)", &user, &pass);  if (env->fault_occurred)    return xmlrpc_build_value(env, "s", "params error");  /* need login first */  login_ok=validate_login(user,pass);  if( strcmp(login_ok,  LOGIN_OK ) != 0 )    return xmlrpc_build_value(env, "s", login_ok );  if ( strcmp(TCOS_PATH, "/sbin" ) )    job_exe(TCOS_PATH"/lockscreen");  else    job_exe("lockscreen");  return xmlrpc_build_value(env, "s", "OK" );}

static voidcallOneMethod(xmlrpc_env *      const envP,              xmlrpc_registry * const registryP,              xmlrpc_value *    const rpcDescP,              void *            const callInfo,              xmlrpc_value **   const resultPP) {    const char * methodName;    xmlrpc_value * paramArrayP;    XMLRPC_ASSERT_ENV_OK(envP);    if (xmlrpc_value_type(rpcDescP) != XMLRPC_TYPE_STRUCT)        xmlrpc_env_set_fault_formatted(            envP, XMLRPC_TYPE_ERROR,            "An element of the multicall array is type %u, but should "            "be a struct (with members 'methodName' and 'params')",            xmlrpc_value_type(rpcDescP));    else {        xmlrpc_decompose_value(envP, rpcDescP, "{s:s,s:A,*}",                               "methodName", &methodName,                               "params", &paramArrayP);        if (!envP->fault_occurred) {            /* Watch out for a deep recursion attack. */            if (xmlrpc_streq(methodName, "system.multicall"))                xmlrpc_env_set_fault_formatted(                    envP,                    XMLRPC_REQUEST_REFUSED_ERROR,                    "Recursive system.multicall forbidden");            else {                xmlrpc_env env;                xmlrpc_value * resultValP;                xmlrpc_env_init(&env);                xmlrpc_dispatchCall(&env, registryP, methodName, paramArrayP,                                    callInfo,                                    &resultValP);                if (env.fault_occurred) {                    /* Method failed, so result is a fault structure */                    *resultPP =                         xmlrpc_build_value(                            envP, "{s:i,s:s}",                            "faultCode", (xmlrpc_int32) env.fault_code,                            "faultString", env.fault_string);                } else {                    *resultPP = xmlrpc_build_value(envP, "(V)", resultValP);                    xmlrpc_DECREF(resultValP);                }                xmlrpc_env_clean(&env);            }            xmlrpc_DECREF(paramArrayP);            xmlrpc_strfree(methodName);        }    }}

static xmlrpc_value *freeswitch_api(xmlrpc_env * const envP, xmlrpc_value * const paramArrayP, void *const userData, void *const callInfo){	char *command = NULL, *arg = NULL;	switch_stream_handle_t stream = { 0 };	xmlrpc_value *val = NULL;	switch_bool_t freed = 0;	/* Parse our argument array. */	xmlrpc_decompose_value(envP, paramArrayP, "(ss)", &command, &arg);	if (envP->fault_occurred) {		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid Request!/n");		return NULL;	}	if (!is_authorized((const TSession *) callInfo, command)) {		val = xmlrpc_build_value(envP, "s", "UNAUTHORIZED!");		goto end;	}	if (switch_stristr("unload", command) && switch_stristr("mod_xml_rpc", arg)) {		switch_safe_free(command);		switch_safe_free(arg);		freed = 1;		command = "bgapi";		arg = "unload mod_xml_rpc";	} else if (switch_stristr("reload", command) && switch_stristr("mod_xml_rpc", arg)) {		switch_safe_free(command);		switch_safe_free(arg);		freed = 1;		command = "bgapi";		arg = "reload mod_xml_rpc";	}	SWITCH_STANDARD_STREAM(stream);	if (switch_api_execute(command, arg, NULL, &stream) == SWITCH_STATUS_SUCCESS) {		/* Return our result. */		val = xmlrpc_build_value(envP, "s", stream.data);		free(stream.data);	} else {		val = xmlrpc_build_value(envP, "s", "ERROR!");	}  end:	/* xmlrpc-c requires us to free memory it malloced from xmlrpc_decompose_value */	if (!freed) {		switch_safe_free(command);		switch_safe_free(arg);	}	return val;}

xmlrpc_value *tcos_standalone(xmlrpc_env *env, xmlrpc_value *in, void *ud)#endif {  FILE *fp;  char line[BIG_BUFFER];  char *info;  char *group;  size_t *len;  char *fret;  UNUSED(fret);  /* read what info search */  xmlrpc_parse_value(env, in, "(ss#)", &info, &group, &len);  dbgtcos("tcosxmlrpc::tcos_standalone() searching for standalone=/"%s/"/n", info);  if ( strcmp(info, "get_user") == 0 )    fp=(FILE*)popen(STANDALONE_USER, "r");  else if ( strcmp(info, "get_exclude") == 0 ) {    snprintf( line, BSIZE, "%s=%s 2>/dev/null", STANDALONE_EXCLUDE, group);    fp=(FILE*)popen(line, "r");  }  else if ( strcmp(info, "get_process") == 0 )    fp=(FILE*)popen(STANDALONE_PROCESS, "r");  else if ( strcmp(info, "get_server") == 0 ) {    snprintf( line, BSIZE, "%s %s 2>/dev/null", STANDALONE_SERVER, group);    fp=(FILE*)popen(line, "r");  }  else if ( strcmp(info, "get_multiseat") == 0 ) {    snprintf( line, BSIZE, "%s %s 2>/dev/null", STANDALONE_MULTISEAT, group);    fp=(FILE*)popen(line, "r");  }  else if ( strcmp(info, "get_time") == 0 )    fp=(FILE*)popen(STANDALONE_TIME, "r");  /* default method = error */  else    return xmlrpc_build_value(env, "s", STANDALONE_UNKNOW );  if (fp == NULL)    return xmlrpc_build_value(env, "s", STANDALONE_UNKNOW );  /* put error into line */  strncpy(line, STANDALONE_ERROR, BIG_BUFFER);  fret=fgets( line, sizeof line, fp);  remove_line_break(line);  pclose(fp);  dbgtcos("tcosxmlrpc::tcos_standalone() line=/"%s/"/n", line);  return xmlrpc_build_value(env, "s", line );}

xmlrpc_value *tcos_dpms(xmlrpc_env *env, xmlrpc_value *in, void *ud)#endif {  FILE *fp;  char line[BIG_BUFFER];  char *action;  char *user;  char *pass;  char *login_ok;  char cmd[BIG_BUFFER];  char *fret;  UNUSED(fret);  /* read what info search */  xmlrpc_parse_value(env, in, "(sss)", &action, &user, &pass);  if (env->fault_occurred)    return xmlrpc_build_value(env, "s", "params error");   /* need login first */  login_ok=validate_login(user,pass);  if( strcmp(login_ok,  LOGIN_OK ) != 0 )    return xmlrpc_build_value(env, "s", login_ok );  dbgtcos("tcosxmlrpc::tcos_dpms() login ok, action=%s /n", action);  /* read action */  if( strcmp(action, "off" ) == 0 ) {    sprintf( cmd , "%s dpms force off; echo $?", DPMS_CONTROLLER);  }  else if( strcmp(action, "on" ) == 0 ) {    sprintf( cmd , "%s dpms force on; echo $?", DPMS_CONTROLLER);  }  else {    /* show status */    sprintf( cmd , "%s q| awk '/Monitor/ {print $3}'", DPMS_CONTROLLER);  }  dbgtcos("tcosxmlrpc::tcos_dpms() cmd=/"%s/"/n", cmd);  /* put error in line */  strncpy(line, DPMS_CMD_ERROR, BIG_BUFFER);  fp=(FILE*)popen(cmd, "r");  fret=fgets( line, sizeof line, fp);  remove_line_break(line);  pclose(fp);  dbgtcos("tcosxmlrpc::tcos_dpms() line=/"%s/"/n", line);  return xmlrpc_build_value(env, "s", line );}

static voidtest_build_decomp_datetime(void) {    const char * datestring = "19980717T14:08:55";    time_t const datetime = 900684535;    xmlrpc_env env;    xmlrpc_value * v;    time_t dt;    const char * ds;    xmlrpc_env_init(&env);    v = xmlrpc_build_value(&env, "t", datetime);    TEST_NO_FAULT(&env);    TEST(v != NULL);    TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_DATETIME);    dt = 0;    xmlrpc_read_datetime_sec(&env, v, &dt);    TEST(dt == datetime);    dt = 0;    xmlrpc_decompose_value(&env, v, "t", &dt);    xmlrpc_DECREF(v);    TEST_NO_FAULT(&env);    TEST(dt == datetime);    v = xmlrpc_int_new(&env, 9);    TEST_NO_FAULT(&env);    xmlrpc_decompose_value(&env, v, "t", &dt);    TEST_FAULT(&env, XMLRPC_TYPE_ERROR);    xmlrpc_env_clean(&env);    xmlrpc_env_init(&env);    xmlrpc_decompose_value(&env, v, "8", &ds);    TEST_FAULT(&env, XMLRPC_TYPE_ERROR);    xmlrpc_env_clean(&env);    xmlrpc_env_init(&env);    xmlrpc_DECREF(v);    v = xmlrpc_build_value(&env, "8", datestring);    TEST_NO_FAULT(&env);    TEST(v != NULL);    TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_DATETIME);    xmlrpc_decompose_value(&env, v, "8", &ds);    xmlrpc_DECREF(v);    TEST_NO_FAULT(&env);    TEST(streq(ds, datestring));    strfree(ds);    xmlrpc_env_clean(&env);}

xmlrpc_value* xmlok (xmlrpc_env *env,xmlrpc_value *array){	//Si es null ponemos uno vacio	if (array==NULL)		array = xmlrpc_build_value(env,"()");	//Creamos el valor de retorno	xmlrpc_value *ret = xmlrpc_build_value(env,"{s:i,s:A}","returnCode",1,"returnVal",array);	//Decrementamos el contador	xmlrpc_DECREF(array);	//Y salimos	return ret;}

static xmlrpc_value *you_license (xmlrpc_env   *env,             xmlrpc_value *param_array,             void         *user_data){    xmlrpc_value *xmlrpc_patches = NULL;    RCYouPatchSList *patches = NULL;    GSList *licenses = NULL;    xmlrpc_value *xmlrpc_licenses = NULL;    GSList *iter;    xmlrpc_parse_value (env, param_array, "(A)", &xmlrpc_patches);    XMLRPC_FAIL_IF_FAULT (env);    patches = rc_xmlrpc_array_to_rc_you_patch_slist        (xmlrpc_patches, env, RC_YOU_PATCH_FROM_XMLRPC_PATCH);    XMLRPC_FAIL_IF_FAULT (env);    licenses = rc_you_patch_slist_lookup_licenses (patches);    xmlrpc_licenses = xmlrpc_build_value (env, "()");    XMLRPC_FAIL_IF_FAULT (env);    for (iter = licenses; iter; iter = iter->next) {        xmlrpc_value *xmlrpc_text;        xmlrpc_text = xmlrpc_build_value (env, "s", (char *) iter->data);        XMLRPC_FAIL_IF_FAULT (env);        xmlrpc_array_append_item (env, xmlrpc_licenses, xmlrpc_text);        XMLRPC_FAIL_IF_FAULT (env);        xmlrpc_DECREF (xmlrpc_text);    } cleanup:    if (patches) {        rc_you_patch_slist_unref (patches);        g_slist_free (patches);    }    g_slist_free (licenses);    if (env->fault_occurred)        return NULL;    return xmlrpc_licenses;}

static xmlrpc_value *license_lookup_from_packages (xmlrpc_env   *env,                              xmlrpc_value *param_array,                              void         *user_data){    xmlrpc_value *xmlrpc_packages;    RCPackageSList *packages = NULL;    GSList *licenses = NULL;    xmlrpc_value *license_texts = NULL;    GSList *iter;    xmlrpc_parse_value (env, param_array, "(A)", &xmlrpc_packages);    XMLRPC_FAIL_IF_FAULT (env);    packages = rcd_xmlrpc_array_to_rc_package_slist (xmlrpc_packages, env,                                                     RCD_PACKAGE_FROM_XMLRPC_PACKAGE);    XMLRPC_FAIL_IF_FAULT (env);    licenses = rcd_license_lookup_from_package_slist (packages);    license_texts = xmlrpc_build_value (env, "()");    XMLRPC_FAIL_IF_FAULT (env);    for (iter = licenses; iter; iter = iter->next) {        xmlrpc_value *xmlrpc_text;        xmlrpc_text = xmlrpc_build_value (env, "s", (char *) iter->data);        XMLRPC_FAIL_IF_FAULT (env);        xmlrpc_array_append_item (env, license_texts, xmlrpc_text);        XMLRPC_FAIL_IF_FAULT (env);        xmlrpc_DECREF (xmlrpc_text);    }cleanup:    if (packages) {        rc_package_slist_unref (packages);        g_slist_free (packages);    }    g_slist_free (licenses);    if (env->fault_occurred)        return NULL;    return license_texts;}

static int recur_build_response_array( xmlrpc_env * env, struct mi_node * tree,                                       str * buf ){    for ( ; tree ; tree = tree->next ) {        if (!(tree->flags & MI_WRITTEN)) {            if ( xr_write_node( buf, tree ) != 0 ) {                LM_ERR("failed to get MI node data!/n");                return -1;            }            /* we are sure that this node has been written            * => avoid writing it again */            tree->flags |= MI_WRITTEN;        }        reply_buffer[reply_buffer_len-buf->len] = 0;        reply_item = xmlrpc_build_value(env, "s", reply_buffer);        xmlrpc_array_append_item(env, xr_response, reply_item);        buf->s = reply_buffer;        buf->len = reply_buffer_len;        if ( tree->kids ) {            if ( recur_build_response_array(env, tree->kids, buf) != 0 )                return -1;        }    }    return 0;}

xmlrpc_value* FLVStartReceivingVideo(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data){	FLVServer *flv = (FLVServer *)user_data;	FLVSession *session = NULL;	 //Parseamos	int sessionId;	xmlrpc_parse_value(env, param_array, "(i)", &sessionId);	//Comprobamos si ha habido error	if(env->fault_occurred)		return 0;	 	//Obtenemos la referencia	if(!flv->GetSessionRef(sessionId,&session))		return xmlerror(env,"La sessionerencia no existe/n");	//La borramos	int recVideoPort = session->StartReceivingVideo();	//Liberamos la referencia	flv->ReleaseSessionRef(sessionId);	//Salimos	if(!recVideoPort)		return xmlerror(env,"No se ha podido terminar la sessionerencia/n");	//Devolvemos el resultado	return xmlok(env,xmlrpc_build_value(env,"(i)",recVideoPort));}

//CreateSessionxmlrpc_value* FLVCreateSession(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data){	FLVServer *flv = (FLVServer *)user_data;	FLVSession *session = NULL;	 //Parseamos	char *str;	xmlrpc_parse_value(env, param_array, "(s)", &str);	 	//Creamos la sessionerencia	int sessionId = flv->CreateSession(str);	//Si error	if (!sessionId>0)		return xmlerror(env,"No se puede crear la sessionerencia");	//Obtenemos la referencia	if(!flv->GetSessionRef(sessionId,&session))		return xmlerror(env,"Conferencia borrada antes de poder iniciarse/n");	//La iniciamos	int port = session->Init();	//Liberamos la referencia	flv->ReleaseSessionRef(sessionId);	//Salimos	if(!port)		return xmlerror(env,"No se ha podido iniciar la sessionerencia/n");	//Devolvemos el resultado	return xmlok(env,xmlrpc_build_value(env,"(ii)",sessionId,port));}

static voidtest_value_bool(void) {    xmlrpc_value * v;    xmlrpc_env env;    xmlrpc_bool b;    /* Test booleans. */    xmlrpc_env_init(&env);    TEST(streq(xmlrpc_type_name(XMLRPC_TYPE_BOOL), "BOOL"));    v = xmlrpc_bool_new(&env, (xmlrpc_bool) 1);    TEST_NO_FAULT(&env);    TEST(XMLRPC_TYPE_BOOL == xmlrpc_value_type(v));    xmlrpc_read_bool(&env, v, &b);    TEST_NO_FAULT(&env);    TEST(b);    xmlrpc_DECREF(v);    v = xmlrpc_build_value(&env, "b", (xmlrpc_bool) 0);    TEST_NO_FAULT(&env);    TEST(v != NULL);    TEST(XMLRPC_TYPE_BOOL == xmlrpc_value_type(v));    xmlrpc_decompose_value(&env, v, "b", &b);    xmlrpc_DECREF(v);    TEST_NO_FAULT(&env);    TEST(!b);    xmlrpc_env_clean(&env);}

static voidtest_value_AS(void) {    xmlrpc_value *v;    xmlrpc_value *v2;    xmlrpc_value *v3;    xmlrpc_env env;    size_t len;    /* Test parsing of 'A' and 'S'. */    xmlrpc_env_init(&env);    v = xmlrpc_build_value(&env, "((){})");    TEST_NO_FAULT(&env);    xmlrpc_decompose_value(&env, v, "(AS)", &v2, &v3);    xmlrpc_DECREF(v);    TEST_NO_FAULT(&env);    TEST(XMLRPC_TYPE_ARRAY == xmlrpc_value_type(v2));    TEST(XMLRPC_TYPE_STRUCT == xmlrpc_value_type(v3));    len = xmlrpc_array_size(&env, v2);    TEST_NO_FAULT(&env);    TEST(len == 0);    len = xmlrpc_struct_size(&env, v3);    TEST_NO_FAULT(&env);    TEST(len == 0);    xmlrpc_DECREF(v2);    xmlrpc_DECREF(v3);    xmlrpc_env_clean(&env);}

xmlrpc_value* DeleteMosaic(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data){	MCU *mcu = (MCU *)user_data;	MultiConf *conf = NULL;	 //Parseamos	int confId;	int mosaicId;	xmlrpc_parse_value(env, param_array, "(ii)", &confId,&mosaicId);	//Comprobamos si ha habido error	if(env->fault_occurred)		xmlerror(env,"Fault occurred/n");	//Obtenemos la referencia	if(!mcu->GetConferenceRef(confId,&conf))		return xmlerror(env,"Conference does not exist");	//La borramos	int res = conf->DeleteMosaic(mosaicId);	//Liberamos la referencia	mcu->ReleaseConferenceRef(confId);	//Salimos	if(!res)		return xmlerror(env,"Could reset overlay image/n");	//Devolvemos el resultado	return xmlok(env,xmlrpc_build_value(env,"(i)",mosaicId));}

xmlrpc_value* xmlerror (xmlrpc_env *env,const char *msg){	//Send error	Error("Error processing xml cmd [/"%s/"]/n",msg);	//Exit	return xmlrpc_build_value(env,"{s:i,s:s}","returnCode",0,"errorMsg",msg);}

static xmlrpc_value *sample_add(xmlrpc_env *   const envP,           xmlrpc_value * const paramArrayP,           void *         const serverInfo,           void *         const channelInfo) {    xmlrpc_int32 x, y, z;    /* Parse our argument array. */    xmlrpc_decompose_value(envP, paramArrayP, "(ii)", &x, &y);    if (envP->fault_occurred)        return NULL;    /* Add our two numbers. */    z = x + y;    /* Sometimes, make it look hard (so client can see what it's like       to do an RPC that takes a while).    */    if (y == 1)        sleep(1);    /* Return our result. */    return xmlrpc_build_value(envP, "i", z);}

static xmlrpc_value * weblab_xmlrpc_test_me(xmlrpc_env * const env, xmlrpc_value * const param_array, void * const user_data) {    char * arg;    xmlrpc_decompose_value(env, param_array, "(s)", &arg);    if (env->fault_occurred)        return NULL;    return xmlrpc_build_value(env, "s", arg);}

xmlrpc_value* GetConferences(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data){	MCU *mcu = (MCU *)user_data;	MCU::ConferencesInfo list;	//Obtenemos la referencia	if(!mcu->GetConferenceList(list))		return xmlerror(env,"Could not retreive conference info list/n");	//Create array	xmlrpc_value* arr = xmlrpc_array_new(env);	//Process result	for (MCU::ConferencesInfo::iterator it = list.begin(); it!=list.end(); ++it)	{		//Create array		xmlrpc_value* val = xmlrpc_build_value(env,"(isi)",it->second.id,it->second.name.c_str(),it->second.numPart);		//Add it		xmlrpc_array_append_item(env,arr,val);		//Release		xmlrpc_DECREF(val);	}	//return	return xmlok(env,arr);}

xmlrpc_value* StartBroadcaster(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data){	MCU *mcu = (MCU *)user_data;	MultiConf *conf = NULL;	 //Parseamos	int confId;	xmlrpc_parse_value(env, param_array, "(i)", &confId);	//Comprobamos si ha habido error	if(env->fault_occurred)		xmlerror(env,"Fault occurred/n");	 	//Obtenemos la referencia	if(!mcu->GetConferenceRef(confId,&conf))		return xmlerror(env,"Conference does not exist");	//La borramos	int port = conf->StartBroadcaster();	//Liberamos la referencia	mcu->ReleaseConferenceRef(confId);	//Salimos	if(!port)		return xmlerror(env,"No se ha podido crear el watcher FLV/n");	//Devolvemos el resultado	return xmlok(env,xmlrpc_build_value(env,"(i)",port));}

xmlrpc_value* CreateSpy(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data){	MCU *mcu = (MCU *)user_data;	MultiConf *conf = NULL;	UTF8Parser parser;		 //Parseamos	int confId;	int spyeeId;	xmlrpc_parse_value(env, param_array, "(ii)", &confId,&spyeeId);		//Comprobamos si ha habido error	if(env->fault_occurred)		xmlerror(env,"Fault occurred/n");		 	//Obtenemos la referencia	if(!mcu->GetConferenceRef(confId,&conf))		return xmlerror(env,"Conference does not exist");		//La borramos	int spyId = conf->CreateSpy(spyeeId);		//Liberamos la referencia	mcu->ReleaseConferenceRef(confId);		//Salimos	if(!spyId)		return xmlerror(env,"Create spy failed /n");		//Devolvemos el resultado	return xmlok(env,xmlrpc_build_value(env,"(i)",spyId));}

static voidrcd_transaction_send_log (RCDTransaction *transaction,                          gboolean        successful,                          const char     *message){    xmlrpc_env env;    xmlrpc_value *params;    xmlrpc_value *transaction_log = NULL;    xmlrpc_env_init (&env);    transaction_log = transaction_xml (&env, transaction,                                       successful, message);    XMLRPC_FAIL_IF_FAULT (&env);    params = xmlrpc_build_value (&env, "(V)", transaction_log);    XMLRPC_FAIL_IF_FAULT (&env);    rcd_xmlrpc_client_foreach_host (TRUE, "rcserver.transaction.log",                                    log_sent_cb, NULL,                                    params);    xmlrpc_DECREF (params);cleanup:    xmlrpc_env_clean (&env);    if (transaction_log)        xmlrpc_DECREF (transaction_log);} /* rcd_transaction_send_log */

static voidtest_value_double(void) {    xmlrpc_value * v;    xmlrpc_env env;    double d;    xmlrpc_env_init(&env);    TEST(streq(xmlrpc_type_name(XMLRPC_TYPE_DOUBLE), "DOUBLE"));    v = xmlrpc_double_new(&env, -3.25);    TEST_NO_FAULT(&env);    TEST(XMLRPC_TYPE_DOUBLE == xmlrpc_value_type(v));    xmlrpc_read_double(&env, v, &d);    TEST_NO_FAULT(&env);    TEST(d == -3.25);    xmlrpc_DECREF(v);    v = xmlrpc_build_value(&env, "d", 1.0);    TEST_NO_FAULT(&env);    TEST(v != NULL);    TEST(XMLRPC_TYPE_DOUBLE == xmlrpc_value_type(v));    xmlrpc_decompose_value(&env, v, "d", &d);    xmlrpc_DECREF(v);    TEST_NO_FAULT(&env);    TEST(d == 1.0);    xmlrpc_env_clean(&env);}

static xmlrpc_value * weblab_xmlrpc_dispose(xmlrpc_env * const env, xmlrpc_value * const param_array, void * const user_data) {    char * response;    if (env->fault_occurred)        return NULL;    response = weblab_handlers.dispose();    return xmlrpc_build_value(env, "s", response);}

xmlrpc_value* CreateMosaic(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data){	MCU *mcu = (MCU *)user_data;	MultiConf *conf = NULL;	 //Parseamos	int confId;	int comp;	int size;	xmlrpc_parse_value(env, param_array, "(iii)", &confId,&comp,&size);	//Comprobamos si ha habido error	if(env->fault_occurred)		xmlerror(env,"Fault occurred/n");	 	//Obtenemos la referencia	if(!mcu->GetConferenceRef(confId,&conf))		return xmlerror(env,"Conference does not exist");	//La borramos	int mosaicId = conf->CreateMosaic((Mosaic::Type)comp,size);	//Liberamos la referencia	mcu->ReleaseConferenceRef(confId);	//Salimos	if(!mosaicId)		return xmlerror(env,"Could not create mosaic/n");	//Devolvemos el resultado	return xmlok(env,xmlrpc_build_value(env,"(i)",mosaicId));}

/* This method returns version information of flowgrindd and OS as an xmlrpc struct */static xmlrpc_value * method_get_version(xmlrpc_env * const env,		   xmlrpc_value * const param_array,		   void * const user_data){	UNUSED_ARGUMENT(param_array);	UNUSED_ARGUMENT(user_data);	struct utsname buf;	xmlrpc_value *ret = 0;	DEBUG_MSG(LOG_WARNING, "Method get_version called");	if (uname(&buf)) {		logging_log(LOG_WARNING, "uname() failed %s", strerror(errno));		exit(1);	}	ret = xmlrpc_build_value(env, "{s:s,s:i,s:s,s:s}",				 "version", FLOWGRIND_VERSION,				 "api_version", FLOWGRIND_API_VERSION,				 "os_name", buf.sysname,				 "os_release", buf.release);	if (env->fault_occurred)		logging_log(LOG_WARNING, "Method get_version failed: %s", env->fault_string);	else {		DEBUG_MSG(LOG_WARNING, "Method get_version successful");	}	return ret;}

static xmlrpc_value * weblab_xmlrpc_is_up_and_running(xmlrpc_env * const env, xmlrpc_value * const param_array, void * const user_data) {    int response;    if (env->fault_occurred)        return NULL;    response = weblab_handlers.is_up_and_running();    return xmlrpc_build_value(env, "b", response);}