/***********************************************************************//**
* @brief Register client at SAMP Hub
*
* @exception GException::invalid_value
* Unable to connect to Hub.
***************************************************************************/
void GVOClient::register_to_hub(void)
{
// Declare request
std::string request;
// Set metadata header
request.append("<?xml version=\"1.0\"?>\n");
request.append("<methodCall>\n");
request.append(" <methodName>samp.hub.register</methodName>\n");
request.append(" <params>\n");
request.append(" <param><value>"+m_secret+"</value></param>\n");
request.append(" </params>\n");
request.append("</methodCall>\n");
// Execute request
GXml xml = execute(request);
// If no error occured, extract hub and client identifiers
if (response_is_valid(xml)) {
m_client_key = get_response_value(xml, "samp.private-key");
m_hub_id = get_response_value(xml, "samp.hub-id");
m_client_id = get_response_value(xml, "samp.self-id");
}
// ... otherwise signal an error
else {
std::string msg = "Unable to connect to Hub (" +
response_error_message(xml) + ", code=" +
gammalib::str(response_error_code(xml)) + ").";
throw GException::runtime_error(G_REGISTER_TO_HUB, msg);
}
// Return
return;
}
/****************************************************************************
* Function : SoapGetServiceVarStatus
*
* Parameters :
* IN char * action_url : Address to send this variable
* query message.
* IN char *var_name : Name of the variable.
* OUT char **var_value : Output value.
*
* Description : This function creates a status variable query message
* send it to the specified URL. It also collect the response.
*
* Return : int
*
* Note :
****************************************************************************/
int
SoapGetServiceVarStatus( IN char *action_url,
IN char *var_name,
OUT char **var_value )
{
const memptr host; /* value for HOST header */
const memptr path; /* ctrl path in first line in msg */
uri_type url;
membuffer request;
int ret_code;
http_parser_t response;
int upnp_error_code;
off_t content_length;
const char *xml_start =
"<s:Envelope "
"xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\" "
"s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">\r\n"
"<s:Body>\r\n"
"<u:QueryStateVariable xmlns:u=\"urn:schemas-upnp-org:control-1-0\">\r\n"
"<u:varName>";
const char *xml_end =
"</u:varName>\r\n"
"</u:QueryStateVariable>\r\n"
"</s:Body>\r\n"
"</s:Envelope>\r\n";
*var_value = NULL; /* return NULL in case of an error */
membuffer_init( &request );
/* get host hdr and url path */
if( get_host_and_path( action_url, &host, &path, &url ) == -1 ) {
return UPNP_E_INVALID_URL;
}
/* make headers */
request.size_inc = 50;
content_length = (off_t)(strlen(xml_start) + strlen(var_name) +
strlen(xml_end));
if (http_MakeMessage(
&request, 1, 1,
"Q" "sbc" "N" "s" "sc" "Ucc" "sss",
SOAPMETHOD_POST, path.buf, path.length,
"HOST: ", host.buf, host.length,
content_length,
ContentTypeHeader,
"SOAPACTION: \"urn:schemas-upnp-org:control-1-0#QueryStateVariable\"",
xml_start, var_name, xml_end ) != 0 ) {
return UPNP_E_OUTOF_MEMORY;
}
/* send msg and get reply */
ret_code = soap_request_and_response( &request, &url, &response );
membuffer_destroy( &request );
if( ret_code != UPNP_E_SUCCESS ) {
return ret_code;
}
/* get variable value from the response */
ret_code = get_response_value( &response.msg, SOAP_VAR_RESP, NULL,
&upnp_error_code, NULL, var_value );
httpmsg_destroy( &response.msg );
if( ret_code == SOAP_VAR_RESP ) {
return UPNP_E_SUCCESS;
} else if( ret_code == SOAP_VAR_RESP_ERROR ) {
return upnp_error_code;
} else {
return ret_code;
}
}
/****************************************************************************
* Function : SoapSendActionEx
*
* Parameters :
* IN char* action_url : device contrl URL
* IN char *service_type : device service type
IN IXML_Document *Header: Soap header
* IN IXML_Document *action_node : SOAP action node ( SOAP body)
* OUT IXML_Document **response_node : SOAP response node
*
* Description : This function is called by UPnP API to send the SOAP
* action request and waits till it gets the response from the device
* pass the response to the API layer. This action is similar to the
* the SoapSendAction with only difference that it allows users to
* pass the SOAP header along the SOAP body ( soap action request)
*
* Return : int
* returns UPNP_E_SUCCESS if successful else returns appropriate error
* Note :
****************************************************************************/
int SoapSendActionEx(
IN char *action_url,
IN char *service_type,
IN IXML_Document * header,
IN IXML_Document * action_node,
OUT IXML_Document ** response_node )
{
char *xml_header_str = NULL;
char *action_str = NULL;
memptr name;
membuffer request;
membuffer responsename;
int err_code;
int ret_code;
http_parser_t response;
uri_type url;
int upnp_error_code;
char *upnp_error_str;
int got_response = FALSE;
const char *xml_start =
"<s:Envelope "
"xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\" "
"s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">\r\n";
const char *xml_header_start =
"<s:Header>\r\n";
const char *xml_header_end =
"</s:Header>\r\n";
const char *xml_body_start =
"<s:Body>";
const char *xml_end =
"</s:Body>\r\n"
"</s:Envelope>\r\n";
size_t xml_start_len;
size_t xml_header_start_len;
size_t xml_header_str_len;
size_t xml_header_end_len;
size_t xml_body_start_len;
size_t action_str_len;
size_t xml_end_len;
off_t content_length;
*response_node = NULL; /* init */
err_code = UPNP_E_OUTOF_MEMORY; /* default error */
UpnpPrintf( UPNP_INFO, SOAP, __FILE__, __LINE__,
"Inside SoapSendActionEx():" );
/* init */
membuffer_init( &request );
membuffer_init( &responsename );
/* header string */
xml_header_str = ixmlPrintNode( ( IXML_Node * ) header );
if( xml_header_str == NULL ) {
goto error_handler;
}
/* print action */
action_str = ixmlPrintNode( ( IXML_Node * ) action_node );
if( action_str == NULL ) {
goto error_handler;
}
/* get action name */
if( get_action_name( action_str, &name ) != 0 ) {
err_code = UPNP_E_INVALID_ACTION;
goto error_handler;
}
/* parse url */
if( http_FixStrUrl( action_url, strlen( action_url ), &url ) != 0 ) {
err_code = UPNP_E_INVALID_URL;
goto error_handler;
}
UpnpPrintf( UPNP_INFO, SOAP, __FILE__, __LINE__,
"path=%.*s, hostport=%.*s\n",
(int)url.pathquery.size,
url.pathquery.buff,
(int)url.hostport.text.size,
url.hostport.text.buff );
xml_start_len = strlen( xml_start );
xml_body_start_len = strlen( xml_body_start );
xml_end_len = strlen( xml_end );
action_str_len = strlen( action_str );
xml_header_start_len = strlen( xml_header_start );
xml_header_end_len = strlen( xml_header_end );
xml_header_str_len = strlen( xml_header_str );
/* make request msg */
request.size_inc = 50;
content_length = (off_t)(xml_start_len + xml_header_start_len +
xml_header_str_len + xml_header_end_len +
xml_body_start_len + action_str_len + xml_end_len);
if (http_MakeMessage(
&request, 1, 1,
"q" "N" "s" "sssbsc" "Uc" "b" "b" "b" "b" "b" "b" "b",
SOAPMETHOD_POST, &url,
content_length,
ContentTypeHeader,
"SOAPACTION: \"", service_type, "#", name.buf, name.length, "\"",
xml_start, xml_start_len,
xml_header_start, xml_header_start_len,
xml_header_str, xml_header_str_len,
xml_header_end, xml_header_end_len,
xml_body_start, xml_body_start_len,
action_str, action_str_len,
xml_end, xml_end_len ) != 0 ) {
goto error_handler;
}
ret_code = soap_request_and_response( &request, &url, &response );
got_response = TRUE;
if( ret_code != UPNP_E_SUCCESS ) {
err_code = ret_code;
goto error_handler;
}
if( membuffer_append( &responsename, name.buf, name.length ) != 0 ||
membuffer_append_str( &responsename, "Response" ) != 0 ) {
goto error_handler;
}
/* get action node from the response */
ret_code = get_response_value( &response.msg, SOAP_ACTION_RESP,
responsename.buf, &upnp_error_code,
( IXML_Node ** ) response_node,
&upnp_error_str );
if( ret_code == SOAP_ACTION_RESP ) {
err_code = UPNP_E_SUCCESS;
} else if( ret_code == SOAP_ACTION_RESP_ERROR ) {
err_code = upnp_error_code;
} else {
err_code = ret_code;
}
error_handler:
ixmlFreeDOMString( action_str );
ixmlFreeDOMString( xml_header_str );
membuffer_destroy( &request );
membuffer_destroy( &responsename );
if( got_response ) {
httpmsg_destroy( &response.msg );
}
return err_code;
}