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

xmlrpc_value* StartSendingVideo(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data){	MCU *mcu = (MCU *)user_data;	MultiConf *conf = NULL;	 //Parseamos	int confId;	int partId;	char *sendVideoIp;	int sendVideoPort;	xmlrpc_value *rtpMap;	xmlrpc_parse_value(env, param_array, "(iisiS)", &confId,&partId,&sendVideoIp,&sendVideoPort,&rtpMap);	//Get the rtp map	VideoCodec::RTPMap map;	//Get map size	int j = xmlrpc_struct_size(env,rtpMap);	//Parse rtp map	for (int i=0;i<j;i++)	{		xmlrpc_value *key, *val;		const char *type;		int codec;		//Read member		xmlrpc_struct_read_member(env,rtpMap,i,&key,&val);		//Read name		xmlrpc_parse_value(env,key,"s",&type);		//Read value		xmlrpc_parse_value(env,val,"i",&codec);		//Add to map		map[atoi(type)] = (VideoCodec::Type) codec;		//Decrement ref counter		xmlrpc_DECREF(key);		xmlrpc_DECREF(val);	}	//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->StartSendingVideo(partId,sendVideoIp,sendVideoPort,map) != NULL;	//Liberamos la referencia	mcu->ReleaseConferenceRef(confId);	//Salimos	if(!res)		return xmlerror(env,"Error/n");	//Devolvemos el resultado	return xmlok(env);}

xmlrpc_value* MediaGatewayStartSendingText(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data){	MediaGateway *mediaGateway = (MediaGateway *)user_data;	MediaBridgeSession *session = NULL;	 //Parseamos	int sessionId;	char *sendTextIp;	int sendTextPort;	xmlrpc_value *rtpMap;	xmlrpc_parse_value(env, param_array, "(isiS)", &sessionId,&sendTextIp,&sendTextPort,&rtpMap);	//Comprobamos si ha habido error	if(env->fault_occurred)		return 0;	//Get the rtp map	TextCodec::RTPMap map;	//Get map size	int j = xmlrpc_struct_size(env,rtpMap);	//Parse rtp map	for (int i=0;i<j;i++)	{		xmlrpc_value *key, *val;		const char *type;		int codec;		//Read member		xmlrpc_struct_read_member(env,rtpMap,i,&key,&val);		//Read name		xmlrpc_parse_value(env,key,"s",&type);		//Read value		xmlrpc_parse_value(env,val,"i",&codec);		//Add to map		map[atoi(type)] = (TextCodec::Type) codec;		//Decrement ref counter		xmlrpc_DECREF(key);		xmlrpc_DECREF(val);	}	//Obtenemos la referencia	if(!mediaGateway->GetMediaBridgeRef(sessionId,&session))		return xmlerror(env,"La sessionerencia no existe/n");	//La borramos	int res = session->StartSendingText(sendTextIp,sendTextPort,map);	//Liberamos la referencia	mediaGateway->ReleaseMediaBridgeRef(sessionId);	//Salimos	if(!res)		return xmlerror(env,"Error/n");	//Devolvemos el resultado	return xmlok(env);}

xmlrpc_value* StartReceivingText(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data){	MCU *mcu = (MCU *)user_data;	MultiConf *conf = NULL;	 //Parseamos	int confId;	int partId;	xmlrpc_value *rtpMap;	xmlrpc_parse_value(env, param_array, "(iiS)", &confId,&partId,&rtpMap);	//Get the rtp map	TextCodec::RTPMap map;	int j = xmlrpc_struct_size(env,rtpMap);	//Parse rtp map	for (int i=0;i<j;i++)	{		xmlrpc_value *key, *val;		const char *type;		int codec;		//Read member		xmlrpc_struct_read_member(env,rtpMap,i,&key,&val);		//Read name		xmlrpc_parse_value(env,key,"s",&type);		//Read value		xmlrpc_parse_value(env,val,"i",&codec);		//Add to map		map[atoi(type)] = (TextCodec::Type) codec;		//Decrement ref counter		xmlrpc_DECREF(key);		xmlrpc_DECREF(val);	}	//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 recTextPort = conf->StartReceivingText(partId,map);	//Liberamos la referencia	mcu->ReleaseConferenceRef(confId);	//Salimos	if(!recTextPort)		return xmlerror(env,"No se ha podido terminar la conferencia/n");	//Devolvemos el resultado	return xmlok(env,xmlrpc_build_value(env,"(i)",recTextPort,recTextPort));}

//CreateConferencexmlrpc_value* CreateConference(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data){	MCU *mcu = (MCU *)user_data;	MultiConf *conf = NULL;	UTF8Parser tagParser;	 //Parseamos	char *str;	int queueId = 0;	xmlrpc_parse_value(env, param_array, "(si)", &str, &queueId);	//Comprobamos si ha habido error	if(env->fault_occurred)	{		//Try with old parameters		xmlrpc_parse_value(env, param_array, "(s)", &str);		//Comprobamos si ha habido error		if(env->fault_occurred)			//Send errro			xmlerror(env,"Fault occurred/n");	}	//Parse string	tagParser.Parse((BYTE*)str,strlen(str));	//Creamos la conferencia	int confId = mcu->CreateConference(tagParser.GetWString(),queueId);	//Si error	if (!confId>0)		return xmlerror(env,"No se puede crear la conferencia");	//Obtenemos la referencia	if(!mcu->GetConferenceRef(confId,&conf))		return xmlerror(env,"Conferencia borrada antes de poder iniciarse/n");	//La iniciamos	int res = conf->Init();	//Liberamos la referencia	mcu->ReleaseConferenceRef(confId);	//Salimos	if(!res)		return xmlerror(env,"No se ha podido iniciar la conferencia/n");	//Devolvemos el resultado	return xmlok(env,xmlrpc_build_value(env,"(i)",confId));}

vertex_id_t ubigraph_new_vertex(){    xmlrpc_env env;    char* const methodName = "ubigraph.new_vertex";    xmlrpc_value * resultP;    if (!xmlrpc_initialized)        init_xmlrpc(0);    xmlrpc_env_init(&env);    /* Make the remote procedure call */    resultP = xmlrpc_client_call(&env, ubigraph_url, methodName,            "()");    if (print_err_if_fault_occurred(&env))        return UBIGRAPH_FAIL;    xmlrpc_int32 status;    xmlrpc_parse_value(&env, resultP, "i", &status);    /* Dispose of our result value. */    xmlrpc_DECREF(resultP);    if (print_err_if_fault_occurred(&env))        return UBIGRAPH_FAIL;    return status;}

xmlrpc_value* SetCompositionType(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data){	MCU *mcu = (MCU *)user_data;	MultiConf *conf = NULL;	 //Parseamos	int confId;	int mosaicId;	int comp;	int size;	xmlrpc_parse_value(env, param_array, "(iiii)", &confId,&mosaicId,&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 res = conf->SetCompositionType(mosaicId,(Mosaic::Type)comp,size);	//Liberamos la referencia	mcu->ReleaseConferenceRef(confId);	//Salimos	if(!res)		return xmlerror(env,"Error/n");	//Devolvemos el resultado	return xmlok(env);}

xmlrpc_value* StopSendingAudio(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data){	MCU *mcu = (MCU *)user_data;	MultiConf *conf = NULL;	 //Parseamos	int confId;	int partId;	xmlrpc_parse_value(env, param_array, "(ii)", &confId,&partId);	//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->StopSendingAudio(partId);	//Liberamos la referencia	mcu->ReleaseConferenceRef(confId);	//Salimos	if(!res)		return xmlerror(env,"No se ha podido terminar la conferencia/n");	//Devolvemos el resultado	return xmlok(env);}

xmlrpc_value* AddConferenceToken(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data){	UTF8Parser parser;	MCU *mcu = (MCU *)user_data;	MultiConf *conf = NULL;	 //Parseamos	int confId;	char *str;	xmlrpc_parse_value(env, param_array, "(is)", &confId, &str);	//Comprobamos si ha habido error	if(env->fault_occurred)		xmlerror(env,"Fault occurred/n");	//Parse string	parser.Parse((BYTE*)str,strlen(str));	//Obtenemos la referencia	if(!mcu->GetConferenceRef(confId,&conf))		return xmlerror(env,"Conference does not exist");	//La borramos	bool res  = conf->AddBroadcastToken(parser.GetWString());	//Liberamos la referencia	mcu->ReleaseConferenceRef(confId);	//Salimos	if(!res)		return xmlerror(env,"Could not add pin to broadcast session/n");	//Devolvemos el resultado	return xmlok(env);}

xmlrpc_value* ResetMosaicOverlay(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->ResetMosaicOverlay(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));}

static xmlrpc_value *service_remove (xmlrpc_env   *env,                xmlrpc_value *param_array,                void         *user_data){    char *service_identifier;    RCWorldService *service;    xmlrpc_parse_value (env, param_array, "(s)", &service_identifier);    XMLRPC_FAIL_IF_FAULT (env);    service = service_lookup (service_identifier);    if (!service) {        xmlrpc_env_set_fault_formatted (env, RCD_RPC_FAULT_INVALID_SERVICE,                                        "Unable to unmount service for '%s'",                                        service_identifier);        goto cleanup;    }    rc_world_multi_remove_subworld (RC_WORLD_MULTI (rc_get_world ()),                                    RC_WORLD (service));    rcd_services_save ();cleanup:    if (env->fault_occurred)        return NULL;    return xmlrpc_build_value (env, "i", 0);}

static xmlrpc_value *service_add (xmlrpc_env   *env,             xmlrpc_value *param_array,             void         *user_data){    char *service_url, *mangled_url;    GError *err = NULL;    xmlrpc_parse_value (env, param_array, "(s)", &service_url);    XMLRPC_FAIL_IF_FAULT (env);    /* We always want to download data from the site */    mangled_url = g_strconcat (service_url, "?remote_only=1", NULL);    if (!rc_world_multi_mount_service (RC_WORLD_MULTI (rc_get_world ()),                                       mangled_url, &err)) {        xmlrpc_env_set_fault_formatted (env, RCD_RPC_FAULT_INVALID_SERVICE,                                        "Unable to mount service for '%s': %s",                                        service_url, err->message);    } else        rcd_services_save ();    g_free (mangled_url);cleanup:    if (env->fault_occurred)        return NULL;    return xmlrpc_build_value (env, "i", 0);}

static xmlrpc_value *you_abort_download (xmlrpc_env   *env,                    xmlrpc_value *param_array,                    void         *user_data){    int download_id;    RCDRPCMethodData *method_data;    int success;    xmlrpc_value *result = NULL;    xmlrpc_parse_value (env, param_array, "(i)", &download_id);    if (!rc_you_transaction_is_valid (download_id)) {        xmlrpc_env_set_fault (env, RCD_RPC_FAULT_INVALID_TRANSACTION_ID,                              "Cannot find transaction for that id");        return NULL;    }    method_data = rcd_rpc_get_method_data ();    success = rc_you_transaction_abort (download_id, method_data->identity);    if (success < 0) {        xmlrpc_env_set_fault (env, RCD_RPC_FAULT_PERMISSION_DENIED,                              "Permission denied");        return NULL;    }    result = xmlrpc_build_value (env, "i", success);    return result;}

xmlrpc_value* MediaGatewaySetMediaBridgeOutputToken(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data){	UTF8Parser parser;	MediaGateway *mediaGateway = (MediaGateway *)user_data;	//Parseamos	int sessionId;	char *str;	xmlrpc_parse_value(env, param_array, "(is)", &sessionId, &str);	//Comprobamos si ha habido error	if(env->fault_occurred)		return 0;	//Parse string	parser.Parse((BYTE*)str,strlen(str));	//La borramos	bool res = mediaGateway->SetMediaBridgeOutputToken(sessionId,parser.GetWString());	//Salimos	if(!res)		return xmlerror(env,"Could not set output token to bridge session/n");	//Devolvemos el resultado	return xmlok(env);}

xmlrpc_value* MediaGatewaySendFPU(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data){	MediaGateway *mediaGateway = (MediaGateway *)user_data;	MediaBridgeSession *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(!mediaGateway->GetMediaBridgeRef(sessionId,&session))		return xmlerror(env,"La sessionerencia no existe/n");	//La borramos	int res = session->SendFPU();	//Liberamos la referencia	mediaGateway->ReleaseMediaBridgeRef(sessionId);	//Salimos	if(!res)		return xmlerror(env,"Error/n");	//Devolvemos el resultado	return xmlok(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" );}

xmlrpc_value* StopRecordingParticipant(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data){	MCU *mcu = (MCU *)user_data;	MultiConf *conf = NULL;	 //Parseamos	int confId;	int playerId;	xmlrpc_parse_value(env, param_array, "(ii)", &confId,&playerId);	//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->StopRecordingParticipant(playerId);	//Liberamos la referencia	mcu->ReleaseConferenceRef(confId);	//Salimos	if(!res)		return xmlerror(env,"Could not stop play back in conference/n");	//Devolvemos el resultado	return xmlok(env);}

xmlrpc_value* SetMute(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data){	MCU *mcu = (MCU *)user_data;	MultiConf *conf = NULL;	 //Parseamos	int confId;	int partId;	int media;	int isMuted;	xmlrpc_parse_value(env, param_array, "(iiii)", &confId, &partId, &media, &isMuted);	//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->SetMute(partId,(MediaFrame::Type)media,isMuted);	//Liberamos la referencia	mcu->ReleaseConferenceRef(confId);	//Salimos	if(!res)		return xmlerror(env,"Could not start playback/n");	//Devolvemos el resultado	return xmlok(env);}

static xmlrpc_value *users_remove (xmlrpc_env   *env,              xmlrpc_value *param_array,              void         *user_data){    char *username;    gboolean rv = FALSE;    xmlrpc_value *value = NULL;        xmlrpc_parse_value (env, param_array, "(s)", &username);    XMLRPC_FAIL_IF_FAULT (env);    if (username && *username) {        RCDIdentity *identity;        identity = rcd_identity_lookup (username);        if (identity != NULL) {            rv = rcd_identity_remove (identity);            rcd_identity_free (identity);        }    }    value = xmlrpc_build_value (env, "i", rv ? 1 : 0); cleanup:    return value;}

xmlrpc_value* DeleteSpy(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data){	MCU *mcu = (MCU *)user_data;	MultiConf *conf = NULL;	 //Parseamos	int confId;	int spyId;	xmlrpc_parse_value(env, param_array, "(ii)", &confId,&spyId);	//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->DeleteSpy(spyId);	//Liberamos la referencia	mcu->ReleaseConferenceRef(confId);	//Salimos	if(!res)		return xmlerror(env,"Delete spy error/n");	//Devolvemos el resultado	return xmlok(env);}

static intxmlrpc_parse_struct(htsmsg_t *dst, htsmsg_t *params,		    char *errbuf, size_t errlen){  htsmsg_field_t *f, *g;  htsmsg_t *c, *c2;  const char *name;  HTSMSG_FOREACH(f, params) {    if(strcmp(f->hmf_name, "member") ||       (c = htsmsg_get_map_by_field(f)) == NULL)      continue;    if((name = htsmsg_get_str(c, "name")) == NULL)      continue;    if((c2 = htsmsg_get_map(c, "value")) == NULL)      continue;    g = TAILQ_FIRST(&c2->hm_fields);    if(g == NULL)      continue;    if(xmlrpc_parse_value(dst, g, name, errbuf, errlen))      return -1;  }  return 0;}

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));}

static intxmlrpc_parse_array(htsmsg_t *dst, htsmsg_t *m, 		   char *errbuf, size_t errlen){  htsmsg_t *c;  htsmsg_field_t *f, *g;  if((m = htsmsg_get_map(m, "data")) == NULL) {    return 0; // Empty array  }  HTSMSG_FOREACH(f, m) {    if(strcmp(f->hmf_name, "value") || (c = htsmsg_get_map_by_field(f)) == NULL)      continue;    g = TAILQ_FIRST(&c->hm_fields);    if(g == NULL || g->hmf_type != HMF_MAP)      continue;        if(xmlrpc_parse_value(dst, g, NULL, errbuf, errlen)) {      return -1;    }  }  return 0;}

static htsmsg_t *xmlrpc_convert_response(htsmsg_t *xml, char *errbuf, size_t errlen){  htsmsg_t *dst, *params;  htsmsg_field_t *f, *g;  htsmsg_t *c;  if((params = htsmsg_get_map_multi(xml, "methodResponse",  "params",				    NULL)) == NULL) {    snprintf(errbuf, errlen, "No params in reply found");    return NULL;  }  dst = htsmsg_create_list();  HTSMSG_FOREACH(f, params) {    if(strcmp(f->hmf_name, "param") || (c = htsmsg_get_map_by_field(f)) == NULL)      continue;    if((c = htsmsg_get_map(c, "value")) == NULL)      continue;    g = TAILQ_FIRST(&c->hm_fields);    if(g == NULL || g->hmf_type != HMF_MAP)      continue;    if(xmlrpc_parse_value(dst, g, NULL, errbuf, errlen)) {      htsmsg_release(dst);      return NULL;    }  }  return dst;}

xmlrpc_value* RemoveMosaicParticipant(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data){	MCU *mcu = (MCU *)user_data;	MultiConf *conf = NULL;	 //Parseamos	int confId;	int mosaicId;	int partId;	xmlrpc_parse_value(env, param_array, "(iii)", &confId,&mosaicId,&partId);	//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");	//Set slot	int res = conf->RemoveMosaicParticipant(mosaicId,partId);	//Liberamos la referencia	mcu->ReleaseConferenceRef(confId);	//Salimos	if(!res)		return xmlerror(env,"Error/n");	//Devolvemos el resultado	return xmlok(env);}

bool ArchiveDataClient::getNames(int key, const stdString &pattern,                                 stdVector<NameInfo> &names){    xmlrpc_value *result, *element;    const char   *name;    xmlrpc_int32 start_sec, start_nano, end_sec, end_nano;    size_t       count, i, len;    NameInfo     info;    result = xmlrpc_client_call(&env, (char *)URL, "archiver.names", "(is)",                                (xmlrpc_int32) key, pattern.c_str());    if (log_fault())        return false;    count = xmlrpc_array_size(&env, result);    names.reserve(count);    for (i=0; i<count; ++i)    {        element = xmlrpc_array_get_item(&env, result, i);        if (log_fault())            return false;        xmlrpc_parse_value(&env, element, "{s:s#,s:i,s:i,s:i,s:i,*}",                           "name",       &name, &len,                           "start_sec",  &start_sec,                           "start_nano", &start_nano,                           "end_sec",    &end_sec,                           "end_nano",   &end_nano);        if (log_fault())            return false;        info.name.assign(name, len);        pieces2epicsTime(start_sec, start_nano, info.start);        pieces2epicsTime(end_sec, end_nano, info.end);        names.push_back(info);    }    xmlrpc_DECREF(result);    return true;}

result_t ubigraph_set_edge_attribute(edge_id_t s, const char* attribute,        const char* value){    xmlrpc_env env;    char* const methodName = "ubigraph.set_edge_attribute";    xmlrpc_value * resultP;    if (!xmlrpc_initialized)        init_xmlrpc(0);    xmlrpc_env_init(&env);    /* Make the remote procedure call */    resultP = xmlrpc_client_call(&env, ubigraph_url, methodName,            "(iss)", (xmlrpc_int32)s, attribute, value);    if (print_err_if_fault_occurred(&env)) {        return UBIGRAPH_FAIL;    }    xmlrpc_int32 status;    xmlrpc_parse_value(&env, resultP, "i", &status);    /* Dispose of our result value. */    xmlrpc_DECREF(resultP);    if (print_err_if_fault_occurred(&env))        return UBIGRAPH_FAIL;    return status;}

//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));}

xmlrpc_value* FLVStopReceivingVideo(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 res = session->StopReceivingVideo();	//Liberamos la referencia	flv->ReleaseSessionRef(sessionId);	//Salimos	if(!res)		return xmlerror(env,"Error/n");	//Devolvemos el resultado	return xmlok(env);}

static voidtest_value_parse_value(void) {    xmlrpc_env env;    xmlrpc_value * valueP;    const char * datestring = "19980717T14:08:55";    xmlrpc_env_init(&env);    valueP = xmlrpc_build_value(&env, "(idb8ss#6(i){s:i}np(i))",                                7, 3.14, (xmlrpc_bool)1, datestring,                                "hello world", "a/0b", (size_t)3,                                "base64 data", strlen("base64 data"),                                15, "member9", 9, &valueP, -5);        TEST_NO_FAULT(&env);    {        xmlrpc_int32 i;        xmlrpc_double d;        xmlrpc_bool b;        const char * dt_str;        const char * s1;        const char * s2;        size_t s2_len;        const unsigned char * b64;        size_t b64_len;        xmlrpc_value * arrayP;        xmlrpc_value * structP;        void * cptr;        xmlrpc_value * subvalP;        xmlrpc_parse_value(&env, valueP, "(idb8ss#6ASnpV)",                           &i, &d, &b, &dt_str, &s1, &s2, &s2_len,                           &b64, &b64_len,                           &arrayP, &structP, &cptr, &subvalP);                TEST_NO_FAULT(&env);        TEST(i == 7);        TEST(d == 3.14);        TEST(b == (xmlrpc_bool)1);        TEST(streq(dt_str, datestring));        TEST(streq(s1, "hello world"));        TEST(s2_len == 3);        TEST(memeq(s2, "a/0b", 3));        TEST(b64_len == strlen("base64 data"));        TEST(memeq(b64, "base64 data", b64_len));        TEST(XMLRPC_TYPE_ARRAY == xmlrpc_value_type(arrayP));        TEST(XMLRPC_TYPE_STRUCT == xmlrpc_value_type(structP));        TEST(cptr == &valueP);        TEST(XMLRPC_TYPE_ARRAY == xmlrpc_value_type(subvalP));        xmlrpc_DECREF(valueP);    }    testFailedParseValue();    xmlrpc_env_clean(&env);}