AL_API ALvoid AL_APIENTRY alDeleteBuffers(ALsizei n, const ALuint *buffers) { ALCdevice *device; ALCcontext *context; ALbuffer *ALBuf; ALsizei i; context = GetContextRef(); if(!context) return; if(!(n >= 0)) SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done); device = context->Device; for(i = 0;i < n;i++) { if(!buffers[i]) continue; /* Check for valid Buffer ID */ if((ALBuf=LookupBuffer(device, buffers[i])) == NULL) SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done); if(ReadRef(&ALBuf->ref) != 0) SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, done); } for(i = 0;i < n;i++) { if((ALBuf=LookupBuffer(device, buffers[i])) != NULL) DeleteBuffer(device, ALBuf); } done: ALCcontext_DecRef(context); }
//--------------------------------------------------------------------------- // IFXString::Assign // // This method copies the source UTF-8 characters to the destination wide characters. //--------------------------------------------------------------------------- IFXRESULT IFXString::Assign(const U8* pSource) { IFXRESULT result = IFX_OK; if(!pSource) { DeleteBuffer(); } else { U32 size = 0; result = IFXOSGetWideCharStrSize( pSource, &size ); size = size + 1; //null terminator if( IFXSUCCESS( result) && (size > 0) ) { NewBuffer(size); if (m_Buffer) result = IFXOSConvertUtf8StrToWideChar( pSource, m_Buffer, size ); else result = IFX_E_OUT_OF_MEMORY; } else result = IFX_E_UNDEFINED; } return result; }
int SensorData_Upload(char *dataPoint, void* value, unsigned char datatype) { int ret = 0; EdpPacket* update_pkg; switch (datatype) { default: case DATATYPE_INT: update_pkg = PacketSavedataInt(kTypeFullJson, SRC_DEVID, dataPoint, *(int*)value, 0, EDP_TOKEN); break; case DATATYPE_DOUBLE: update_pkg = PacketSavedataDouble(kTypeFullJson, SRC_DEVID, dataPoint, *(double*)value, 0, EDP_TOKEN); break; case DATATYPE_STRING: update_pkg = PacketSavedataString(kTypeFullJson, SRC_DEVID, dataPoint, (const char*)value, 0, EDP_TOKEN); break; } OSTimeDly(10); /* 发送转存数据到OneNet并转发到Dev2设备 */ ret = Socket_TCPClientSendData((char*)update_pkg->_data, update_pkg->_write_pos); if (ret <= 0) { log_info("Save and transmit full json data failed(ret:%d).\n", ret); } else { log_notice("Save and transmit full json data success.\n"); } DeleteBuffer(&update_pkg); return 0; }
INT32 Adreno::MemoryBuffer::ExpandBuffer( INT32 num_new_bytes ) { INT32 old_size = BufferSize(); INT32 new_size = old_size + num_new_bytes; if( new_size > 0 ) { BYTE* new_buffer = new BYTE[ new_size ]; // Copy the old buffer if( m_buffer ) { for( INT32 i = 0; i < old_size; ++i ) { new_buffer[ i ] = m_buffer[ i ]; } DeleteBuffer(); } // Zero out the new bytes for( INT32 i = old_size; i < new_size; ++i ) { new_buffer[ i ] = 0; } // Use the new buffer m_size = new_size; m_buffer = new_buffer; } return old_size; }
void CDVDVideoCodecLibMpeg2::DeleteBuffer(DVDVideoPicture* pPic) { if(pPic) { _aligned_free(pPic->data[0]); _aligned_free(pPic->data[1]); _aligned_free(pPic->data[2]); pPic->data[0] = 0; pPic->data[1] = 0; pPic->data[2] = 0; pPic->iLineSize[0] = 0; pPic->iLineSize[1] = 0; pPic->iLineSize[2] = 0; pPic->iFlags &= ~DVP_FLAG_ALLOCATED; pPic->iFlags &= ~DVP_FLAG_LIBMPEG2_ALLOCATED; if (m_pCurrentBuffer == pPic) m_pCurrentBuffer = NULL; } else { //Release all buffers for (int i = 0; i < 3; i++) DeleteBuffer(m_pVideoBuffer + i); } }
void System::Quit() { DeleteBuffer(); g_input->PurgeInstance(); g_scene->PurgeInstance(); g_system->PurgeInstance(); }
static void EEPROMWriteReadTestHandler(SignalType * Signal) { switch (Signal->Event) { case EE_PRIMITIVE: switch (Signal->SubEvent) { case EE_READ_DATA_cfm: { char* ptr; EeStoreDataReqType *EeStoreDataReq; ptr = StringPrint(StatusString, "EE_READ_DATA_cfm["); ptr = StrPrintHexWord(ptr, EEP_UserDataArea); ptr = StringPrint(ptr, "]=["); ptr = StrPrintHexByte(ptr, eepromData[0]); ptr = StringPrint(ptr, "]"); PrintStatus(0, StatusString); eepromData[0]++; NewSignal(sizeof(EeStoreDataReqType) + 1, (void **) &EeStoreDataReq); getSignalData(EeStoreDataReq)[0] = eepromData[0]; EeStoreDataReq->DataTypes = EEDT_ANYADDRESS; EeStoreDataReq->SubsNo = 0; setAddressData(EEP_UserDataArea, 1); SendSignal((SignalType *) EeStoreDataReq, EE_PROCESS_ID, EE_PRIMITIVE, EE_STORE_DATA_req); setSignalHandler(APPLICATION_PROCESS_ID_PP, PPconnectionHandler, 0); } break; } } DeleteBuffer(Signal); }
/* if possible, read num_bytes from session. If not possible, return false and write nothing. DO NOT pass in 0 bytes to read. */ Bool ReadSessionBytes(session_node *s,int num_bytes,void *buf) { buffer_node *bn,*blist; int copied,copy_bytes; if (GetSessionReadBytes(s) < num_bytes) return False; blist = s->receive_list; if (blist->len_buf - s->receive_index > num_bytes) { memcpy(buf,blist->buf + s->receive_index,num_bytes); s->receive_index += num_bytes; return True; } /* reading at least as many bytes as there are in first buffer */ copy_bytes = blist->len_buf - s->receive_index; memcpy(buf,blist->buf + s->receive_index,copy_bytes); copied = copy_bytes; bn = blist->next; DeleteBuffer(blist); s->receive_list = bn; s->receive_index = 0; copy_bytes = 0; /* in case exactly read message, set receive_index right */ while (s->receive_list != NULL && copied < num_bytes) { copy_bytes = std::min(num_bytes-copied,s->receive_list->len_buf); memcpy((char *)buf+copied,s->receive_list->buf,copy_bytes); copied += copy_bytes; if (copy_bytes == s->receive_list->len_buf) { bn = s->receive_list->next; DeleteBuffer(s->receive_list); s->receive_list = bn; copy_bytes = 0; /* if last copy ended with this buffer, set receive_index right */ } } s->receive_index = copy_bytes; return True; }
void ArrayBuffer<DataType>::SetBufferUsage(unsigned int usage) { if (m_BufferUsage != usage) { DeleteBuffer(); UpdateBuffer(); } }
EXPORT_C void CImOffLineOperation::SetOperation(TOffLineOpType aOpType, TMsvId aMessageId, TMsvId aTargetMessageId) { DeleteBuffer(); iOpType = aOpType; iMessageId = aMessageId; iTargetMessageId = aTargetMessageId; iMtmFunctionId = 0; }
int Agent_cloud_process(void) { EdpPacket* connect_pkg = NULL; int ret; unsigned char failedcnt = 0; cloud_conn_status.conn_status = SOCK_DONE; #ifndef Devid_RestFul AGAIN: /* 向Onenet服务器发送EDP连接报文 */ connect_pkg = PacketConnect1((char*)SRC_DEVID, (char*)CLOUD_API_KEY); /* dump package data */ log_info("Packet connect data(len:%d):\n", connect_pkg->_write_pos); dump_hex(connect_pkg->_data, connect_pkg->_write_pos); log_info("SRC_DEVID:%s CLOUD_API_KEY:%s\r\n",SRC_DEVID,CLOUD_API_KEY); ret = Socket_TCPClientSendData((char *)connect_pkg->_data, connect_pkg->_write_pos); DeleteBuffer(&connect_pkg); if (ret < 0) { cloud_conn_status.conn_status = CLOUD_CONN_ERROR; log_info("Send connect data failed(ret:%d).\n", ret); failedcnt++; /* 发送连接次数超过3次则退出连接 */ if (failedcnt > 3) { Socket_TCPClientClose(); return -1; } OSTimeDly(50); goto AGAIN; } else { log_notice("Send connect data success.\n"); } #endif /* 主进程用于接收云端服务器的数据 */ while (1) { ret = Socket_TCPClientRecvData(recv_buf, CLOUD_RECV_BUFFER_SIZE); if (ret > 0) { recv_buf[ret] = '\0'; #if (4 & Devid_Mode) //restful方式 log_notice("%s\r\n",recv_buf); RestFul_RecvProcess(recv_buf,ret); #else recv_data_process(recv_buf, ret); #endif } if (ret < 0 || TCPClient_reset_flag == 0xa5 ) { //关闭TCP链接 log_err("Recv tcp client data error(%d)\n", ret); Socket_TCPClientClose(); return -1; } } }
UByte voice_callUser(PPIDType called, PPIDType caller) { ApplicationInstanceType *applicationInstanceData; if (QuickData[called].EmptyMarker == 0) { SignalType * signal; NewSignal(sizeof(SignalType), (void**) &signal); PPID2PMID((PMIDType *) signal->Address, called); applicationInstanceData = getApplicationInstance(signal->Address); if (applicationInstanceData->state == idle) { applicationInstanceData->state = incommingcall; applicationInstanceData->connectedTo = caller; SendSignal((SignalType*) signal, APP_CC_PROCESS_ID, APP_CC_PRIMITIVE, APPCCSetupReq); /*setup the outgoing side of the call:*/ { PMIDType pmid; char tmp[13]; UByte sum = called; PPID2PMID(&pmid, caller); applicationInstanceData = getApplicationInstance(pmid); applicationInstanceData->connectedTo = called; memset(tmp, 0, 12); tmp[0] = sum + '0'; handleConnectPrim(pmid, applicationInstanceData); /*{ AudioLineCtrlReqType *AudioLineCtrlReq; NewSignal(sizeof(AudioLineCtrlReqType), (void **) &AudioLineCtrlReq); AudioLineCtrlReq->TheSignal.Address[0] = 0x0F; AudioLineCtrlReq->TheSignal.Address[1] = 0;//MeInstance->Mcei; AudioLineCtrlReq->Lid = sum; _memcpy(AudioLineCtrlReq->Pmid,pmid,3); AudioLineCtrlReq->option = 3; PrintStatus(0, "\r\napp: send AUDIOLINECTRL_req to mac layer"); SendSignal((SignalType*)AudioLineCtrlReq, CCF_PROCESS_ID, CCF_PRIMITIVE, AUDIOLINECTRL_req); }*/ } return 1; } else { DeleteBuffer(signal); PrintStatus(0, "\r\nnumber found, but user allready active.\n"); return 2; } } else { PrintStatus(0, "\r\nnumber not found..."); return 3; } }
MeshStream::~MeshStream() { if (m_IsLocked) { m_BufferAccess.UnLock(); } DeleteBuffer(); }
//This call could possibly be moved outside of the codec, could allow us to do some type of //direct rendering. problem is that that the buffer requested isn't allways the next one //that should go to display. DVDVideoPicture* CDVDVideoCodecLibMpeg2::GetBuffer(unsigned int width, unsigned int height) { for(int i = 0; i < 3; i++) { if( !(m_pVideoBuffer[i].iFlags & DVP_FLAG_LIBMPEG2_INUSE) ) { if( m_pVideoBuffer[i].iWidth != width || m_pVideoBuffer[i].iHeight != height ) //Dimensions changed.. realloc needed { DeleteBuffer(m_pVideoBuffer+i); } if( !(m_pVideoBuffer[i].iFlags & DVP_FLAG_ALLOCATED) ) { //Need to allocate //First make sure all properties are reset memset(&m_pVideoBuffer[i], 0, sizeof(DVDVideoPicture)); //Allocate for YV12 frame unsigned int iPixels = width*height; unsigned int iChromaPixels = iPixels/4; // If we're dealing with a 4:2:2 format, then we actually need more pixels to // store the chroma, as "the two chroma components are sampled at half the // sample rate of luma, so horizontal chroma resolution is cut in half." // // FIXME: Do we need to handle 4:4:4 and 4:1:1 as well? // if (m_bIs422) iChromaPixels = iPixels/2; m_pVideoBuffer[i].iLineSize[0] = width; //Y m_pVideoBuffer[i].iLineSize[1] = width/2; //U m_pVideoBuffer[i].iLineSize[2] = width/2; //V m_pVideoBuffer[i].iLineSize[3] = 0; m_pVideoBuffer[i].iWidth = width; m_pVideoBuffer[i].iHeight = height; m_pVideoBuffer[i].data[0] = (BYTE*)_aligned_malloc(iPixels, 16); //Y m_pVideoBuffer[i].data[1] = (BYTE*)_aligned_malloc(iChromaPixels, 16); //U m_pVideoBuffer[i].data[2] = (BYTE*)_aligned_malloc(iChromaPixels, 16); //V //Set all data to 0 for less artifacts.. hmm.. what is black in YUV?? memset( m_pVideoBuffer[i].data[0], 0, iPixels ); memset( m_pVideoBuffer[i].data[1], 0, iChromaPixels ); memset( m_pVideoBuffer[i].data[2], 0, iChromaPixels ); } m_pVideoBuffer[i].pts = DVD_NOPTS_VALUE; m_pVideoBuffer[i].iFlags = DVP_FLAG_LIBMPEG2_INUSE | DVP_FLAG_ALLOCATED; //Mark as inuse return m_pVideoBuffer+i; } } //No free pictures found. return NULL; }
/* * @brief EDP协议向自己透传数据,用于测试,将src_dev替换成目标DEVICE ID即可 */ void Push_DataToMyself(void) { EdpPacket* send_pkg; int8_t push_data[] = {44}; printf("%s %d\n", __func__, __LINE__); send_pkg = PacketPushdata(src_dev, push_data, sizeof(push_data)); DoSend(0, (const uint8_t *)send_pkg->_data, send_pkg->_write_pos); DeleteBuffer(&send_pkg); mDelay(1000); }
EXPORT_C void CImOffLineOperation::SetOperation(TOffLineOpType aOpType, TMsvId aMessageId, TMsvId aTargetMessageId, TInt aMtmFunctionId, HBufC8* aParameters) { DeleteBuffer(); iOpType = aOpType; iMessageId = aMessageId; iTargetMessageId = aTargetMessageId; iMtmFunctionId = aMtmFunctionId; iMtmFunctionId = aMtmFunctionId; iMtmParameters = aParameters; }
static void PPAlreadySubscribedHandler(SignalType * Signal) { switch (Signal->Event) { case IWU_PRIMITIVE: { switch (Signal->SubEvent) { case OM_SUBS_SELECT_cfm: { OmSubsSelectCfmType *OmSubsSelectCfm = (OmSubsSelectCfmType *) Signal; if (OmSubsSelectCfm->NotAccepted) { PrintStatus(0, "Login to subscribed base failed!"); } } break; case OM_SUBS_STATUS_ind: { OmSubsStatusIndType *OmSubsStatusInd = (OmSubsStatusIndType *) Signal; if (OmSubsStatusInd->Status & SS_LocRegSucceeded) { PrintStatus(0, "Login to subscribed base completed"); } else if (OmSubsStatusInd->Status & SS_Locked) { PrintStatus(0, "Locked to subscribed base"); } else if (OmSubsStatusInd->Status & SS_Subscripted) { _sprintf_(StatusString, "Subscription number [%02x]", OmSubsStatusInd->SubsNo); PrintStatus(0, StatusString); } } break; case OM_ATTACH_ind: { OmAttachIndType * OmAttachInd = (OmAttachIndType *) Signal; IwuToIwuType * IwuToIwuPtr; IwuToIwuPtr = (IwuToIwuType *) FindInfoElement(IwuToIwuId, getOmAttachIndTypeIE(OmAttachInd) - 2, OmAttachInd->SignalHeader.SignalLength - sizeof(OmAttachIndType) + 2); if (IwuToIwuPtr != NULL) { if (IwuToIwuPtr->ProtocolDiscrim == UserSpecific && IwuToIwuPtr->DiscrimType == UseOfEmc) { StandByTxtIEType *standbyText = (StandByTxtIEType *) FindInfoElement(StandByTxtAPEIEId, getIwuToIwuSIE(IwuToIwuPtr) - 2, OmAttachInd->SignalHeader.SignalLength - sizeof(OmAttachIndType) - sizeof(IwuToIwuType) + 2); if (standbyText) { memcpy(StatusString, standbyText->StandByTxt, standbyText->LengthOfContents); StatusString[standbyText->LengthOfContents] = '\0'; PrintStatus(0, StatusString); } } } setSignalHandler(APPLICATION_PROCESS_ID_PP, PPLockedHandler, 0); } } } break; } DeleteBuffer(Signal); }
IFXINLINE void IFXString::NewBuffer(U32 size) { DeleteBuffer(); if(size) { //m_Buffer = new IFXCHAR[size]; m_Buffer = (IFXCHAR*)IFXAllocate(size * sizeof(IFXCHAR)); if( NULL != m_Buffer ) m_BufferLength = size; } }
void AsyncSocketWrite(SOCKET sock) { int bytes; session_node *s; buffer_node *bn; s = GetSessionBySocket(sock); if (s == NULL) return; if (s->hangup) return; /* dprintf("got async write session %i\n",s->session_id); */ if (WaitForSingleObject(s->muxSend,10000) != WAIT_OBJECT_0) { eprintf("AsyncSocketWrite couldn't get session %i muxSend\n",s->session_id); return; } while (s->send_list != NULL) { bn = s->send_list; /* dprintf("async writing %i\n",bn->len_buf); */ bytes = send(s->conn.socket,bn->buf,bn->len_buf,0); if (bytes == SOCKET_ERROR) { if (GetLastError() != WSAEWOULDBLOCK) { /* eprintf("AsyncSocketWrite got send error %i\n",GetLastError()); */ if (!ReleaseMutex(s->muxSend)) eprintf("File %s line %i release of non-owned mutex\n",__FILE__,__LINE__); HangupSession(s); return; } /* dprintf("got write event, but send would block\n"); */ break; } else { if (bytes != bn->len_buf) dprintf("async write wrote %i/%i bytes\n",bytes,bn->len_buf); transmitted_bytes += bn->len_buf; s->send_list = bn->next; DeleteBuffer(bn); } } if (!ReleaseMutex(s->muxSend)) eprintf("File %s line %i release of non-owned mutex\n",__FILE__,__LINE__); }
void ReallocateBuffer(SIZE_T count) { // count is always > STACKCOUNT here. T * newBuffer = (T *)PAL_malloc((count + 1) * sizeof(T)); if (NULL == newBuffer) { SetLastError(ERROR_NOT_ENOUGH_MEMORY); DeleteBuffer(); m_count = 0; return; } DeleteBuffer(); m_buffer = newBuffer; m_count = count; m_size = count+1; return; }
EXPORT_C void CImOffLineOperation::CopyL(const CImOffLineOperation& aOperation) { DeleteBuffer(); iOpType = aOperation.iOpType; iMessageId = aOperation.iMessageId; iTargetMessageId = aOperation.iTargetMessageId; iMtmFunctionId = aOperation.iMtmFunctionId; if (aOperation.iMtmParameters) { iMtmParameters = aOperation.iMtmParameters->Des().AllocL(); } }
void SessionAddBufferList(session_node *s,buffer_node *blist) { buffer_node *bn,*temp; int length; /* prereq: we must already hold the muxSend for s */ if (s->send_list == NULL) { /* put first node on, then try the compress junk */ s->send_list = blist; blist = blist->next; s->send_list->next = NULL; bn = s->send_list; } else { length = 1; bn = s->send_list; while (bn->next != NULL) { length++; bn = bn->next; } /* dprintf("non-blank send list len %i\n",length); */ /* if currently backed up more than MAX_SESSION_BUFFER_LIST_LEN, then don't waste any more memory on them */ if (length > MAX_SESSION_BUFFER_LIST_LEN) { //dprintf("SessionAddBufferList deleting because buffer list too long %i\n",s->session_id); DeleteBufferList(blist); return; } } /* simple approach: set bn->next to blist. However, this can use up a ton of buffers, when the amount of data to be sent is small. So do a couple discreet checks, and perhaps memcpy's. */ while (blist != NULL && blist->len_buf < (bn->size_prebuf - bn->len_buf - HEADERBYTES)) { /* dprintf("squeezing %i in %i\n",blist->len_buf,bn->size_buf-bn->len_buf); */ memcpy(bn->buf+bn->len_buf,blist->buf,blist->len_buf); bn->len_buf += blist->len_buf; temp = blist->next; DeleteBuffer(blist); blist = temp; } bn->next = blist; }
nsHtml5OwningUTF16Buffer::~nsHtml5OwningUTF16Buffer() { MOZ_COUNT_DTOR(nsHtml5OwningUTF16Buffer); DeleteBuffer(); // This is to avoid dtor recursion on 'next', bug 706932. nsRefPtr<nsHtml5OwningUTF16Buffer> tail; tail.swap(next); while (tail && tail->mRefCnt == 1) { nsRefPtr<nsHtml5OwningUTF16Buffer> tmp; tmp.swap(tail->next); tail.swap(tmp); } }
/* * @brief 发送PING包维持心跳 */ void Ping_Server(void) { EdpPacket *send_pkg; printf("%s %d\n", __func__, __LINE__); /* 组装ping包 */ send_pkg = PacketPing(); DoSend(0, (const uint8_t *)send_pkg->_data, send_pkg->_write_pos); mDelay(500); /* 必须释放这个内存,否则造成泄露 */ DeleteBuffer(&send_pkg); mDelay(100); }
void CDVDVideoCodecLibMpeg2::Dispose() { if (m_pHandle) m_dll.mpeg2_close(m_pHandle); m_pHandle = NULL; m_pInfo = NULL; DeleteBuffer(NULL); m_pCurrentBuffer = NULL; m_irffpattern = 0; m_dll.Unload(); }
IFXString::IFXString(const IFXCHAR* operand) : m_Buffer(NULL), m_BufferLength(0) { if(!operand) { DeleteBuffer(); } else { NewBuffer((U32)wcslen(operand)+1); if (m_Buffer) wcscpy(m_Buffer, operand); } }
EXPORT_C void CImOffLineOperation::InternalizeL( RMsvReadStream& aReadStream ) { DeleteBuffer(); iOpType = TOffLineOpType(aReadStream.ReadInt32L()); iMessageId = TMsvId(aReadStream.ReadInt32L()); iTargetMessageId = TMsvId(aReadStream.ReadInt32L()); iMtmFunctionId = aReadStream.ReadInt32L(); TInt length = aReadStream.ReadInt32L(); if (length > 0) { iMtmParameters = HBufC8::NewL(aReadStream, length); } return; }
/* * @brief EDP协议向Onenet上传湿度信息,数据点格式TYPE=3 */ void Save_HumToOneNet(void) { EdpPacket* send_pkg; uint16_t hum[1]; SHT20_read_user_reg(); mDelay(200);//延迟,设备没有那么快的响应时间,否则总线处理忙等待 SHT2x_MeasureHM(SHT20_Measurement_RH_NHM, hum); printf("%s %d hum:%d\n", __func__, __LINE__, (uint32_t)hum[0]); send_pkg = PacketSavedataInt(kTypeSimpleJsonWithoutTime, NULL, "hum", (uint32_t)hum[0], 0, NULL); DoSend(0, (const uint8_t *)send_pkg->_data, send_pkg->_write_pos); DeleteBuffer(&send_pkg); mDelay(1000); }
IFXString::IFXString(const IFXString* operand) : m_Buffer(NULL), m_BufferLength(0) { if(!operand) { DeleteBuffer(); } else { if (operand->m_BufferLength > 0) { NewBuffer((U32)operand->m_BufferLength); if (m_Buffer) wcscpy(m_Buffer, operand->m_Buffer); } } }
static void PPDialingHandler(SignalType * Signal) { switch (Signal->Event) { case IWU_PRIMITIVE: { switch (Signal->SubEvent) { case CC_CONNECT_prim: { SignalType * startAudio; NewBuffer(sizeof(SignalType), (void**) &startAudio); SendSignal((SignalType*) startAudio, DSP_PROCESS_ID, SETUPAUDIO_EVENT, 0); connected = 1; } case CC_INFO_prim: /*do not break*/ { if (connected == 1) { SignalType* mySignal; NewSignal(sizeof(SignalType) + 2 + strlen(numberToDial), (void **) &mySignal); getSignalData(mySignal)[0] = 0x2c; getSignalData(mySignal)[1] = strlen(numberToDial); memcpy(getSignalData(mySignal) + 2, numberToDial, strlen(numberToDial)); InjectSignal(mySignal, IWU_PROCESS_ID, IWU_PRIMITIVE, CC_INFO_prim, Signal->SessionId); } } break; case CC_RELEASE_prim: { if (connected == 1) { Signal->SignalLength = sizeof(CcReleaseComPrimType); SendSignal(Signal, IWU_PROCESS_ID, IWU_PRIMITIVE, CC_RELEASE_COM_prim); connected = 0; setSignalHandler(APPLICATION_PROCESS_ID_PP, PPconnectionHandler, 0); return; } } break; } } } DeleteBuffer(Signal); }