int BoxAutoAppdenPage(HBOX HBox)
{
if (HBox&&ItemGetFather(HBox))
{
HPAGE MidHPage;
Pages *MidPage;
TextBoxs *TextBox1,*TextBox2;
MidPage=HandleLock(ItemGetHandle(ItemGetFather(HBox)));
if (MidPage==NULL)
return(OUTOFMEMORY);
MidHPage=PageNew(MidPage,PageHandleToNumber(ItemGetFather(HBox))+1);
HandleUnlock(ItemGetHandle(ItemGetFather(HBox)));
TextBox1=HandleLock(ItemGetHandle(HBox));
if (TextBox1==NULL)
return(OUTOFMEMORY);
TextBox2=HandleLock(ItemGetHandle(ItemGetChild(MidHPage)));
if (TextBox2==NULL)
{
HandleUnlock(ItemGetHandle(HBox));
return(OUTOFMEMORY);
}
TextBoxSetNextLinkBox(TextBox1,ItemGetChild(MidHPage));
TextBoxSetPrevLinkBox(TextBox2,HBox);
SetAllLinkBoxTextHandle(HBox);
TextBoxInitialLineTable(TextBox2);
HandleUnlock(ItemGetHandle(ItemGetChild(MidHPage)));
HandleUnlock(ItemGetHandle(HBox));
}
ReturnOK();
}
void gena_process_unsubscribe_request(
SOCKINFO *info,
http_message_t *request)
{
Upnp_SID sid;
service_info *service;
struct Handle_Info *handle_info;
UpnpDevice_Handle device_handle;
memptr temp_hdr;
membuffer event_url_path;
/* if a CALLBACK or NT header is present, then it is an error */
if( httpmsg_find_hdr( request, HDR_CALLBACK, NULL ) != NULL ||
httpmsg_find_hdr( request, HDR_NT, NULL ) != NULL ) {
error_respond( info, HTTP_BAD_REQUEST, request );
return;
}
/* get SID */
if( httpmsg_find_hdr( request, HDR_SID, &temp_hdr ) == NULL ||
temp_hdr.length > SID_SIZE ) {
error_respond( info, HTTP_PRECONDITION_FAILED, request );
return;
}
memcpy( sid, temp_hdr.buf, temp_hdr.length );
sid[temp_hdr.length] = '\0';
/* lookup service by eventURL */
membuffer_init( &event_url_path );
if( membuffer_append( &event_url_path, request->uri.pathquery.buff,
request->uri.pathquery.size ) != 0 ) {
error_respond( info, HTTP_INTERNAL_SERVER_ERROR, request );
return;
}
HandleLock();
if( GetDeviceHandleInfoForPath(event_url_path.buf, info->foreign_sockaddr.ss_family,
&device_handle, &handle_info, &service) != HND_DEVICE ) {
error_respond( info, HTTP_PRECONDITION_FAILED, request );
membuffer_destroy( &event_url_path );
HandleUnlock();
return;
}
membuffer_destroy( &event_url_path );
/* validate service */
if( service == NULL ||
!service->active || GetSubscriptionSID( sid, service ) == NULL )
{
error_respond( info, HTTP_PRECONDITION_FAILED, request );
HandleUnlock();
return;
}
RemoveSubscriptionSID(sid, service);
error_respond(info, HTTP_OK, request); /* success */
HandleUnlock();
}
int ClipBoardInsertImage(HPICTUREBOX HBox,char InsertSign)
/* InsertSign: 0 -- Not first insert, 1 -- First insert */
{
PictureBoxs *PictureBox;
ImageDescribes *TiffPresent;
InsertImages InsertImage;
PictureBox=HandleLock(ItemGetHandle(HBox));
if (PictureBox==NULL)
return(OUTOFMEMORY);
if (!PictureBoxGetPictureFileName(PictureBox)[0])
{
HandleUnlock(ItemGetHandle(HBox));
return(0);
}
if (InsertSign)
ClipBoardInsert(sizeof(ClipBoards)+sizeof(InsertImages));
TiffPresent=&(PictureBoxGetPicturePresent(PictureBox));
strcpy(InsertImage.InsertFileName,PictureBoxGetPictureFileName(PictureBox));
memcpy(&InsertImage.InsertPresent,TiffPresent,sizeof(*TiffPresent));
HandleUnlock(ItemGetHandle(HBox));
return( ClipBoardAppend(&InsertImage,sizeof(InsertImages),IMAGEDATA) );
}
/*!
* \brief This is a thread function to send the renewal just before the
* subscription times out.
*/
static void GenaAutoRenewSubscription(
/*! [in] Thread data(upnp_timeout *) needed to send the renewal. */
IN void *input)
{
upnp_timeout *event = (upnp_timeout *) input;
struct Upnp_Event_Subscribe *sub_struct = (struct Upnp_Event_Subscribe *)event->Event;
void *cookie;
Upnp_FunPtr callback_fun;
struct Handle_Info *handle_info;
int send_callback = 0;
int eventType = 0;
int timeout = 0;
int errCode = 0;
UpnpString *tmpSID = UpnpString_new();
if (AUTO_RENEW_TIME == 0) {
UpnpPrintf( UPNP_INFO, GENA, __FILE__, __LINE__, "GENA SUB EXPIRED");
sub_struct->ErrCode = UPNP_E_SUCCESS;
send_callback = 1;
eventType = UPNP_EVENT_SUBSCRIPTION_EXPIRED;
} else {
UpnpPrintf(UPNP_INFO, GENA, __FILE__, __LINE__, "GENA AUTO RENEW");
timeout = sub_struct->TimeOut;
UpnpString_set_String(tmpSID, sub_struct->Sid);
errCode = genaRenewSubscription(
event->handle,
tmpSID,
&timeout);
sub_struct->ErrCode = errCode;
sub_struct->TimeOut = timeout;
if (errCode != UPNP_E_SUCCESS &&
errCode != GENA_E_BAD_SID &&
errCode != GENA_E_BAD_HANDLE) {
send_callback = 1;
eventType = UPNP_EVENT_AUTORENEWAL_FAILED;
}
}
if (send_callback) {
HandleReadLock();
if( GetHandleInfo( event->handle, &handle_info ) != HND_CLIENT ) {
HandleUnlock();
free_upnp_timeout(event);
goto end_function;
}
UpnpPrintf(UPNP_INFO, GENA, __FILE__, __LINE__, "HANDLE IS VALID");
/* make callback */
callback_fun = handle_info->Callback;
cookie = handle_info->Cookie;
HandleUnlock();
callback_fun(eventType, event->Event, cookie);
}
free_upnp_timeout(event);
end_function:
UpnpString_delete(tmpSID);
return;
}
int ClipBoardInsertText(HTEXTBOX HBox,int BlockStart,int BlockEnd,char InsertSign)
/* InsertSign: 0 -- Not first insert, 1 -- First insert */
{
Wchar *TextBlock;
int Result,Length;
TextBoxs *TextBox;
Length=BlockEnd-BlockStart;
if(Length<=0) // ByHance
ReturnOK();
if (InsertSign)
ClipBoardInsert(Length*sizeof(Wchar)+sizeof(ClipBoards));
TextBox=HandleLock(ItemGetHandle(HBox));
if (TextBox==NULL)
return(OUTOFMEMORY);
if (TextBoxGetTextHandle(TextBox))
{
TextBlock=HandleLock(TextBoxGetTextHandle(TextBox));
if (TextBlock==NULL)
{
HandleUnlock(ItemGetHandle(HBox));
return(OUTOFMEMORY);
}
Result=ClipBoardAppend(TextBlock+BlockStart,Length*sizeof(Wchar),TEXTDATA);
HandleUnlock(ItemGetHandle(HBox));
return(Result);
}
else
ReturnOK();
}
int ClipBoardInsertBox(HBOX HBox,char InsertSign)
/* InsertSign: 0 -- Not first insert, 1 -- First insert */
{
TextBoxs *TextBox;
int Result;
int *PolygonEdgeNumber;
TextBox=HandleLock(ItemGetHandle(HBox));
if (InsertSign)
{
Result=ClipBoardSizeofBox(HBox);
if (Result<=0)
{
HandleUnlock(ItemGetHandle(HBox));
return(Result);
}
else
ClipBoardInsert(Result);
}
if (TextBoxGetBoxType(TextBox)==TEXTBOX)
{
Result=ClipBoardAppend(TextBox,sizeof(TextBoxs),BOXDATA);
if (Result<0)
{
HandleUnlock(ItemGetHandle(HBox));
return(Result);
}
if (!TextBoxGetPrevLinkBox(TextBox))
{
Result=ClipBoardInsertText(HBox,0,TextBoxGetTextLength(TextBox),0);
}
}
else if ((TextBoxGetBoxType(TextBox)>=RECTANGLEPICTUREBOX)&&
(TextBoxGetBoxType(TextBox)<=POLYGONPICTUREBOX))
{
Result=ClipBoardAppend(TextBox,sizeof(PictureBoxs),BOXDATA);
if (Result<0)
{
HandleUnlock(ItemGetHandle(HBox));
return(Result);
}
if (TextBoxGetBoxType(TextBox)==POLYGONPICTUREBOX)
{
PolygonEdgeNumber=HandleLock(PictureBoxGetBorderPolygon(TextBox));
if (PolygonEdgeNumber!=NULL)
{
Result=sizeof(int)+sizeof(ORDINATETYPE)*2*(*PolygonEdgeNumber);
ClipBoardAppend(PolygonEdgeNumber,Result,POLYGONDATA);
HandleUnlock(PictureBoxGetBorderPolygon(TextBox));
}
}
}
HandleUnlock(ItemGetHandle(HBox));
return(Result);
}
/************************************************************************
* Function : GenaAutoRenewSubscription
*
* Parameters:
* IN void *input: Thread data(upnp_timeout *) needed to send the renewal
*
* Description:
* This is a thread function to send the renewal just before the
* subscription times out.
*
* Returns: VOID
*
***************************************************************************/
static void
GenaAutoRenewSubscription( IN void *input )
{
upnp_timeout *event = ( upnp_timeout * ) input;
void *cookie;
Upnp_FunPtr callback_fun;
struct Handle_Info *handle_info;
struct Upnp_Event_Subscribe *sub_struct =
( struct Upnp_Event_Subscribe * )
event->Event;
int send_callback = 0;
int eventType = 0;
if( AUTO_RENEW_TIME == 0 ) {
DBGONLY( UpnpPrintf( UPNP_INFO, GENA, __FILE__, __LINE__,
"GENA SUB EXPIRED" ) );
sub_struct->ErrCode = UPNP_E_SUCCESS;
send_callback = 1;
eventType = UPNP_EVENT_SUBSCRIPTION_EXPIRED;
} else {
DBGONLY( UpnpPrintf( UPNP_INFO, GENA, __FILE__, __LINE__,
"GENA AUTO RENEW" ) );
if( ( ( sub_struct->ErrCode = genaRenewSubscription( event->handle,
sub_struct->
Sid,
&sub_struct->
TimeOut ) ) !=
UPNP_E_SUCCESS )
&& ( sub_struct->ErrCode != GENA_E_BAD_SID )
&& ( sub_struct->ErrCode != GENA_E_BAD_HANDLE ) ) {
send_callback = 1;
eventType = UPNP_EVENT_AUTORENEWAL_FAILED;
}
}
if( send_callback ) {
HandleLock( );
if( GetHandleInfo( event->handle, &handle_info ) != HND_CLIENT ) {
HandleUnlock( );
free_upnp_timeout( event );
return;
}
DBGONLY( UpnpPrintf( UPNP_INFO, GENA, __FILE__, __LINE__,
"HANDLE IS VALID" ) );
callback_fun = handle_info->Callback;
cookie = handle_info->Cookie;
HandleUnlock( );
//make callback
callback_fun( eventType, event->Event, cookie );
}
free_upnp_timeout( event );
}
/************************************************************************
* Function : genaUnSubscribe
*
* Parameters:
* IN UpnpClient_Handle client_handle: UPnP client handle
* IN SID in_sid: The subscription ID
*
* Description:
* This function unsubscribes a SID. It first validates the SID and
* client_handle,copies the subscription, sends UNSUBSCRIBE http request
* to service processes request and finally removes the subscription
*
* Returns: int
* return UPNP_E_SUCCESS if service response is OK else
* returns appropriate error
***************************************************************************/
int
genaUnSubscribe( IN UpnpClient_Handle client_handle,
IN const Upnp_SID in_sid )
{
client_subscription *sub;
int return_code = GENA_SUCCESS;
struct Handle_Info *handle_info;
client_subscription sub_copy;
http_parser_t response;
HandleLock( );
// validate handle and sid
if( GetHandleInfo( client_handle, &handle_info ) != HND_CLIENT ) {
HandleUnlock( );
return GENA_E_BAD_HANDLE;
}
if( ( sub =
GetClientSubClientSID( handle_info->ClientSubList, in_sid ) )
== NULL ) {
HandleUnlock( );
return GENA_E_BAD_SID;
}
return_code = copy_client_subscription( sub, &sub_copy );
HandleUnlock( );
return_code = gena_unsubscribe( sub_copy.EventURL, sub_copy.ActualSID,
&response );
if( return_code == 0 ) {
httpmsg_destroy( &response.msg );
}
free_client_subscription( &sub_copy );
HandleLock( );
if( GetHandleInfo( client_handle, &handle_info ) != HND_CLIENT ) {
HandleUnlock( );
return GENA_E_BAD_HANDLE;
}
RemoveClientSubClientSID( &handle_info->ClientSubList, in_sid );
HandleUnlock( );
return return_code;
}
/************************************************************************
* Function : searchExpired
*
* Parameters:
* IN void * arg:
*
* Description:
* This function
*
* Returns: void
*
***************************************************************************/
void
searchExpired( void *arg )
{
int *id = ( int * )arg;
int handle = -1;
struct Handle_Info *ctrlpt_info = NULL;
//remove search Target from list and call client back
ListNode *node = NULL;
SsdpSearchArg *item;
Upnp_FunPtr ctrlpt_callback;
void *cookie = NULL;
int found = 0;
HandleLock( );
//remove search target from search list
if( GetClientHandleInfo( &handle, &ctrlpt_info ) != HND_CLIENT ) {
free( id );
HandleUnlock( );
return;
}
ctrlpt_callback = ctrlpt_info->Callback;
node = ListHead( &ctrlpt_info->SsdpSearchList );
while( node != NULL ) {
item = ( SsdpSearchArg * ) node->item;
if( item->timeoutEventId == ( *id ) ) {
free( item->searchTarget );
cookie = item->cookie;
found = 1;
item->searchTarget = NULL;
free( item );
ListDelNode( &ctrlpt_info->SsdpSearchList, node, 0 );
break;
}
node = ListNext( &ctrlpt_info->SsdpSearchList, node );
}
HandleUnlock( );
if( found ) {
ctrlpt_callback( UPNP_DISCOVERY_SEARCH_TIMEOUT, NULL, cookie );
}
free( id );
}
void ChangePageSetup(Pages *OldPage)
{
ORDINATETYPE left,right,top,bottom,width,height,newx,newy,neww,newh;
HPAGE HPage;
HBOX HBox;
TextBoxs *MidBox;
int i;
left=OldPage->MarginLeft;
top=OldPage->MarginTop;
right=OldPage->MarginRight;
bottom=OldPage->MarginBottom;
width=OldPage->PageWidth - left - right;
height=OldPage->PageHeight - top - bottom;
newx=TmpPage.MarginLeft;
newy=TmpPage.MarginTop;
neww=TmpPage.PageWidth-(TmpPage.MarginLeft+TmpPage.MarginRight);
newh=TmpPage.PageHeight-(TmpPage.MarginTop+TmpPage.MarginBottom);
for (i=0;i<TotalPage;i++)
{
HPage=PageNumberToHandle(i);
HBox=PageGetBoxHead(HPage);
while (HBox)
{
MidBox=HandleLock(ItemGetHandle(HBox));
if (MidBox==NULL)
return;
if( TextBoxGetBoxType(MidBox)==TEXTBOX && TextBoxDependPage(MidBox) )
{
if(MidBox->BoxLeft==left && MidBox->BoxTop ==top
&& MidBox->BoxWidth ==width && MidBox->BoxHeight==height )
{ // find the box, now, change it
MidBox->BoxLeft=newx;
MidBox->BoxTop=newy;
MidBox->BoxWidth=neww;
MidBox->BoxHeight=newh;
BoxChangeAll(HPage);
}
HandleUnlock(ItemGetHandle(HBox));
break; // only 1 depend_box in a page, so, goto next page
}
HandleUnlock(ItemGetHandle(HBox));
HBox=ItemGetNext(HBox);
}
} //--- i ---
}
int GetFontUse(unsigned char *UseStatusArray)
{
HPAGE MidPage;
HBOX HBox;
TextBoxs *TextBox;
Wchar *TextBlock,KeyAttribute;
HANDLE TextHandle;
int i;
MemSet(UseStatusArray,0,MAXFONTNUMBER);
MidPage=ItemGetChild(GlobalPageHeadHandle);
while (MidPage)
{
HBox=PageGetBoxHead(MidPage);
while (HBox)
{
TextBox=HandleLock(ItemGetHandle(HBox));
if (TextBox==NULL)
return(OUTOFMEMORY);
if ((TextBoxGetBoxType(TextBox)==TEXTBOX
||TextBoxGetBoxType(TextBox)==TABLEBOX)
&&!TextBoxGetPrevLinkBox(TextBox))
{
TextHandle=TextBoxGetTextHandle(TextBox);
if (TextHandle!=0)
{
TextBlock=HandleLock(TextHandle);
if (TextBlock==NULL)
{
HandleUnlock(ItemGetHandle(HBox));
return(OUTOFMEMORY);
}
i=TextBoxGetBlockLength(TextBox);
while (i>=0)
{
KeyAttribute=EditBufferSearchAttribute(TextBlock,i,CHARFONT,&i);
if (i>0)
UseStatusArray[KeyAttribute]=1;
}
HandleUnlock(TextHandle);
}
}
HandleUnlock(ItemGetHandle(HBox));
HBox=ItemGetNext(HBox);
}
MidPage=ItemGetNext(MidPage);
}
ReturnOK();
}
int genaUnSubscribe(
UpnpClient_Handle client_handle,
const UpnpString *in_sid)
{
ClientSubscription *sub = NULL;
int return_code = GENA_SUCCESS;
struct Handle_Info *handle_info;
ClientSubscription *sub_copy = UpnpClientSubscription_new();
http_parser_t response;
/* validate handle and sid */
HandleLock();
if (GetHandleInfo(client_handle, &handle_info) != HND_CLIENT) {
HandleUnlock();
return_code = GENA_E_BAD_HANDLE;
goto exit_function;
}
sub = GetClientSubClientSID(handle_info->ClientSubList, in_sid);
if (sub == NULL) {
HandleUnlock();
return_code = GENA_E_BAD_SID;
goto exit_function;
}
UpnpClientSubscription_assign(sub_copy, sub);
HandleUnlock();
return_code = gena_unsubscribe(
UpnpClientSubscription_get_EventURL(sub_copy),
UpnpClientSubscription_get_ActualSID(sub_copy),
&response);
if (return_code == 0) {
httpmsg_destroy(&response.msg);
}
free_client_subscription(sub_copy);
HandleLock();
if (GetHandleInfo(client_handle, &handle_info) != HND_CLIENT) {
HandleUnlock();
return_code = GENA_E_BAD_HANDLE;
goto exit_function;
}
RemoveClientSubClientSID(&handle_info->ClientSubList, in_sid);
HandleUnlock();
exit_function:
UpnpClientSubscription_delete(sub_copy);
return return_code;
}
void ItemFinish(void)
{
if (GlobalItemsHandle)
{
HandleUnlock(GlobalItemsHandle);
HandleFree(GlobalItemsHandle);
}
}
/************************************************************************
* Function : genaUnregisterClient
*
* Parameters:
* IN UpnpClient_Handle client_handle: Handle containing all the control
* point related information
*
* Description:
* This function unsubcribes all the outstanding subscriptions and cleans
* the subscription list. This function is called when control point
* unregisters.
*
* Returns: int
* return UPNP_E_SUCCESS if successful else returns appropriate error
***************************************************************************/
int
genaUnregisterClient( IN UpnpClient_Handle client_handle )
{
client_subscription sub_copy;
int return_code = UPNP_E_SUCCESS;
struct Handle_Info *handle_info = NULL;
http_parser_t response;
while( TRUE ) {
HandleLock( );
if( GetHandleInfo( client_handle, &handle_info ) != HND_CLIENT ) {
HandleUnlock( );
return GENA_E_BAD_HANDLE;
}
if( handle_info->ClientSubList == NULL ) {
return_code = UPNP_E_SUCCESS;
break;
}
return_code = copy_client_subscription( handle_info->ClientSubList,
&sub_copy );
if( return_code != HTTP_SUCCESS ) {
break;
}
RemoveClientSubClientSID( &handle_info->ClientSubList,
sub_copy.sid );
HandleUnlock( );
return_code = gena_unsubscribe( sub_copy.EventURL,
sub_copy.ActualSID, &response );
if( return_code == 0 ) {
httpmsg_destroy( &response.msg );
}
free_client_subscription( &sub_copy );
}
freeClientSubList( handle_info->ClientSubList );
HandleUnlock( );
return return_code;
}
int genaUnregisterClient(UpnpClient_Handle client_handle)
{
ClientSubscription *sub_copy = UpnpClientSubscription_new();
int return_code = UPNP_E_SUCCESS;
struct Handle_Info *handle_info = NULL;
http_parser_t response;
while (TRUE) {
HandleLock();
if (GetHandleInfo(client_handle, &handle_info) != HND_CLIENT) {
HandleUnlock();
return_code = GENA_E_BAD_HANDLE;
goto exit_function;
}
if (handle_info->ClientSubList == NULL) {
return_code = UPNP_E_SUCCESS;
break;
}
UpnpClientSubscription_assign(sub_copy, handle_info->ClientSubList);
RemoveClientSubClientSID(
&handle_info->ClientSubList,
UpnpClientSubscription_get_SID(sub_copy));
HandleUnlock();
return_code = gena_unsubscribe(
UpnpClientSubscription_get_EventURL(sub_copy),
UpnpClientSubscription_get_ActualSID(sub_copy),
&response);
if (return_code == 0) {
httpmsg_destroy(&response.msg);
}
free_client_subscription(sub_copy);
}
freeClientSubList(handle_info->ClientSubList);
HandleUnlock();
exit_function:
UpnpClientSubscription_delete(sub_copy);
return return_code;
}
void SaveFontPath(void)
{
LPVECFNT Lpvfnt;
if ((Lpvfnt=HandleLock(cfnHandle))==NULL)
return;
if ((SysDc.lpttf=HandleLock(efnHandle))==NULL)
{
HandleUnlock(cfnHandle);
return;
}
strcpy (Lpvfnt->cfnPath,VectLibPath);
strcpy (SysDc.lpttf->ttPath,TrueTypeLibPath);
SetProfileString( ProfileName,InitSection, VectLibPathEntry,VectLibPath);
SetProfileString( ProfileName,InitSection, TrueTypeLibPathEntry,TrueTypeLibPath);
HandleUnlock(cfnHandle);
HandleUnlock(efnHandle);
}
int GetUserFrame(int Pa,int *w,int *h)
{
Pages *Mid;
HPAGE pp;
pp=PageNumberToHandle(Pa);
Mid=HandleLock(ItemGetHandle(pp));
*w=PageGetPageWidth(Mid); //By zjh 96.9.7
*h=PageGetPageHeight(Mid); //By zjh 96.9.7
HandleUnlock(ItemGetHandle(pp));
return 0;
}
static int ClipBoardSizeofBox(HBOX HBox)
{
TextBoxs *TextBox;
int Length;
int *PolygonEdgeNumber;
TextBox=HandleLock(ItemGetHandle(HBox));
if (TextBox==NULL)
return(OUTOFMEMORY);
if (TextBoxGetBoxType(TextBox)==TEXTBOX)
{
Length=sizeof(ClipBoards)+sizeof(TextBoxs);
if (!TextBoxGetPrevLinkBox(TextBox))
Length+=sizeof(ClipBoards)+sizeof(Wchar)*TextBoxGetTextLength(TextBox);
}
else if ((TextBoxGetBoxType(TextBox)>=RECTANGLEPICTUREBOX)&&
(TextBoxGetBoxType(TextBox)<=POLYGONPICTUREBOX))
{
Length=sizeof(ClipBoards)+sizeof(PictureBoxs);
if (TextBoxGetBoxType(TextBox)==POLYGONPICTUREBOX)
{
PolygonEdgeNumber=HandleLock(PictureBoxGetBorderPolygon(TextBox));
if (PolygonEdgeNumber!=NULL)
{
Length+=sizeof(ClipBoards)+sizeof(int)+
sizeof(ORDINATETYPE)*2*(*PolygonEdgeNumber);
HandleUnlock(PictureBoxGetBorderPolygon(TextBox));
}
}
if (PictureBoxGetPictureFileName(TextBox)[0])
Length+=sizeof(ClipBoards)+sizeof(InsertImages);
}
HandleUnlock(ItemGetHandle(HBox));
return(Length);
}
static void ClipBoardGet(void *GetClipboardData,int *DataLength,char *DataType)
{
char *ClipBoardData;
ClipBoardData=HandleLock(GlobalClipBoardHandle);
if (ClipBoardData==NULL)
return;
*DataType=((ClipBoards *)&ClipBoardData[GlobalClipBoardReadLength])->ClipBoardDataType;
*DataLength=((ClipBoards *)&ClipBoardData[GlobalClipBoardReadLength])->ClipBoardDataLength;
memcpy(GetClipboardData,
&ClipBoardData[GlobalClipBoardReadLength+sizeof(ClipBoards)],
*DataLength);
GlobalClipBoardReadLength+=*DataLength+sizeof(ClipBoards);
HandleUnlock(GlobalClipBoardHandle);
}
void ClipBoardGetDataInfomation(ClipBoards *ClipBoardDataInformation)
{
char *ClipBoardData;
if (!ClipBoardHasData())
{
err_exit:
ClipBoardDataInformation->ClipBoardDataType=0;
ClipBoardDataInformation->ClipBoardDataLength=0;
return;
}
ClipBoardData=HandleLock(GlobalClipBoardHandle);
if (ClipBoardData==NULL)
{
HandleUnlock(GlobalClipBoardHandle);
goto err_exit;
}
memcpy(ClipBoardDataInformation,&ClipBoardData[GlobalClipBoardReadLength],
sizeof(ClipBoards));
HandleUnlock(GlobalClipBoardHandle);
return;
}
int ClipBoardAppend(void *AppendData,int DataLength,char DataType)
{
char *ClipBoardData;
ClipBoardData=HandleLock(GlobalClipBoardHandle);
if (ClipBoardData==NULL)
return(OUTOFMEMORY);
((ClipBoards *)&ClipBoardData[GlobalClipBoardDataLength])->ClipBoardDataType=
DataType;
((ClipBoards *)&ClipBoardData[GlobalClipBoardDataLength])->ClipBoardDataLength=
DataLength;
memcpy(&ClipBoardData[GlobalClipBoardDataLength+sizeof(ClipBoards)],
AppendData,DataLength);
GlobalClipBoardDataLength+=DataLength+sizeof(ClipBoards);
HandleUnlock(GlobalClipBoardHandle);
ReturnOK();
}
/*!
* \brief Unregisters a device.
*
* \return UPNP_E_SUCCESS on success, GENA_E_BAD_HANDLE on failure.
*/
int genaUnregisterDevice(
/*! [in] Device handle. */
UpnpDevice_Handle device_handle)
{
int ret = 0;
struct Handle_Info *handle_info;
HandleLock();
if (GetHandleInfo(device_handle, &handle_info) != HND_DEVICE) {
UpnpPrintf(UPNP_CRITICAL, GENA, __FILE__, __LINE__,
"genaUnregisterDevice: BAD Handle: %d\n",
device_handle);
ret = GENA_E_BAD_HANDLE;
} else {
freeServiceTable(&handle_info->ServiceTable);
ret = UPNP_E_SUCCESS;
}
HandleUnlock();
return ret;
}
int GetPictureUse(unsigned char *UseStatusArray[40])
{
HPAGE MidPage;
HBOX HBox;
PictureBoxs *PictureBox;
char *FileName;
int TotalFile=0,i;
UseStatusArray[0][0]=0;
MidPage=ItemGetChild(GlobalPageHeadHandle);
while (MidPage)
{
HBox=PageGetBoxHead(MidPage);
while (HBox)
{
PictureBox=HandleLock(ItemGetHandle(HBox));
if (PictureBox==NULL)
return(OUTOFMEMORY);
if (PictureBoxGetBoxType(PictureBox)>=RECTANGLEPICTUREBOX
&&PictureBoxGetBoxType(PictureBox)<=POLYGONPICTUREBOX)
{
FileName=PictureBoxGetPictureFileName(PictureBox);
if (FileName[0])
{
for (i=0;i<TotalFile;i++)
{
if (!strcmp(FileName,UseStatusArray[i]))
break;
}
if (i>=TotalFile)
strncpy(UseStatusArray[TotalFile],FileName,39);
}
}
HandleUnlock(ItemGetHandle(HBox));
HBox=ItemGetNext(HBox);
}
MidPage=ItemGetNext(MidPage);
}
return(TotalFile);
}
/* We take ownership of propertySet and will free it */
static int genaNotifyAllCommon(
UpnpDevice_Handle device_handle,
char *UDN,
char *servId,
DOMString propertySet)
{
int ret = GENA_SUCCESS;
int line = 0;
int *reference_count = NULL;
char *UDN_copy = NULL;
char *servId_copy = NULL;
char *headers = NULL;
notify_thread_struct *thread_struct = NULL;
subscription *finger = NULL;
service_info *service = NULL;
struct Handle_Info *handle_info;
UpnpPrintf(UPNP_INFO, GENA, __FILE__, __LINE__,
"GENA BEGIN NOTIFY ALL COMMON");
/* Keep this allocation first */
reference_count = (int *)malloc(sizeof (int));
if (reference_count == NULL) {
line = __LINE__;
ret = UPNP_E_OUTOF_MEMORY;
goto ExitFunction;
}
*reference_count = 0;
UDN_copy = strdup(UDN);
if (UDN_copy == NULL) {
line = __LINE__;
ret = UPNP_E_OUTOF_MEMORY;
goto ExitFunction;
}
servId_copy = strdup(servId);
if( servId_copy == NULL ) {
line = __LINE__;
ret = UPNP_E_OUTOF_MEMORY;
goto ExitFunction;
}
headers = AllocGenaHeaders(propertySet);
if (headers == NULL) {
line = __LINE__;
ret = UPNP_E_OUTOF_MEMORY;
goto ExitFunction;
}
HandleLock();
if (GetHandleInfo(device_handle, &handle_info) != HND_DEVICE) {
line = __LINE__;
ret = GENA_E_BAD_HANDLE;
} else {
service = FindServiceId(&handle_info->ServiceTable, servId, UDN);
if (service != NULL) {
finger = GetFirstSubscription(service);
while (finger) {
ThreadPoolJob *job = NULL;
ListNode *node;
thread_struct = (notify_thread_struct *)malloc(sizeof (notify_thread_struct));
if (thread_struct == NULL) {
line = __LINE__;
ret = UPNP_E_OUTOF_MEMORY;
break;
}
(*reference_count)++;
thread_struct->reference_count = reference_count;
thread_struct->UDN = UDN_copy;
thread_struct->servId = servId_copy;
thread_struct->headers = headers;
thread_struct->propertySet = propertySet;
memset(thread_struct->sid, 0,
sizeof(thread_struct->sid));
strncpy(thread_struct->sid, finger->sid,
sizeof(thread_struct->sid) - 1);
thread_struct->ctime = time(0);
thread_struct->device_handle = device_handle;
maybeDiscardEvents(&finger->outgoing);
job = (ThreadPoolJob *)malloc(sizeof(ThreadPoolJob));
if (job == NULL) {
line = __LINE__;
ret = UPNP_E_OUTOF_MEMORY;
break;
}
memset(job, 0, sizeof(ThreadPoolJob));
TPJobInit(job, (start_routine)genaNotifyThread, thread_struct);
TPJobSetFreeFunction(job, (free_routine)free_notify_struct);
TPJobSetPriority(job, MED_PRIORITY);
node = ListAddTail(&finger->outgoing, job);
/* If there is only one element on the list (which we just
added), need to kickstart the threadpool */
if (ListSize(&finger->outgoing) == 1) {
ret = ThreadPoolAdd(&gSendThreadPool, job, NULL);
if (ret != 0) {
line = __LINE__;
if (ret == EOUTOFMEM) {
line = __LINE__;
ret = UPNP_E_OUTOF_MEMORY;
}
break;
}
if (node) {
((ThreadPoolJob *)(node->item))->jobId = STALE_JOBID;
}
}
finger = GetNextSubscription(service, finger);
}
} else {
line = __LINE__;
ret = GENA_E_BAD_SERVICE;
}
}
ExitFunction:
/* The only case where we want to free memory here is if the
struct was never queued. Else, let the normal cleanup take place.
reference_count is allocated first so it's ok to do nothing if it's 0
*/
if (reference_count && *reference_count == 0) {
free(headers);
ixmlFreeDOMString(propertySet);
free(servId_copy);
free(UDN_copy);
free(reference_count);
}
HandleUnlock();
UpnpPrintf(UPNP_INFO, GENA, __FILE__, line,
"GENA END NOTIFY ALL COMMON, ret = %d",
ret);
return ret;
}
/* We take ownership of propertySet and will free it */
static int genaInitNotifyCommon(
UpnpDevice_Handle device_handle,
char *UDN,
char *servId,
DOMString propertySet,
const Upnp_SID sid)
{
int ret = GENA_SUCCESS;
int line = 0;
int *reference_count = NULL;
char *UDN_copy = NULL;
char *servId_copy = NULL;
char *headers = NULL;
notify_thread_struct *thread_struct = NULL;
subscription *sub = NULL;
service_info *service = NULL;
struct Handle_Info *handle_info;
ThreadPoolJob *job = NULL;
UpnpPrintf(UPNP_INFO, GENA, __FILE__, __LINE__,
"GENA BEGIN INITIAL NOTIFY COMMON");
job = (ThreadPoolJob *)malloc(sizeof(ThreadPoolJob));
if (job == NULL) {
line = __LINE__;
ret = UPNP_E_OUTOF_MEMORY;
goto ExitFunction;
}
memset(job, 0, sizeof(ThreadPoolJob));
reference_count = (int *)malloc(sizeof (int));
if (reference_count == NULL) {
line = __LINE__;
ret = UPNP_E_OUTOF_MEMORY;
goto ExitFunction;
}
*reference_count = 0;
UDN_copy = strdup(UDN);
if (UDN_copy == NULL) {
line = __LINE__;
ret = UPNP_E_OUTOF_MEMORY;
goto ExitFunction;
}
servId_copy = strdup(servId);
if (servId_copy == NULL) {
line = __LINE__;
ret = UPNP_E_OUTOF_MEMORY;
goto ExitFunction;
}
HandleLock();
if (GetHandleInfo(device_handle, &handle_info) != HND_DEVICE) {
line = __LINE__;
ret = GENA_E_BAD_HANDLE;
goto ExitFunction;
}
service = FindServiceId(&handle_info->ServiceTable, servId, UDN);
if (service == NULL) {
line = __LINE__;
ret = GENA_E_BAD_SERVICE;
goto ExitFunction;
}
UpnpPrintf(UPNP_INFO, GENA, __FILE__, __LINE__,
"FOUND SERVICE IN INIT NOTFY: UDN %s, ServID: %s",
UDN, servId);
sub = GetSubscriptionSID(sid, service);
if (sub == NULL || sub->active) {
line = __LINE__;
ret = GENA_E_BAD_SID;
goto ExitFunction;
}
UpnpPrintf( UPNP_INFO, GENA, __FILE__, __LINE__,
"FOUND SUBSCRIPTION IN INIT NOTIFY: SID %s", sid);
sub->active = 1;
headers = AllocGenaHeaders(propertySet);
if (headers == NULL) {
line = __LINE__;
ret = UPNP_E_OUTOF_MEMORY;
goto ExitFunction;
}
/* schedule thread for initial notification */
thread_struct = (notify_thread_struct *)malloc(sizeof (notify_thread_struct));
if (thread_struct == NULL) {
line = __LINE__;
ret = UPNP_E_OUTOF_MEMORY;
} else {
*reference_count = 1;
thread_struct->servId = servId_copy;
thread_struct->UDN = UDN_copy;
thread_struct->headers = headers;
thread_struct->propertySet = propertySet;
memset(thread_struct->sid, 0, sizeof(thread_struct->sid));
strncpy(thread_struct->sid, sid,
sizeof(thread_struct->sid) - 1);
thread_struct->ctime = time(0);
thread_struct->reference_count = reference_count;
thread_struct->device_handle = device_handle;
TPJobInit(job, (start_routine)genaNotifyThread, thread_struct);
TPJobSetFreeFunction(job, (free_routine)free_notify_struct);
TPJobSetPriority(job, MED_PRIORITY);
ret = ThreadPoolAdd(&gSendThreadPool, job, NULL);
if (ret != 0) {
if (ret == EOUTOFMEM) {
line = __LINE__;
ret = UPNP_E_OUTOF_MEMORY;
}
} else {
ListNode *node = ListAddTail(&sub->outgoing, job);
if (node != NULL) {
((ThreadPoolJob *)node->item)->jobId = STALE_JOBID;
line = __LINE__;
ret = GENA_SUCCESS;
} else {
line = __LINE__;
ret = UPNP_E_OUTOF_MEMORY;
}
}
}
ExitFunction:
if (ret != GENA_SUCCESS) {
free(job);
free(thread_struct);
free(headers);
ixmlFreeDOMString(propertySet);
free(servId_copy);
free(UDN_copy);
free(reference_count);
}
HandleUnlock();
UpnpPrintf(UPNP_INFO, GENA, __FILE__, line,
"GENA END INITIAL NOTIFY COMMON, ret = %d",
ret);
return ret;
}
/*!
* \brief Thread job to Notify a control point.
*
* It validates the subscription and copies the subscription. Also make sure
* that events are sent in order.
*
* \note calls the genaNotify to do the actual work.
*/
static void genaNotifyThread(
/*! [in] notify thread structure containing all the headers and property set info. */
void *input)
{
subscription *sub;
service_info *service;
subscription sub_copy;
notify_thread_struct *in = (notify_thread_struct *) input;
int return_code;
struct Handle_Info *handle_info;
/* This should be a HandleLock and not a HandleReadLock otherwise if there
* is a lot of notifications, then multiple threads will acquire a read
* lock and the thread which sends the notification will be blocked forever
* on the HandleLock at the end of this function. */
/*HandleReadLock(); */
HandleLock();
/* validate context */
if (GetHandleInfo(in->device_handle, &handle_info) != HND_DEVICE) {
free_notify_struct(in);
HandleUnlock();
return;
}
if (!(service = FindServiceId(&handle_info->ServiceTable, in->servId, in->UDN)) ||
!service->active ||
!(sub = GetSubscriptionSID(in->sid, service)) ||
copy_subscription(sub, &sub_copy) != HTTP_SUCCESS) {
free_notify_struct(in);
HandleUnlock();
return;
}
HandleUnlock();
/* send the notify */
return_code = genaNotify(in->headers, in->propertySet, &sub_copy);
freeSubscription(&sub_copy);
HandleLock();
if (GetHandleInfo(in->device_handle, &handle_info) != HND_DEVICE) {
free_notify_struct(in);
HandleUnlock();
return;
}
/* validate context */
if (!(service = FindServiceId(&handle_info->ServiceTable, in->servId, in->UDN)) ||
!service->active ||
!(sub = GetSubscriptionSID(in->sid, service))) {
free_notify_struct(in);
HandleUnlock();
return;
}
sub->ToSendEventKey++;
if (sub->ToSendEventKey < 0)
/* wrap to 1 for overflow */
sub->ToSendEventKey = 1;
/* Remove head of event queue. Possibly activate next */
{
ListNode *node = ListHead(&sub->outgoing);
if (node)
ListDelNode(&sub->outgoing, node, 1);
if (ListSize(&sub->outgoing) > 0) {
ThreadPoolJob *job;
ListNode *node = ListHead(&sub->outgoing);
job = (ThreadPoolJob*)node->item;
/* The new head of queue should not have already been
added to the pool, else something is very wrong */
assert(job->jobId != STALE_JOBID);
ThreadPoolAdd(&gSendThreadPool, job, NULL);
job->jobId = STALE_JOBID;
}
}
if (return_code == GENA_E_NOTIFY_UNACCEPTED_REMOVE_SUB)
RemoveSubscriptionSID(in->sid, service);
free_notify_struct(in);
HandleUnlock();
}
void gena_process_subscription_renewal_request(
SOCKINFO *info,
http_message_t *request)
{
Upnp_SID sid;
subscription *sub;
int time_out = 1801;
service_info *service;
struct Handle_Info *handle_info;
UpnpDevice_Handle device_handle;
memptr temp_hdr;
membuffer event_url_path;
memptr timeout_hdr;
/* if a CALLBACK or NT header is present, then it is an error */
if( httpmsg_find_hdr( request, HDR_CALLBACK, NULL ) != NULL ||
httpmsg_find_hdr( request, HDR_NT, NULL ) != NULL ) {
error_respond( info, HTTP_BAD_REQUEST, request );
return;
}
/* get SID */
if( httpmsg_find_hdr( request, HDR_SID, &temp_hdr ) == NULL ||
temp_hdr.length > SID_SIZE ) {
error_respond( info, HTTP_PRECONDITION_FAILED, request );
return;
}
memcpy( sid, temp_hdr.buf, temp_hdr.length );
sid[temp_hdr.length] = '\0';
/* lookup service by eventURL */
membuffer_init( &event_url_path );
if( membuffer_append( &event_url_path, request->uri.pathquery.buff,
request->uri.pathquery.size ) != 0 ) {
error_respond( info, HTTP_INTERNAL_SERVER_ERROR, request );
return;
}
HandleLock();
if (GetDeviceHandleInfoForPath(event_url_path.buf, info->foreign_sockaddr.ss_family,
&device_handle, &handle_info, &service) != HND_DEVICE ) {
error_respond( info, HTTP_PRECONDITION_FAILED, request );
membuffer_destroy( &event_url_path );
HandleUnlock();
return;
}
membuffer_destroy( &event_url_path );
/* get subscription */
if( service == NULL ||
!service->active ||
( ( sub = GetSubscriptionSID( sid, service ) ) == NULL ) ) {
error_respond( info, HTTP_PRECONDITION_FAILED, request );
HandleUnlock();
return;
}
UpnpPrintf( UPNP_INFO, GENA, __FILE__, __LINE__,
"Renew request: Number of subscriptions already: %d\n "
"Max Subscriptions allowed:%d\n",
service->TotalSubscriptions,
handle_info->MaxSubscriptions );
/* too many subscriptions */
if( handle_info->MaxSubscriptions != -1 &&
service->TotalSubscriptions > handle_info->MaxSubscriptions ) {
error_respond( info, HTTP_INTERNAL_SERVER_ERROR, request );
RemoveSubscriptionSID( sub->sid, service );
HandleUnlock();
return;
}
/* set the timeout */
if( httpmsg_find_hdr( request, HDR_TIMEOUT, &timeout_hdr ) != NULL ) {
if( matchstr( timeout_hdr.buf, timeout_hdr.length,
"%iSecond-%d%0", &time_out ) == PARSE_OK ) {
/*nothing */
} else if( memptr_cmp_nocase( &timeout_hdr, "Second-infinite" ) ==
0 ) {
time_out = -1; /* inifinite timeout */
} else {
time_out = DEFAULT_TIMEOUT; /* default is > 1800 seconds */
}
}
/* replace infinite timeout with max timeout, if possible */
if( handle_info->MaxSubscriptionTimeOut != -1 ) {
if( time_out == -1 ||
time_out > handle_info->MaxSubscriptionTimeOut ) {
time_out = handle_info->MaxSubscriptionTimeOut;
}
}
if( time_out == -1 ) {
sub->expireTime = 0;
} else {
sub->expireTime = time( NULL ) + time_out;
}
if( respond_ok( info, time_out, sub, request ) != UPNP_E_SUCCESS ) {
RemoveSubscriptionSID( sub->sid, service );
}
HandleUnlock();
}
void gena_process_subscription_request(
SOCKINFO *info,
http_message_t *request)
{
UpnpSubscriptionRequest *request_struct = UpnpSubscriptionRequest_new();
Upnp_SID temp_sid;
int return_code = 1;
int time_out = 1801;
service_info *service;
subscription *sub;
uuid_upnp uid;
struct Handle_Info *handle_info;
void *cookie;
Upnp_FunPtr callback_fun;
UpnpDevice_Handle device_handle;
memptr nt_hdr;
char *event_url_path = NULL;
memptr callback_hdr;
memptr timeout_hdr;
int rc = 0;
UpnpPrintf(UPNP_INFO, GENA, __FILE__, __LINE__,
"Subscription Request Received:\n");
if (httpmsg_find_hdr(request, HDR_NT, &nt_hdr) == NULL) {
error_respond(info, HTTP_BAD_REQUEST, request);
goto exit_function;
}
/* check NT header */
/* Windows Millenium Interoperability: */
/* we accept either upnp:event, or upnp:propchange for the NT header */
if (memptr_cmp_nocase(&nt_hdr, "upnp:event") != 0) {
error_respond(info, HTTP_PRECONDITION_FAILED, request);
goto exit_function;
}
/* if a SID is present then the we have a bad request "incompatible headers" */
if (httpmsg_find_hdr(request, HDR_SID, NULL) != NULL) {
error_respond(info, HTTP_BAD_REQUEST, request);
goto exit_function;
}
/* look up service by eventURL */
event_url_path = str_alloc(request->uri.pathquery.buff, request->uri.pathquery.size);
if (event_url_path == NULL) {
error_respond(info, HTTP_INTERNAL_SERVER_ERROR, request);
goto exit_function;
}
UpnpPrintf(UPNP_INFO, GENA, __FILE__, __LINE__,
"SubscriptionRequest for event URL path: %s\n",
event_url_path);
HandleLock();
if (GetDeviceHandleInfoForPath(event_url_path, info->foreign_sockaddr.ss_family,
&device_handle, &handle_info, &service) != HND_DEVICE) {
free(event_url_path);
error_respond(info, HTTP_INTERNAL_SERVER_ERROR, request);
HandleUnlock();
goto exit_function;
}
free(event_url_path);
if (service == NULL || !service->active) {
error_respond(info, HTTP_NOT_FOUND, request);
HandleUnlock();
goto exit_function;
}
UpnpPrintf(UPNP_INFO, GENA, __FILE__, __LINE__,
"Subscription Request: Number of Subscriptions already %d\n "
"Max Subscriptions allowed: %d\n",
service->TotalSubscriptions,
handle_info->MaxSubscriptions);
/* too many subscriptions */
if (handle_info->MaxSubscriptions != -1 &&
service->TotalSubscriptions >= handle_info->MaxSubscriptions) {
error_respond(info, HTTP_INTERNAL_SERVER_ERROR, request);
HandleUnlock();
goto exit_function;
}
/* generate new subscription */
sub = (subscription *)malloc(sizeof (subscription));
if (sub == NULL) {
error_respond(info, HTTP_INTERNAL_SERVER_ERROR, request);
HandleUnlock();
goto exit_function;
}
sub->ToSendEventKey = 0;
sub->active = 0;
sub->next = NULL;
sub->DeliveryURLs.size = 0;
sub->DeliveryURLs.URLs = NULL;
sub->DeliveryURLs.parsedURLs = NULL;
if (ListInit(&sub->outgoing, 0, free) != 0) {
error_respond(info, HTTP_INTERNAL_SERVER_ERROR, request);
HandleUnlock();
goto exit_function;
}
/* check for valid callbacks */
if (httpmsg_find_hdr( request, HDR_CALLBACK, &callback_hdr) == NULL) {
error_respond(info, HTTP_PRECONDITION_FAILED, request);
freeSubscriptionList(sub);
HandleUnlock();
goto exit_function;
}
return_code = create_url_list(&callback_hdr, &sub->DeliveryURLs);
if (return_code == 0) {
error_respond(info, HTTP_PRECONDITION_FAILED, request);
freeSubscriptionList(sub);
HandleUnlock();
goto exit_function;
}
if (return_code == UPNP_E_OUTOF_MEMORY) {
error_respond(info, HTTP_INTERNAL_SERVER_ERROR, request);
freeSubscriptionList(sub);
HandleUnlock();
goto exit_function;
}
/* set the timeout */
if (httpmsg_find_hdr(request, HDR_TIMEOUT, &timeout_hdr) != NULL) {
if (matchstr(timeout_hdr.buf, timeout_hdr.length,
"%iSecond-%d%0", &time_out) == PARSE_OK) {
/* nothing */
} else if(memptr_cmp_nocase(&timeout_hdr, "Second-infinite") == 0) {
/* infinite timeout */
time_out = -1;
} else {
/* default is > 1800 seconds */
time_out = DEFAULT_TIMEOUT;
}
}
/* replace infinite timeout with max timeout, if possible */
if (handle_info->MaxSubscriptionTimeOut != -1) {
if (time_out == -1 ||
time_out > handle_info->MaxSubscriptionTimeOut) {
time_out = handle_info->MaxSubscriptionTimeOut;
}
}
if (time_out >= 0) {
sub->expireTime = time(NULL) + time_out;
} else {
/* infinite time */
sub->expireTime = 0;
}
/* generate SID */
uuid_create(&uid);
upnp_uuid_unpack(&uid, temp_sid);
rc = snprintf(sub->sid, sizeof(sub->sid), "uuid:%s", temp_sid);
/* respond OK */
if (rc < 0 || (unsigned int) rc >= sizeof(sub->sid) ||
(respond_ok(info, time_out,
sub, request) != UPNP_E_SUCCESS)) {
freeSubscriptionList(sub);
HandleUnlock();
goto exit_function;
}
/* add to subscription list */
sub->next = service->subscriptionList;
service->subscriptionList = sub;
service->TotalSubscriptions++;
/* finally generate callback for init table dump */
UpnpSubscriptionRequest_strcpy_ServiceId(request_struct, service->serviceId);
UpnpSubscriptionRequest_strcpy_UDN(request_struct, service->UDN);
UpnpSubscriptionRequest_strcpy_SID(request_struct, sub->sid);
/* copy callback */
callback_fun = handle_info->Callback;
cookie = handle_info->Cookie;
HandleUnlock();
/* make call back with request struct */
/* in the future should find a way of mainting that the handle */
/* is not unregistered in the middle of a callback */
callback_fun(UPNP_EVENT_SUBSCRIPTION_REQUEST, request_struct, cookie);
exit_function:
UpnpSubscriptionRequest_delete(request_struct);
}
int genaNotifyAll(
UpnpDevice_Handle device_handle,
char *UDN,
char *servId,
char **VarNames,
char **VarValues,
int var_count)
{
int ret = GENA_SUCCESS;
int line = 0;
int *reference_count = NULL;
char *UDN_copy = NULL;
char *servId_copy = NULL;
DOMString propertySet = NULL;
char *headers = NULL;
notify_thread_struct *thread_struct = NULL;
subscription *finger = NULL;
service_info *service = NULL;
struct Handle_Info *handle_info;
ThreadPoolJob job;
memset(&job, 0, sizeof(job));
UpnpPrintf(UPNP_INFO, GENA, __FILE__, __LINE__,
"GENA BEGIN NOTIFY ALL");
reference_count = (int *)malloc(sizeof (int));
if (reference_count == NULL) {
line = __LINE__;
ret = UPNP_E_OUTOF_MEMORY;
goto ExitFunction;
}
*reference_count = 0;
UDN_copy = strdup(UDN);
if (UDN_copy == NULL) {
line = __LINE__;
ret = UPNP_E_OUTOF_MEMORY;
goto ExitFunction;
}
servId_copy = strdup(servId);
if( servId_copy == NULL ) {
line = __LINE__;
ret = UPNP_E_OUTOF_MEMORY;
goto ExitFunction;
}
ret = GeneratePropertySet(VarNames, VarValues, var_count, &propertySet);
if (ret != XML_SUCCESS) {
line = __LINE__;
goto ExitFunction;
}
UpnpPrintf(UPNP_INFO, GENA, __FILE__, __LINE__,
"GENERATED PROPERTY SET IN EXT NOTIFY: %s",
propertySet);
headers = AllocGenaHeaders(propertySet);
if (headers == NULL) {
line = __LINE__;
ret = UPNP_E_OUTOF_MEMORY;
goto ExitFunction;
}
HandleLock();
if (GetHandleInfo(device_handle, &handle_info) != HND_DEVICE) {
line = __LINE__;
ret = GENA_E_BAD_HANDLE;
} else {
service = FindServiceId(&handle_info->ServiceTable, servId, UDN);
if (service != NULL) {
finger = GetFirstSubscription(service);
while (finger) {
thread_struct = (notify_thread_struct *)malloc(sizeof (notify_thread_struct));
if (thread_struct == NULL) {
line = __LINE__;
ret = UPNP_E_OUTOF_MEMORY;
break;
}
(*reference_count)++;
thread_struct->reference_count = reference_count;
thread_struct->UDN = UDN_copy;
thread_struct->servId = servId_copy;
thread_struct->headers = headers;
thread_struct->propertySet = propertySet;
memset(thread_struct->sid, 0,
sizeof(thread_struct->sid));
strncpy(thread_struct->sid, finger->sid,
sizeof(thread_struct->sid) - 1);
thread_struct->eventKey = finger->eventKey++;
thread_struct->device_handle = device_handle;
/* if overflow, wrap to 1 */
if (finger->eventKey < 0) {
finger->eventKey = 1;
}
TPJobInit(&job, (start_routine)genaNotifyThread, thread_struct);
TPJobSetFreeFunction(&job, (free_routine)free_notify_struct);
TPJobSetPriority(&job, MED_PRIORITY);
ret = ThreadPoolAdd(&gSendThreadPool, &job, NULL);
if (ret != 0) {
line = __LINE__;
if (ret == EOUTOFMEM) {
line = __LINE__;
ret = UPNP_E_OUTOF_MEMORY;
}
break;
}
finger = GetNextSubscription(service, finger);
}
} else {
line = __LINE__;
ret = GENA_E_BAD_SERVICE;
}
}
ExitFunction:
if (ret != GENA_SUCCESS || *reference_count == 0) {
free(headers);
ixmlFreeDOMString(propertySet);
free(servId_copy);
free(UDN_copy);
free(reference_count);
}
HandleUnlock();
UpnpPrintf(UPNP_INFO, GENA, __FILE__, line,
"GENA END NOTIFY ALL, ret = %d",
ret);
return ret;
}
int genaInitNotifyExt(
UpnpDevice_Handle device_handle,
char *UDN,
char *servId,
IXML_Document *PropSet,
const Upnp_SID sid)
{
int ret = GENA_SUCCESS;
int line = 0;
int *reference_count = NULL;
char *UDN_copy = NULL;
char *servId_copy = NULL;
DOMString propertySet = NULL;
char *headers = NULL;
notify_thread_struct *thread_struct = NULL;
subscription *sub = NULL;
service_info *service = NULL;
struct Handle_Info *handle_info;
ThreadPoolJob job;
memset(&job, 0, sizeof(job));
UpnpPrintf(UPNP_INFO, GENA, __FILE__, __LINE__,
"GENA BEGIN INITIAL NOTIFY EXT");
reference_count = (int *)malloc(sizeof (int));
if (reference_count == NULL) {
line = __LINE__;
ret = UPNP_E_OUTOF_MEMORY;
goto ExitFunction;
}
*reference_count = 0;
UDN_copy = strdup(UDN);
if (UDN_copy == NULL) {
line = __LINE__;
ret = UPNP_E_OUTOF_MEMORY;
goto ExitFunction;
}
servId_copy = strdup(servId);
if( servId_copy == NULL ) {
line = __LINE__;
ret = UPNP_E_OUTOF_MEMORY;
goto ExitFunction;
}
HandleLock();
if (GetHandleInfo(device_handle, &handle_info) != HND_DEVICE) {
line = __LINE__;
ret = GENA_E_BAD_HANDLE;
goto ExitFunction;
}
service = FindServiceId(&handle_info->ServiceTable, servId, UDN);
if (service == NULL) {
line = __LINE__;
ret = GENA_E_BAD_SERVICE;
goto ExitFunction;
}
UpnpPrintf(UPNP_INFO, GENA, __FILE__, __LINE__,
"FOUND SERVICE IN INIT NOTFY EXT: UDN %s, ServID: %s",
UDN, servId);
sub = GetSubscriptionSID(sid, service);
if (sub == NULL || sub->active) {
line = __LINE__;
ret = GENA_E_BAD_SID;
goto ExitFunction;
}
UpnpPrintf( UPNP_INFO, GENA, __FILE__, __LINE__,
"FOUND SUBSCRIPTION IN INIT NOTIFY EXT: SID %s", sid);
sub->active = 1;
if (PropSet == 0) {
line = __LINE__;
ret = GENA_SUCCESS;
goto ExitFunction;
}
propertySet = ixmlPrintNode((IXML_Node *)PropSet);
if (propertySet == NULL) {
line = __LINE__;
ret = UPNP_E_INVALID_PARAM;
goto ExitFunction;
}
UpnpPrintf(UPNP_INFO, GENA, __FILE__, __LINE__,
"GENERATED PROPERTY SET IN INIT EXT NOTIFY: %s",
propertySet);
headers = AllocGenaHeaders(propertySet);
if (headers == NULL) {
line = __LINE__;
ret = UPNP_E_OUTOF_MEMORY;
goto ExitFunction;
}
/* schedule thread for initial notification */
thread_struct = (notify_thread_struct *)malloc(sizeof (notify_thread_struct));
if (thread_struct == NULL) {
line = __LINE__;
ret = UPNP_E_OUTOF_MEMORY;
} else {
*reference_count = 1;
thread_struct->servId = servId_copy;
thread_struct->UDN = UDN_copy;
thread_struct->headers = headers;
thread_struct->propertySet = propertySet;
memset(thread_struct->sid, 0, sizeof(thread_struct->sid));
strncpy(thread_struct->sid, sid,
sizeof(thread_struct->sid) - 1);
thread_struct->eventKey = sub->eventKey++;
thread_struct->reference_count = reference_count;
thread_struct->device_handle = device_handle;
TPJobInit(&job, (start_routine)genaNotifyThread, thread_struct);
TPJobSetFreeFunction(&job, (free_routine)free_notify_struct);
TPJobSetPriority(&job, MED_PRIORITY);
ret = ThreadPoolAdd(&gSendThreadPool, &job, NULL);
if (ret != 0) {
if (ret == EOUTOFMEM) {
line = __LINE__;
ret = UPNP_E_OUTOF_MEMORY;
}
} else {
line = __LINE__;
ret = GENA_SUCCESS;
}
}
ExitFunction:
if (ret != GENA_SUCCESS || PropSet == 0) {
free(thread_struct);
free(headers);
ixmlFreeDOMString(propertySet);
free(servId_copy);
free(UDN_copy);
free(reference_count);
}
HandleUnlock();
UpnpPrintf(UPNP_INFO, GENA, __FILE__, line,
"GENA END INITIAL NOTIFY EXT, ret = %d",
ret);
return ret;
}