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