int TvDevicePowerOn(IXML_Document * in,IXML_Document **out,
const char **errorString)
{
(*out) = NULL;
(*errorString) = NULL;
char *value = NULL;
// Debug, add action to this
value = SampleUtil_GetFirstDocumentItem(in, "BinaryState");
if(NULL != value){
if(atoi(value)){
SampleUtil_Print("Luma Turned On!!\n");
}
else{
SampleUtil_Print("Luma Turned Off!!\n");
}
}
if (TvDeviceSetPower(POWER_ON)) {
/* create a response */
if (UpnpAddToActionResponse(out, "PowerOn",
TvServiceType[TV_SERVICE_CONTROL],
"Power", value) != UPNP_E_SUCCESS) {
//"Power", "1") != UPNP_E_SUCCESS) {
(*out) = NULL;
(*errorString) = "Internal Error";
return UPNP_E_INTERNAL_ERROR;
}
return UPNP_E_SUCCESS;
} else {
(*errorString) = "Internal Error";
return UPNP_E_INTERNAL_ERROR;
}
in = in;
}
/*****************************************************************************
* TvDeviceSetContrast
*
* Description:
* Change the contrast, update the TvDevice picture service
* state table, and notify all subscribed control points of the
* updated state.
*
* Parameters:
*
* IXML_Document * in - action request document
* IXML_Document **out - action result document
* char **errorString - errorString (in case action was unsuccessful)
*
****************************************************************************/
int TvDeviceSetContrast(IN IXML_Document *in, OUT IXML_Document **out,
OUT const char **errorString)
{
char *value = NULL;
int contrast = -1;
(*out) = NULL;
(*errorString) = NULL;
if (!(value = SampleUtil_GetFirstDocumentItem(in, "Contrast"))) {
(*errorString) = "Invalid Contrast";
return UPNP_E_INVALID_PARAM;
}
contrast = atoi(value);
if (contrast < MIN_CONTRAST || contrast > MAX_CONTRAST) {
SampleUtil_Print("error: can't change to contrast %d\n",
contrast);
(*errorString) = "Invalid Contrast";
return UPNP_E_INVALID_PARAM;
}
/* Vendor-specific code to set the volume goes here. */
if (TvDeviceSetServiceTableVar(TV_SERVICE_PICTURE,
TV_PICTURE_CONTRAST, value)) {
if (UpnpAddToActionResponse(out, "SetContrast",
TvServiceType[TV_SERVICE_PICTURE],
"NewContrast",
value) != UPNP_E_SUCCESS) {
(*out) = NULL;
(*errorString) = "Internal Error";
free(value);
return UPNP_E_INTERNAL_ERROR;
}
free(value);
return UPNP_E_SUCCESS;
} else {
free(value);
(*errorString) = "Internal Error";
return UPNP_E_INTERNAL_ERROR;
}
}
int TvDeviceSetChannel(IXML_Document * in, IXML_Document ** out,
const char **errorString)
{
char *value = NULL;
int channel = 0;
(*out) = NULL;
(*errorString) = NULL;
if (!(value = SampleUtil_GetFirstDocumentItem(in, "Channel"))) {
(*errorString) = "Invalid Channel";
return UPNP_E_INVALID_PARAM;
}
channel = atoi(value);
if (channel < MIN_CHANNEL || channel > MAX_CHANNEL) {
free(value);
SampleUtil_Print("error: can't change to channel %d\n",
channel);
(*errorString) = "Invalid Channel";
return UPNP_E_INVALID_PARAM;
}
/* Vendor-specific code to set the channel goes here. */
if (TvDeviceSetServiceTableVar(TV_SERVICE_CONTROL,
TV_CONTROL_CHANNEL, value)) {
if (UpnpAddToActionResponse(out, "SetChannel",
TvServiceType[TV_SERVICE_CONTROL],
"NewChannel",
value) != UPNP_E_SUCCESS) {
(*out) = NULL;
(*errorString) = "Internal Error";
free(value);
return UPNP_E_INTERNAL_ERROR;
}
free(value);
return UPNP_E_SUCCESS;
} else {
free(value);
(*errorString) = "Internal Error";
return UPNP_E_INTERNAL_ERROR;
}
}
int TvDeviceSetBrightness(IXML_Document * in, IXML_Document ** out,
const char **errorString)
{
char *value = NULL;
int brightness = -1;
(*out) = NULL;
(*errorString) = NULL;
if (!(value = SampleUtil_GetFirstDocumentItem(in, "Brightness"))) {
(*errorString) = "Invalid Brightness";
return UPNP_E_INVALID_PARAM;
}
brightness = atoi(value);
if (brightness < MIN_BRIGHTNESS || brightness > MAX_BRIGHTNESS) {
SampleUtil_Print("error: can't change to brightness %d\n",
brightness);
(*errorString) = "Invalid Brightness";
return UPNP_E_INVALID_PARAM;
}
/* Vendor-specific code to set the volume goes here. */
if (TvDeviceSetServiceTableVar(TV_SERVICE_PICTURE,
TV_PICTURE_BRIGHTNESS, value)) {
if (UpnpAddToActionResponse(out, "SetBrightness",
TvServiceType[TV_SERVICE_PICTURE],
"NewBrightness",
value) != UPNP_E_SUCCESS) {
(*out) = NULL;
(*errorString) = "Internal Error";
free(value);
return UPNP_E_INTERNAL_ERROR;
}
free(value);
return UPNP_E_SUCCESS;
} else {
free(value);
(*errorString) = "Internal Error";
return UPNP_E_INTERNAL_ERROR;
}
}
int TvDeviceSetVolume(IXML_Document * in, IXML_Document ** out,
const char **errorString)
{
char *value = NULL;
int volume = 0;
(*out) = NULL;
(*errorString) = NULL;
if (!(value = SampleUtil_GetFirstDocumentItem(in, "Volume"))) {
(*errorString) = "Invalid Volume";
return UPNP_E_INVALID_PARAM;
}
volume = atoi(value);
if (volume < MIN_VOLUME || volume > MAX_VOLUME) {
SampleUtil_Print("error: can't change to volume %d\n", volume);
(*errorString) = "Invalid Volume";
return UPNP_E_INVALID_PARAM;
}
/* Vendor-specific code to set the volume goes here. */
if (TvDeviceSetServiceTableVar(TV_SERVICE_CONTROL,
TV_CONTROL_VOLUME, value)) {
if (UpnpAddToActionResponse(out, "SetVolume",
TvServiceType[TV_SERVICE_CONTROL],
"NewVolume",
value) != UPNP_E_SUCCESS) {
(*out) = NULL;
(*errorString) = "Internal Error";
free(value);
return UPNP_E_INTERNAL_ERROR;
}
free(value);
return UPNP_E_SUCCESS;
} else {
free(value);
(*errorString) = "Internal Error";
return UPNP_E_INTERNAL_ERROR;
}
}
int TvDeviceStateTableInit(char *DescDocURL)
{
IXML_Document *DescDoc = NULL;
int ret = UPNP_E_SUCCESS;
char *servid_ctrl = NULL;
char *evnturl_ctrl = NULL;
char *ctrlurl_ctrl = NULL;
char *servid_pict = NULL;
char *evnturl_pict = NULL;
char *ctrlurl_pict = NULL;
char *udn = NULL;
/*Download description document */
if (UpnpDownloadXmlDoc(DescDocURL, &DescDoc) != UPNP_E_SUCCESS) {
SampleUtil_Print("TvDeviceStateTableInit -- Error Parsing %s\n",
DescDocURL);
ret = UPNP_E_INVALID_DESC;
goto error_handler;
}
udn = SampleUtil_GetFirstDocumentItem(DescDoc, "UDN");
/* Find the Tv Control Service identifiers */
if (!SampleUtil_FindAndParseService(DescDoc, DescDocURL,
TvServiceType[TV_SERVICE_CONTROL],
&servid_ctrl, &evnturl_ctrl,
&ctrlurl_ctrl)) {
SampleUtil_Print("TvDeviceStateTableInit -- Error: Could not find Service: %s\n",
TvServiceType[TV_SERVICE_CONTROL]);
ret = UPNP_E_INVALID_DESC;
goto error_handler;
}
/* set control service table */
SetServiceTable(TV_SERVICE_CONTROL, udn, servid_ctrl,
TvServiceType[TV_SERVICE_CONTROL],
&tv_service_table[TV_SERVICE_CONTROL]);
/* Find the Tv Picture Service identifiers */
if (!SampleUtil_FindAndParseService(DescDoc, DescDocURL,
TvServiceType[TV_SERVICE_PICTURE],
&servid_pict, &evnturl_pict,
&ctrlurl_pict)) {
SampleUtil_Print("TvDeviceStateTableInit -- Error: Could not find Service: %s\n",
TvServiceType[TV_SERVICE_PICTURE]);
ret = UPNP_E_INVALID_DESC;
goto error_handler;
}
/* set picture service table */
SetServiceTable(TV_SERVICE_PICTURE, udn, servid_pict,
TvServiceType[TV_SERVICE_PICTURE],
&tv_service_table[TV_SERVICE_PICTURE]);
error_handler:
/* clean up */
if (udn)
free(udn);
if (servid_ctrl)
free(servid_ctrl);
if (evnturl_ctrl)
free(evnturl_ctrl);
if (ctrlurl_ctrl)
free(ctrlurl_ctrl);
if (servid_pict)
free(servid_pict);
if (evnturl_pict)
free(evnturl_pict);
if (ctrlurl_pict)
free(ctrlurl_pict);
if (DescDoc)
ixmlDocument_free(DescDoc);
return (ret);
}
/********************************************************************************
* SampleUtil_FindAndParseService
*
* Description:
* This routine finds the first occurance of a service in a DOM representation
* of a description document and parses it.
*
* Parameters:
* DescDoc -- The DOM description document
* location -- The location of the description document
* serviceSearchType -- The type of service to search for
* serviceId -- OUT -- The service ID
* eventURL -- OUT -- The event URL for the service
* controlURL -- OUT -- The control URL for the service
*
********************************************************************************/
int
SampleUtil_FindAndParseService( IN IXML_Document * DescDoc,
IN char *location,
IN char *serviceType,
OUT char **serviceId,
OUT char **eventURL,
OUT char **controlURL )
{
int i,
length,
found = 0;
int ret;
char *tempServiceType = NULL;
char *baseURL = NULL;
char *base;
char *relcontrolURL = NULL,
*releventURL = NULL;
IXML_NodeList *serviceList = NULL;
IXML_Element *service = NULL;
baseURL = SampleUtil_GetFirstDocumentItem( DescDoc, "URLBase" );
if( baseURL )
base = baseURL;
else
base = location;
serviceList = SampleUtil_GetFirstServiceList( DescDoc );
length = ixmlNodeList_length( serviceList );
for( i = 0; i < length; i++ ) {
service = ( IXML_Element * ) ixmlNodeList_item( serviceList, i );
tempServiceType =
SampleUtil_GetFirstElementItem( ( IXML_Element * ) service,
"serviceType" );
if( strcmp( tempServiceType, serviceType ) == 0 ) {
SampleUtil_Print( "Found service: %s\n", serviceType );
*serviceId =
SampleUtil_GetFirstElementItem( service, "serviceId" );
SampleUtil_Print( "serviceId: %s\n", ( *serviceId ) );
relcontrolURL =
SampleUtil_GetFirstElementItem( service, "controlURL" );
releventURL =
SampleUtil_GetFirstElementItem( service, "eventSubURL" );
*controlURL =
malloc( strlen( base ) + strlen( relcontrolURL ) + 1 );
if( *controlURL ) {
ret = UpnpResolveURL( base, relcontrolURL, *controlURL );
if( ret != UPNP_E_SUCCESS )
SampleUtil_Print
( "Error generating controlURL from %s + %s\n",
base, relcontrolURL );
}
*eventURL =
malloc( strlen( base ) + strlen( releventURL ) + 1 );
if( *eventURL ) {
ret = UpnpResolveURL( base, releventURL, *eventURL );
if( ret != UPNP_E_SUCCESS )
SampleUtil_Print
( "Error generating eventURL from %s + %s\n", base,
releventURL );
}
if( relcontrolURL )
free( relcontrolURL );
if( releventURL )
free( releventURL );
relcontrolURL = releventURL = NULL;
found = 1;
break;
}
if( tempServiceType )
free( tempServiceType );
tempServiceType = NULL;
}
if( tempServiceType )
free( tempServiceType );
if( serviceList )
ixmlNodeList_free( serviceList );
if( baseURL )
free( baseURL );
return ( found );
}
/********************************************************************************
* TvCtrlPointAddDevice
*
* Description:
* If the device is not already included in the global device list,
* add it. Otherwise, update its advertisement expiration timeout.
*
* Parameters:
* DescDoc -- The description document for the device
* location -- The location of the description document URL
* expires -- The expiration time for this advertisement
*
********************************************************************************/
void TvCtrlPointAddDevice(
IXML_Document *DescDoc,
const char *location,
int expires)
{
char *deviceType = NULL;
char *friendlyName = NULL;
char presURL[200];
char *baseURL = NULL;
char *relURL = NULL;
char *UDN = NULL;
char *serviceId[TV_SERVICE_SERVCOUNT] = { NULL, NULL };
char *eventURL[TV_SERVICE_SERVCOUNT] = { NULL, NULL };
char *controlURL[TV_SERVICE_SERVCOUNT] = { NULL, NULL };
Upnp_SID eventSID[TV_SERVICE_SERVCOUNT];
int TimeOut[TV_SERVICE_SERVCOUNT] = {
default_timeout,
default_timeout
};
struct TvDeviceNode *deviceNode;
struct TvDeviceNode *tmpdevnode;
int ret = 1;
int found = 0;
int service;
int var;
ithread_mutex_lock(&DeviceListMutex);
/* Read key elements from description document */
UDN = SampleUtil_GetFirstDocumentItem(DescDoc, "UDN");
deviceType = SampleUtil_GetFirstDocumentItem(DescDoc, "deviceType");
friendlyName = SampleUtil_GetFirstDocumentItem(DescDoc, "friendlyName");
baseURL = SampleUtil_GetFirstDocumentItem(DescDoc, "URLBase");
relURL = SampleUtil_GetFirstDocumentItem(DescDoc, "presentationURL");
ret = UpnpResolveURL((baseURL ? baseURL : location), relURL, presURL);
if (UPNP_E_SUCCESS != ret)
SampleUtil_Print("Error generating presURL from %s + %s\n",
baseURL, relURL);
if (strcmp(deviceType, TvDeviceType) == 0) {
SampleUtil_Print("Found Tv device\n");
/* Check if this device is already in the list */
tmpdevnode = GlobalDeviceList;
while (tmpdevnode) {
if (strcmp(tmpdevnode->device.UDN, UDN) == 0) {
found = 1;
break;
}
tmpdevnode = tmpdevnode->next;
}
if (found) {
/* The device is already there, so just update */
/* the advertisement timeout field */
tmpdevnode->device.AdvrTimeOut = expires;
} else {
for (service = 0; service < TV_SERVICE_SERVCOUNT;
service++) {
if (SampleUtil_FindAndParseService
(DescDoc, location, TvServiceType[service],
&serviceId[service], &eventURL[service],
&controlURL[service])) {
SampleUtil_Print
("Subscribing to EventURL %s...\n",
eventURL[service]);
ret =
UpnpSubscribe(ctrlpt_handle,
eventURL[service],
&TimeOut[service],
eventSID[service]);
if (ret == UPNP_E_SUCCESS) {
SampleUtil_Print
("Subscribed to EventURL with SID=%s\n",
eventSID[service]);
} else {
SampleUtil_Print
("Error Subscribing to EventURL -- %d\n",
ret);
strcpy(eventSID[service], "");
}
} else {
SampleUtil_Print
("Error: Could not find Service: %s\n",
TvServiceType[service]);
}
}
/* Create a new device node */
deviceNode =
(struct TvDeviceNode *)
malloc(sizeof(struct TvDeviceNode));
strcpy(deviceNode->device.UDN, UDN);
strcpy(deviceNode->device.DescDocURL, location);
strcpy(deviceNode->device.FriendlyName, friendlyName);
strcpy(deviceNode->device.PresURL, presURL);
deviceNode->device.AdvrTimeOut = expires;
for (service = 0; service < TV_SERVICE_SERVCOUNT;
service++) {
strcpy(deviceNode->device.TvService[service].
ServiceId, serviceId[service]);
strcpy(deviceNode->device.TvService[service].
ServiceType, TvServiceType[service]);
strcpy(deviceNode->device.TvService[service].
ControlURL, controlURL[service]);
strcpy(deviceNode->device.TvService[service].
EventURL, eventURL[service]);
strcpy(deviceNode->device.TvService[service].
SID, eventSID[service]);
for (var = 0; var < TvVarCount[service]; var++) {
deviceNode->device.
TvService[service].VariableStrVal
[var] =
(char *)malloc(TV_MAX_VAL_LEN);
strcpy(deviceNode->device.
TvService[service].VariableStrVal
[var], "");
}
}
deviceNode->next = NULL;
/* Insert the new device node in the list */
if ((tmpdevnode = GlobalDeviceList)) {
while (tmpdevnode) {
if (tmpdevnode->next) {
tmpdevnode = tmpdevnode->next;
} else {
tmpdevnode->next = deviceNode;
break;
}
}
} else {
GlobalDeviceList = deviceNode;
}
/*Notify New Device Added */
SampleUtil_StateUpdate(NULL, NULL,
deviceNode->device.UDN,
DEVICE_ADDED);
}
}
ithread_mutex_unlock(&DeviceListMutex);
if (deviceType)
free(deviceType);
if (friendlyName)
free(friendlyName);
if (UDN)
free(UDN);
if (baseURL)
free(baseURL);
if (relURL)
free(relURL);
for (service = 0; service < TV_SERVICE_SERVCOUNT; service++) {
if (serviceId[service])
free(serviceId[service]);
if (controlURL[service])
free(controlURL[service]);
if (eventURL[service])
free(eventURL[service]);
}
}
int SampleUtil_FindAndParseService(IXML_Document *DescDoc, const char *location,
const char *serviceType, char **serviceId, char **eventURL, char **controlURL)
{
unsigned int i;
unsigned long length;
int found = 0;
int ret;
#ifdef OLD_FIND_SERVICE_CODE
#else /* OLD_FIND_SERVICE_CODE */
unsigned int sindex = 0;
#endif /* OLD_FIND_SERVICE_CODE */
char *tempServiceType = NULL;
char *baseURL = NULL;
const char *base = NULL;
char *relcontrolURL = NULL;
char *releventURL = NULL;
IXML_NodeList *serviceList = NULL;
IXML_Element *service = NULL;
baseURL = SampleUtil_GetFirstDocumentItem(DescDoc, "URLBase");
if (baseURL)
base = baseURL;
else
base = location;
#ifdef OLD_FIND_SERVICE_CODE
serviceList = SampleUtil_GetFirstServiceList(DescDoc);
#else /* OLD_FIND_SERVICE_CODE */
for (sindex = 0;
(serviceList = SampleUtil_GetNthServiceList(DescDoc , sindex)) != NULL;
sindex++) {
tempServiceType = NULL;
relcontrolURL = NULL;
releventURL = NULL;
service = NULL;
#endif /* OLD_FIND_SERVICE_CODE */
length = ixmlNodeList_length(serviceList);
for (i = 0; i < length; i++) {
service = (IXML_Element *)ixmlNodeList_item(serviceList, i);
tempServiceType = SampleUtil_GetFirstElementItem(
(IXML_Element *)service, "serviceType");
if (tempServiceType && strcmp(tempServiceType, serviceType) == 0) {
SampleUtil_Print("Found service: %s\n", serviceType);
*serviceId = SampleUtil_GetFirstElementItem(service, "serviceId");
SampleUtil_Print("serviceId: %s\n", *serviceId);
relcontrolURL = SampleUtil_GetFirstElementItem(service, "controlURL");
releventURL = SampleUtil_GetFirstElementItem(service, "eventSubURL");
*controlURL = (char *)malloc(strlen(base) + strlen(relcontrolURL) + 1);
if (*controlURL) {
ret = UpnpResolveURL(base, relcontrolURL, *controlURL);
if (ret != UPNP_E_SUCCESS)
SampleUtil_Print("Error generating controlURL from %s + %s\n",
base, relcontrolURL);
}
*eventURL = (char *)malloc(strlen(base) + strlen(releventURL) + 1);
if (*eventURL) {
ret = UpnpResolveURL(base, releventURL, *eventURL);
if (ret != UPNP_E_SUCCESS)
SampleUtil_Print("Error generating eventURL from %s + %s\n",
base, releventURL);
}
free(relcontrolURL);
free(releventURL);
relcontrolURL = NULL;
releventURL = NULL;
found = 1;
break;
}
free(tempServiceType);
tempServiceType = NULL;
}
free(tempServiceType);
tempServiceType = NULL;
if (serviceList)
ixmlNodeList_free(serviceList);
serviceList = NULL;
#ifdef OLD_FIND_SERVICE_CODE
#else /* OLD_FIND_SERVICE_CODE */
}
#endif /* OLD_FIND_SERVICE_CODE */
free(baseURL);
return found;
}
/********************************************************************************
* TvCtrlPointAddDevice
*
* Description:
* If the device is not already included in the global device list,
* add it. Otherwise, update its advertisement expiration timeout.
*
* Parameters:
* DescDoc -- The description document for the device
* location -- The location of the description document URL
* expires -- The expiration time for this advertisement
*
********************************************************************************/
void
TvCtrlPointAddDevice( IXML_Document * DescDoc,
char *location,
int expires )
{
char *cyber_action_name[TV_SERVICE_SERVCOUNT] = { NULL, NULL };
char *cyber_control_url[TV_SERVICE_SERVCOUNT] = { NULL, NULL };
char *deviceType = NULL;
char *friendlyName = NULL;
char presURL[200];
char *baseURL = NULL;
char *relURL = NULL;
char *UDN = NULL;
char *serviceId[TV_SERVICE_SERVCOUNT] = { NULL, NULL };
char *eventURL[TV_SERVICE_SERVCOUNT] = { NULL, NULL };
char *controlURL[TV_SERVICE_SERVCOUNT] = { NULL, NULL };
Upnp_SID eventSID[TV_SERVICE_SERVCOUNT];
int TimeOut[TV_SERVICE_SERVCOUNT] =
{ default_timeout, default_timeout };
struct TvDeviceNode *deviceNode;
struct TvDeviceNode *tmpdevnode;
int ret = 1;
int found = 0;
int service,
var;
printf("let go 0\n");
ithread_mutex_lock( &DeviceListMutex );
printf("let go 00\n");
/*
Read key elements from description document
*/
UDN = SampleUtil_GetFirstDocumentItem( DescDoc, "UDN" );
printf("UDN=%s\n",UDN);
printf("let go 000\n");
deviceType = SampleUtil_GetFirstDocumentItem( DescDoc, "deviceType" );
printf("deviceType=%s\n",deviceType);
printf("let go 0000\n");
friendlyName =
SampleUtil_GetFirstDocumentItem( DescDoc, "friendlyName" );
printf("friendlyName=%s\n",friendlyName);
printf("let go 00000\n");
//baseURL = SampleUtil_GetFirstDocumentItem( DescDoc, "URLBase" );//made by zdy
printf("let go 000000\n");
relURL = SampleUtil_GetFirstDocumentItem( DescDoc, "presentationURL" );
printf("relURL=%s\n",relURL);
printf("let go 1\n");
// ret =UpnpResolveURL( ( baseURL ? baseURL : location ), relURL,presURL );//made by zdy
//if( UPNP_E_SUCCESS != ret )
// printf( "Error generating presURL from %s + %s\n", baseURL,
// relURL );
if( strcmp( deviceType, TvDeviceType ) == 0 ) {
printf( "Found rounte device\n" );
// Check if this device is already in the list
tmpdevnode = GlobalDeviceList;
while( tmpdevnode ) {
if( strcmp( tmpdevnode->device.UDN, UDN ) == 0 ) {
found = 1;
break;
}
tmpdevnode = tmpdevnode->next;
}
printf("let go 2\n");
printf("found=%d\n",found);
if( found ) {
// The device is already there, so just update
// the advertisement timeout field
tmpdevnode->device.AdvrTimeOut = expires;
} else
{
// for( service = 0; service < TV_SERVICE_SERVCOUNT; service++ ) { //made by zdy
printf("let go 22222222****\n");
// /* made by zdy
if( CYBER_SampleUtil_FindAndParseService
( DescDoc, location, TvServiceType[service],
&serviceId[service], &eventURL[service],
&controlURL[service] ) )
// */
{
printf( "Subscribing to EventURL %s...",
eventURL[service] );
// eventURL[0]="http://192.168.0.1:1780/event?WANIPConnection";
// controlURL[0]="http://192.168.0.1:1780/control?WANIPConnection";
// cyber_action_name[0]="AddPortMapping";
// cyber_control_url[0]="http://192.168.0.1:1780/control?WANIPConnection";
//
ret =UpnpSubscribe( ctrlpt_handle, eventURL[service],&TimeOut[service],eventSID[service] );
if( ret == UPNP_E_SUCCESS ) {
printf
( "Subscribed to EventURL with SID=%s",
eventSID[service] );
} else {
printf
( "Error Subscribing to EventURL -- %d", ret );
strcpy( eventSID[service], "" );
}
}
// /*made by zdy
else
{
printf( "Error: Could not find Service: %s",
TvServiceType[service] );
}
// */
// }
/*
Create a new device node
*/
printf("let go 3\n");
/*
deviceNode =
( struct TvDeviceNode * )
malloc( sizeof( struct TvDeviceNode ) );
strcpy( deviceNode->device.UDN, UDN );
strcpy( deviceNode->device.DescDocURL, location );
strcpy( deviceNode->device.FriendlyName, friendlyName );
strcpy( deviceNode->device.PresURL, presURL );
deviceNode->device.AdvrTimeOut = expires;
printf("let go 4\n");
strcpy( deviceNode->device.TvService[service].ServiceId,
serviceId[service] );
printf("let go 5\n");
strcpy( deviceNode->device.TvService[service].ServiceType,
TvServiceType[service] );
printf("let go 6\n");
strcpy( deviceNode->device.TvService[service].ControlURL,
controlURL[service] );
printf("let go 7\n");
strcpy( deviceNode->device.TvService[service].EventURL,
eventURL[service] );
printf("let go 8\n");
strcpy( deviceNode->device.TvService[service].SID,
eventSID[service] );
*/
printf("let go 9\n");
ithread_mutex_unlock( &DeviceListMutex );
want_action=3;
if( ret == UPNP_E_SUCCESS ){ Cyber_Addmapport( 0,cyber_control_url[0],cyber_action_name[0],8 );};
printf("let go 6\n");
/*
if( deviceType )
free( deviceType );
if( friendlyName )
free( friendlyName );
if( UDN )
free( UDN );
if( baseURL )
free( baseURL );
if( relURL )
free( relURL );
if( serviceId[service] )
free( serviceId[service] );
if( controlURL[service] )
free( controlURL[service] );
if( eventURL[service] )
free( eventURL[service] );
*/
}
}
}
/********************************************************************************
* WscUPnPCPAddDevice
*
* Description:
* Add a new Wsc device into the wsc device list or just update its advertisement
* expiration timeout if it alreay exists in the list.
*
* Parameters:
* deviceType -- The device type want to add to the Device List
* d_event -- The "Upnp_Discovery" data
*
* Return:
* WSC_SYS_SUCCESS - if success
* other value - if failure
********************************************************************************/
int WscUPnPCPAddDevice(
IN char *deviceType,
IN struct Upnp_Discovery *d_event,
OUT unsigned int *outIPAddr)
{
IXML_Document *DescDoc = NULL, *scpdDescDoc = NULL;
char *deviceTypeStr = NULL, *friendlyName = NULL, *baseURL = NULL, *relURL = NULL, *UDN = NULL;
char presURL[200] = {0};
char *serviceId = NULL, *SCPDURL = NULL, *eventURL = NULL, *controlURL = NULL;
Upnp_SID eventSID;
struct upnpDeviceNode *newDeviceNode, *devNodePtr;
int ret = WSC_SYS_ERROR;
int found = 0;
int TimeOut = DEF_SUBSCRIPTION_TIMEOUT;
unsigned int ipAddr = 0;
unsigned short port = 0;
if(d_event->DestAddr != NULL)
{
ipAddr = (unsigned int)d_event->DestAddr->sin_addr.s_addr;
port = (unsigned short)d_event->DestAddr->sin_port;
*outIPAddr = ipAddr;
}
printf("%s():outIPAddr=0x%x!\n", __FUNCTION__, *outIPAddr);
if( !(strcmp(&HostDescURL[0], &d_event->Location[0])))
{
// DBGPRINTF(RT_DBG_INFO, "%s():Adver from LocalDev, ignore it!\n", __FUNCTION__);
goto done;
}
// Check if this device is already in the list
devNodePtr = WscDeviceList;
while (devNodePtr)
{
if((strcmp(devNodePtr->device.UDN, d_event->DeviceId) == 0)
&& (strcmp(devNodePtr->device.DescDocURL, d_event->Location) == 0))
{
found = 1;
break;
}
devNodePtr = devNodePtr->next;
}
if (found)
{
// Update the advertisement timeout field
// DBGPRINTF(RT_DBG_INFO, "Old device, just update the expires!\n");
devNodePtr->device.AdvrTimeOut = d_event->Expires;
devNodePtr->device.timeCount = 0;
} else {
DBGPRINTF(RT_DBG_INFO, "Adver from a new device!\n");
if((ret = UpnpDownloadXmlDoc(d_event->Location, &DescDoc)) != UPNP_E_SUCCESS){
DBGPRINTF(RT_DBG_ERROR, "Get device description failed from %s -- err=%d\n", d_event->Location, ret);
goto done;
}
/* Read key elements from description document */
UDN = SampleUtil_GetFirstDocumentItem(DescDoc, "UDN");
deviceTypeStr = SampleUtil_GetFirstDocumentItem(DescDoc, "deviceType");
friendlyName = SampleUtil_GetFirstDocumentItem(DescDoc, "friendlyName");
baseURL = SampleUtil_GetFirstDocumentItem(DescDoc, "URLBase");
relURL = SampleUtil_GetFirstDocumentItem(DescDoc, "presentationURL");
if((UDN == NULL) || (deviceTypeStr == NULL) || (friendlyName == NULL))
{
DBGPRINTF(RT_DBG_ERROR, "%s(): Get UDN failed!\n", __FUNCTION__);
goto done;
}
UpnpResolveURL((baseURL ? baseURL : d_event->Location), relURL, presURL);
if (SampleUtil_FindAndParseService(DescDoc, d_event->Location, WscServiceTypeStr,
&serviceId, &SCPDURL, &eventURL,&controlURL))
{
if (SCPDURL != NULL)
{
if ((ret = UpnpDownloadXmlDoc(SCPDURL, &scpdDescDoc)) != UPNP_E_SUCCESS)
{
DBGPRINTF(RT_DBG_ERROR, "Get service description failed from %s -- err=%d\n", SCPDURL, ret);
} else {
WscUPnPCPCheckService(scpdDescDoc);
free(scpdDescDoc);
}
}
if ((ret = UpnpSubscribe(WscCPHandle, eventURL, &TimeOut, eventSID)) != UPNP_E_SUCCESS)
{
DBGPRINTF(RT_DBG_ERROR, "Error Subscribing to EventURL(%s) -- %d\n", eventURL, ret);
goto done;
}
/* Create a new device node */
newDeviceNode = (struct upnpDeviceNode *)malloc(sizeof(struct upnpDeviceNode));
if (newDeviceNode == NULL) {
DBGPRINTF(RT_DBG_ERROR, "%s: create new wsc Device Node failed!\n", __FUNCTION__);
goto done;
}
memset(newDeviceNode, 0, sizeof(newDeviceNode));
newDeviceNode->device.services.StateVarVal[WSC_EVENT_WLANEVENT] = NULL;
newDeviceNode->device.services.StateVarVal[WSC_EVENT_APSTATUS] = NULL;
newDeviceNode->device.services.StateVarVal[WSC_EVENT_STASTATUS] = NULL;
strncpy(newDeviceNode->device.UDN, UDN, NAME_SIZE-1);
strncpy(newDeviceNode->device.DescDocURL, d_event->Location, NAME_SIZE-1);
strncpy(newDeviceNode->device.FriendlyName, friendlyName, NAME_SIZE-1);
strncpy(newDeviceNode->device.PresURL, presURL, NAME_SIZE-1);
newDeviceNode->device.AdvrTimeOut = d_event->Expires;
newDeviceNode->device.timeCount = 0;
newDeviceNode->device.ipAddr = ipAddr;
strncpy(newDeviceNode->device.services.ServiceType, WscServiceTypeStr, NAME_SIZE-1);
if (serviceId)
strncpy(newDeviceNode->device.services.ServiceId, serviceId, NAME_SIZE-1);
if (SCPDURL)
strncpy(newDeviceNode->device.services.SCPDURL, SCPDURL, NAME_SIZE-1);
if (eventURL)
strncpy(newDeviceNode->device.services.EventURL, eventURL, NAME_SIZE-1);
if (controlURL)
strncpy(newDeviceNode->device.services.ControlURL, controlURL, NAME_SIZE-1);
if (eventSID)
strncpy(newDeviceNode->device.services.SID, eventSID, NAME_SIZE-1);
newDeviceNode->next = NULL;
#if 0
for (var = 0; var < WSC_STATE_VAR_COUNT; var++)
{
deviceNode->device.services.serviceList.stateVarVals[var] = (char *)malloc(WSC_STATE_VAR_MAX_STR_LEN);
strcpy(deviceNode->device.services.serviceList.stateVarVals[var], "");
}
#endif
// Insert the new device node in the list
if(WscDeviceList)
{
newDeviceNode->next = WscDeviceList->next;
WscDeviceList->next = newDeviceNode;
} else {
WscDeviceList = newDeviceNode;
}
ret = WSC_SYS_SUCCESS;
// TODO:Notify New Device Added
//WscCPDevUpdate(NULL, NULL, deviceNode->device.UDN, DEVICE_ADDED);
} else {
DBGPRINTF(RT_DBG_ERROR, "Error: Could not find Service: %s\n", WscServiceTypeStr);
}
}
done:
if (DescDoc)
ixmlDocument_free(DescDoc);
if (UDN)
free(UDN);
if (deviceTypeStr)
free(deviceTypeStr);
if (friendlyName)
free(friendlyName);
if (baseURL)
free(baseURL);
if (relURL)
free(relURL);
if (serviceId)
free(serviceId);
if (controlURL)
free(controlURL);
if (eventURL)
free(eventURL);
return ret;
}
