void CTcpServerTestUPnP23::RecvComplete ( RMBufChain& aData )
{
RBuf8 responseBuf;
responseBuf.CreateMax ( aData.Length () );
aData.CopyOut ( responseBuf );
aData.Free ();
if ( responseBuf.FindF ( KExpectedResponse ) != KErrNotFound )
{
iSocketHandler.Recv ();
responseBuf.Close ();
return;
}
if ( responseBuf.FindF ( KResponseData ) == KErrNotFound )
{
iResponse = EFail; // test case failed
}
else
{
iResponse = EPass; // test case passed
}
responseBuf.Close ();
CompleteSelf ( KErrNone );
}
void CCTsyCallControlMultipartyFUNegative::DriverCreateConferenceCallL(RMobilePhone::TMobileService aMobileService, TInt aCallId1, TInt aCallId2)
{
RBuf8 data;
CleanupClosePushL(data);
DriverDialAndHoldFirstCallDialSecondCallL(aMobileService, aCallId1, aCallId2);
TMockLtsyData2<TInt, TInt> createConfData(aCallId1, aCallId2);
createConfData.SerialiseL(data);
iMockLTSY.ExpectL(MLtsyDispatchCallControlMultipartyCreateConference::KLtsyDispatchCallControlMultipartyCreateConferenceApiId, data);
RMobileCall::TMobileCallStatus callStatus = RMobileCall::EStatusConnected;
TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData(
aCallId1, RMobilePhone::EServiceUnspecified, callStatus);
data.Close();
mockCallData.SerialiseL(data);
iMockLTSY.CompleteL(KMockLtsyDispatchCallControlNotifyCallStatusChangeIndId, KErrNone, data);
TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(
aCallId2, RMobilePhone::EServiceUnspecified, callStatus);
data.Close();
mockCallData2.SerialiseL(data);
iMockLTSY.CompleteL(KMockLtsyDispatchCallControlNotifyCallStatusChangeIndId, KErrNone, data);
CleanupStack::PopAndDestroy(1, &data);
} // CCTsyCallControlMultipartyFUNegative::DriverCreateConferenceCallL
void CMockPowerEngine::QueueProcessedEventL(const TInt aCommandId, const TUint8 aTransId, TDesC8& aData)
{
// Request
RBuf8 buffer;
// Request
FurtherProcessEventL(aCommandId, aData);
TMockHwrmPluginData reqData(aTransId,aData);
reqData.SerialiseL(buffer);
// copy serialised data to a HBufC8 pointer
HBufC8* req = HBufC8::New(buffer.Length());
TPtr8 reqPtr = req->Des();
reqPtr = buffer;
// queue that as expected request (take ownership of req)
CMockSYEngine::DoQueueEventL(TMockSYEvent::EMessage,aCommandId,req,KErrNone,EFalse,0);
buffer.Close();
QueueProcessedCompletionL(aCommandId, aTransId, buffer, aData);
// copy serialised data to a HBufC8 pointer
HBufC8* resp = HBufC8::New(buffer.Length());
TPtr8 respPtr = resp->Des();
respPtr = buffer;
// queue that as response (take ownership of req)
CMockSYEngine::DoQueueEventL(TMockSYEvent::ECompletion,aCommandId,resp,KErrNone,EFalse,1);
buffer.Close();
}
void CTcpServerTestUPnP40::RecvComplete ( RMBufChain& aData )
{
RBuf8 responseBuf;
responseBuf.CreateMax ( aData.Length () );
aData.CopyOut ( responseBuf );
aData.Free ();
if ( responseBuf.FindF ( KExpectedResponse3 ) != KErrNotFound )
{
iSocketHandler.Recv ();
responseBuf.Close ();
return;
}
if ( responseBuf.FindF ( KResponseData ) != KErrNotFound )
{
TRAP_IGNORE(iSendChain.CreateL ( KData32 ));
iSocketHandler.Send ( iSendChain );
responseBuf.Close ();
return;
}
if ( responseBuf.FindF ( KExpectedResponse32 ) != KErrNotFound )
{
iResponse = EPass; // test case Passed
}
else
{
iResponse = EFail; // test case failed
}
responseBuf.Close ();
CompleteSelf ( KErrNone );
}
void CTcpClientTestUPnP13::NewData(TUint aCount)
{
RMBufChain data;
RBuf8 resData;
iLogger.WriteFormat(_L("<i>NewData..... </i>"));
iSSP->GetOption(1,KCHMaxLength,resData);
resData.Create( aCount );
iSSP->GetOption(KCHOptionLevel,KCHMaxLength,resData);
TInt len = *(TUint*) resData.Ptr();
resData.Close();
iSSPData->GetData(data,aCount,0);
resData.Create( aCount );
data.CopyOut(resData);
resData.Close();
resData.Create( aCount );
iSSP->GetOption(KCHOptionLevel,KCHLastMessage,resData);
TBool isLastMsg = *(TUint*) resData.Ptr();
resData.Close();
data.Init();
if(isLastMsg)
{
iLogger.WriteFormat(_L("<i>NewData.LastMsg.... </i>"));
CompleteSelf ( KErrNone );
}
}
/*
Tests whether Publishing a Service/Device is performing as specified in UPnP specifications.
@param aOperationType is reference to a section name in ini file where required parameters
needs to be referred for this operation.
@return None.
*/
void CTestRControlChannel::PublishServiceL (const TDesC& aOperationType)
{
_LIT(KInfoLogFile, "CTestRControlChannel::PublishServiceL ().... \n");
INFO_PRINTF1(KInfoLogFile);
CRControlChannelObserver* upnpObserver = CRControlChannelObserver::NewL(this);
CleanupStack::PushL( upnpObserver );
iObserverArray.Append(upnpObserver);
RPnPParameterBundle pnpBundle ;
pnpBundle.Open();
CleanupClosePushL( pnpBundle );
pnpBundle.SetPnPObserver((MPnPObserver*)upnpObserver);
RParameterFamily family = pnpBundle.CreateFamilyL(EUPnPServiceRegisterParamSet);
CUPnPServiceRegisterParamSet* registerServiceParamSet = CUPnPServiceRegisterParamSet::NewL(family );
_LIT(KParentDeviceUid, "ParentDeviceUid");
TPtrC parentDeviceUid;
GetStringFromConfig(aOperationType, KParentDeviceUid, parentDeviceUid);
RBuf8 parentDeviceUidBuf;
parentDeviceUidBuf.Create(parentDeviceUid.Length());
parentDeviceUidBuf.Copy(parentDeviceUid);
registerServiceParamSet->SetDeviceUidL (parentDeviceUidBuf);
TPtrC serviceType;
GetStringFromConfig(aOperationType, KServiceType, serviceType);
RBuf8 serviceTypeBuf;
serviceTypeBuf.Create(serviceType.Length());
serviceTypeBuf.Copy(serviceType);
registerServiceParamSet->SetUriL ( serviceTypeBuf );
TInt duration;
GetIntFromConfig(aOperationType, KCacheControl, duration);
registerServiceParamSet->SetCacheControlData (duration);
ExtractServiceDescriptionL (aOperationType, *registerServiceParamSet);
_LIT8(KInitialMessage, "Initial notification message");
registerServiceParamSet->SetInitialMessageL(KInitialMessage);
OpenPublisherL();
iPublisher.Publish( pnpBundle );
CActiveScheduler::Start();
serviceTypeBuf.Close();
parentDeviceUidBuf.Close();
CleanupStack::PopAndDestroy( &pnpBundle );
CleanupStack::Pop( upnpObserver );
InitiateControlL();
_LIT(KInfoLogFile1, "CTestRControlChannel::PublishServiceL () Stop.... \n");
INFO_PRINTF1(KInfoLogFile1);
}
void SymbianLog::printMessage(const char* level, const char* msg, PLATFORM_VA_LIST argList)
{
iSemaphore.Wait();
StringBuffer currentTime = createCurrentTime(true);
TInt err = file.Open(fsSession, iLogName, EFileWrite|EFileShareAny);
TInt pos = 0;
if (err == KErrNotFound)
{
// First time: file does not exist. Create it.
err = file.Create(fsSession, iLogName, EFileWrite|EFileShareAny);
if (err != KErrNone) {
setErrorF(err, "SymbianLog: could not open log file (code %d)", err);
goto finally;
}
StringBuffer header = createHeader();
RBuf8 data;
data.Assign(stringBufferToNewBuf8(header));
file.Write(data);
data.Close();
}
else
{
err = file.Seek(ESeekEnd, pos);
if (err != KErrNone) {
setErrorF(err, "SymbianLog: seek error on log file (code %d)", err);
goto finally;
}
}
{
// Write the data
StringBuffer line, data;
line.sprintf("%s -%s- %s", currentTime.c_str(), level, msg);
data.vsprintf(line.c_str(), argList);
data.append("\n");
RBuf8 buf;
buf.Assign(stringBufferToNewBuf8(data));
file.Write(buf);
buf.Close();
}
finally:
file.Close();
// we need closed file to operate on it
if ( LogSize() > SYMBIAN_LOG_SIZE ){
// roll log file
RollLogFile();
}
iSemaphore.Signal();
}
int ILibSocketWrapper_recv(int socketObject, char *buffer, int bufferLength)
{
RSocket *s = (RSocket*)SocketArray[socketObject];
RBuf8 *buf = new RBuf8();
TRequestStatus status;
TSockXfrLength aLen;
int RetVal=0;
if(buf->Create(bufferLength)==KErrNone)
{
s->RecvOneOrMore(*buf,0,status,aLen);
User::WaitForRequest(status);
if(status!=KErrNone)
{
RetVal = 0;
}
else
{
RetVal = aLen();
Mem::Copy(buffer,(void*)buf->Ptr(),RetVal);
}
}
buf->Close();
delete buf;
return(RetVal);
}
// -------------------------------------------------------------------------------------
// CUpnpTmClientProfileService::SetClientProfileActionL
// @param aAction Pointer to UPnP action object
// @return Returns upnp error code
// ---------------------------------------------------------------------------------
//
TUpnpErrorCode CUpnpTmClientProfileService::SetClientProfileActionL( CUpnpAction* aAction )
{
OstTraceFunctionEntry0( CUPNPTMCLIENTPROFILESERVICE_SETCLIENTPROFILEACTIONL_ENTRY );
TUint profileIdInt;
// Fetch the value for profile ID argument
TLex8 lex( aAction->ArgumentValue(KProfileId) );
lex.Val(profileIdInt);
OstTrace1( TRACE_ERROR, CUPNPTMCLIENTPROFILESERVICE_SETCLIENTPROFILEACTIONL, "CUpnpTmClientProfileService::SetClientProfileActionL;profileIdInt=%d", profileIdInt );
// Fetch the value for client profile argument
const TDesC8& clientProfile = aAction->ArgumentValue(KClientProfile);
RBuf8 resultProfileBuf;
TTerminalModeErrorCode ret = iTmServerImpl.SetClientProfile( profileIdInt,clientProfile,resultProfileBuf );
if ( ret != ETerminalModeSuccess )
{
resultProfileBuf.Close();
OstTrace0( TRACE_ERROR, DUP1_CUPNPTMCLIENTPROFILESERVICE_SETCLIENTPROFILEACTIONL, "CUpnpTmClientProfileService::SetClientProfileActionL" );
return TUpnpErrorCode( ret );
}
CleanupClosePushL(resultProfileBuf);
aAction->SetArgumentL( KResultProfile , resultProfileBuf );
CleanupStack::PopAndDestroy(&resultProfileBuf);
OstTraceFunctionExit0( CUPNPTMCLIENTPROFILESERVICE_SETCLIENTPROFILEACTIONL_EXIT );
return EHttpOk;
}
/** This user-side method uses the RFile Session methods to find the end of the file described by iCSVFile.
It then appends performance data metrics by element from the passed array, with each element separated by a comma character.
@param aPerformanceData is the constant array of performance data stored as TDesC
@return KErrNone if command was prepared correctly and a system wide error code otherwise.
*/
void CUptCsvGenerator::WriteL(const RArray<TPtrC8>& aPerformanceConfig)
{
// find end of this file, and append the passed data from here.
TInt filesize;
iCsvFile.Size(filesize);
iCsvFile.Seek(ESeekStart, filesize);
RBuf8 buf;
CleanupClosePushL(buf);
//create a buf large enough to contain the passed data and comma separators
TInt numbytes = 5*aPerformanceConfig.Count()*sizeof(TPtrC8);
buf.CreateL(numbytes);
//for the number of elements in the passed array:- append each element, separated by a comma, to the buffer
for(TInt i=0; i!=aPerformanceConfig.Count(); i++) //could replace aPerformance.Count() with structure paramter Parameter.Count
{
buf.Append(aPerformanceConfig[i]);
//may reimplement this
if(i!=aPerformanceConfig.Count())
buf.Append(KCsvComma);
}
//write the buffer to the given file
User::LeaveIfError(iCsvFile.Write(buf));
//close and cleanup the heap objects
buf.Close();
CleanupStack::PopAndDestroy(&buf);
}
// ---------------------------------------------------------------------------
// Data request from CatalogsPCConnectivityPlugin
// First ask the size from server, then give correct size CBufFlat
// ---------------------------------------------------------------------------
//
void RCatalogsPCConnectivityClient::GetDataL(
TDataType& aMimeType, CBufFlat& aData )
{
TPckgBuf<TInt> pckgSize;
TPckgBuf<TDataType> pckgMIME;
User::LeaveIfError( SendReceive(
ECatalogsPCConnectivityGetSize,
TIpcArgs( &pckgMIME, &pckgSize ) ) );
TInt size = pckgSize();
aMimeType = pckgMIME();
RBuf8 desData;
desData.CreateL( size );
desData.CleanupClosePushL();
User::LeaveIfError( SendReceive(
ECatalogsPCConnectivityGetData,
TIpcArgs( &desData ) ) );
aData.Reset();
aData.ExpandL( 0, size );
aData.Write( 0, desData, size );
CleanupStack::Pop(); //desData
desData.Close();
}
void CTcpClientTestUPnP1::ReceivedL ( const TRuntimeCtxId& /*aSender*/, const TNodeId& /*aRecipient*/, TSignatureBase& aMessage )
{
if ( aMessage.IsMessage<TCFFactory::TPeerFoundOrCreated> () )
{
const TCFFactory::TPeerFoundOrCreated& msg = message_cast < const TCFFactory::TPeerFoundOrCreated > ( aMessage );
iClientId = msg.iNodeId;
CompleteSelf ( KErrNone );
}
else if ( aMessage.IsMessage<TUpnpMessage::TResponse > () )
{
TUpnpMessage::TResponse& msg = message_cast< TUpnpMessage::TResponse >(aMessage);
RBuf8 responseBodyData;
responseBodyData.CreateMax ( msg.iBodyData.Length () );
responseBodyData.FillZ ( msg.iBodyData.Length () );
msg.iBodyData.CopyOut ( responseBodyData );
responseBodyData.Close ();
msg.iBodyData.Free ();
CompleteSelf(EPass);
}
else if ( aMessage.IsMessage<TEBase::TError > () )
{
iLogger.WriteFormat(_L("<i>TEBase::TError..... </i>"));
CompleteSelf(EFail);
}
}
void CUptCsvGenerator::WriteApiNameL(const TInt aApiEnum)
{
// find end of this file, and append the passed data from here.
TInt filesize;
iCsvFile.Size(filesize);
iCsvFile.Seek(ESeekStart, filesize);
RBuf8 buf;
CleanupClosePushL(buf);
//create a buf large enough to contain the passed data and comma separators
TInt numbytes = 1024;//2*sizeof(TPtrC8);
buf.CreateL(numbytes);
//read the APIenum (which is the same as the first element of aPerformanceData)
//use this enum value to write the name of the API being tested
TApiNames getApiName;
buf.Append(getApiName.GetApiIdString(aApiEnum));
buf.Append(KCsvComma);
//write the buffer to the given file
User::LeaveIfError(iCsvFile.Write(buf));
//close and cleanup the heap objects
buf.Close();
CleanupStack::PopAndDestroy(&buf);
}
/**
* @see GetInfoCpm test case NET-CONFIGURATOR-I-0018-HP
*
* doTestStepL virtual function does the below action
* Connect to a configurator
* Configurator get the module inidata section. Inidata section contains
module initialisation information in the module's configuration file.
* close the connection to configuator
* Expected:-GetInfoCpm return kerrNone
*/
TVerdict CGetInfoCpm::doTestStepL()
{
SetTestStepResult(EFail);
_LIT8(KNameDummyCpm,"DummyCpm");
RBuf8 data;
data.Create(100);
TInt actualdatasize;
//Configurator call to get the module inidata section
TInt error = iConfigurator.GetModuleIniData(KNameDummyCpm(), data, actualdatasize);
if (error == KErrOverflow)
{
INFO_PRINTF2(_L("GetModuleIniData returned KErrOverflow (%d) \n"), error);
data.ReAlloc(actualdatasize);
error = iConfigurator.GetModuleIniData(KNameDummyCpm(), data, actualdatasize);
}
else if (error == KErrRSModuleUnknown )
{
INFO_PRINTF2(_L("GetModuleIniData returned KErrRSModuleUnknown (%d) \n"), error);
}
else if (error == KErrNone)
{
INFO_PRINTF1(_L("GetModuleIniData Sucessful"));
SetTestStepResult(EPass);
}
else
{
INFO_PRINTF2(_L("GetModuleIniData (DummyCpm) returned Error (%d) \n"), error);
}
data.Close();
return TestStepResult();
}
// ---------------------------------------------------------------------------------
// CUpnpTmAppServerService::LaunchAppActionL
// @param aAction pointer to upnp action object
// @return Returns upnp error code
// ---------------------------------------------------------------------------------
//
TUpnpErrorCode CUpnpTmAppServerService::LaunchAppActionL( CUpnpAction* aAction )
{
OstTraceFunctionEntry0( CUPNPTMAPPSERVERSERVICE_LAUNCHAPPACTIONL_ENTRY );
TUint appIdInt;
TUint profileIdInt;
// Validates the input parameters
if ( ( ConvertDescriptorToInt( aAction->ArgumentValue(KAppId), appIdInt ) != KErrNone )
|| ( ConvertDescriptorToInt( aAction->ArgumentValue(KProfileId), profileIdInt ) != KErrNone ))
{
OstTraceExt2( TRACE_ERROR, CUPNPTMAPPSERVERSERVICE_LAUNCHAPPACTIONL, "CUpnpTmAppServerService::LaunchAppActionL;appIdInt=%u;profileIdInt=%u", appIdInt, profileIdInt );
return EInvalidArgs; // either invalid app ID or invalid profile ID
}
RBuf8 launchUrl;
TTerminalModeErrorCode ret = iTmServerImpl.LaunchApp( appIdInt,profileIdInt,launchUrl );
if ( ret != ETerminalModeSuccess )
{
// Error is returned
launchUrl.Close();
OstTrace0( TRACE_ERROR, DUP1_CUPNPTMAPPSERVERSERVICE_LAUNCHAPPACTIONL, "CUpnpTmAppServerService::LaunchAppActionL" );
return TUpnpErrorCode( ret );
}
CleanupClosePushL(launchUrl);
aAction->SetArgumentL( KAppLaunchUri , launchUrl );
CleanupStack::PopAndDestroy(&launchUrl);
OstTraceFunctionExit0( CUPNPTMAPPSERVERSERVICE_LAUNCHAPPACTIONL_EXIT );
return EHttpOk;
}
void CPlayStatusWatcher::ReceiveUpdate(CInternalCommand& aCommand, TRemConClientId aClientId, RBuf8& aData)
{
LOG_FUNC;
// Read 4 byte Big-Endian error code before the payload
RAvrcpIPCError errorResponse;
TRAPD(err, errorResponse.ReadL(aData));
err = err ? err : errorResponse.iError;
RRemConPlayerInformationGetPlayStatusUpdateResponse response;
if(!err)
{
// Parse the rest of the response (minus error code)
TRAP(err, response.ReadL(aData.RightTPtr(aData.Length() - KLengthErrorResponse)));
}
aData.Close(); // data has been used now
if(!err)
{
iObserver.MpsoPlayStatusChanged(aClientId, response.iStatus);
SendPlayStatusUpdateRequest(aCommand, aClientId, response.iStatus);
}
else
{
// Should never get here with a valid player. This client is
// sending us junk.
iObserver.MpsoError(aClientId);
}
}
/** Decode PDU ID 0x40 - fragmentation support
*/
TInt CControlCommand::ParseContinuingResponse(TPtrC8& aMtPayload,
CAVRCPFragmenter& aFragmenter)
{
// Check if in fragmentation state, return error if not
if (! aFragmenter.InFragmentedState())
{
return KErrAvrcpMetadataInvalidCommand;
}
// Check if the parameter matches the fragmented response
TMetadataTransferPDUID pduId = MetadataTransferParser::GetPDUID(aMtPayload);
if (pduId != aFragmenter.GetPDU())
{
return KErrAvrcpMetadataInvalidParameter;
}
RBuf8 respPayload;
CAVCFrame* frame = NULL;
TRAPD(err, frame = CAVCVendorDependentResponse::NewL(KBluetoothSIGVendorId));
err = respPayload.Create(KAVCMaxVendorDependentPayload); //longest resp
if (err == KErrNone)
{
respPayload.Append(aFragmenter.GetNextFragmentHeader());
respPayload.Append(aFragmenter.GetNextFragment());
frame->SetType(AVC::EStable);
frame->Append(respPayload);
delete iFrame;
iFrame = frame;
respPayload.Close();
}
else
return KErrAvrcpMetadataInternalError;
return KErrAvrcpHandledInternallyRespondNow;
}
/**
* @SYMTestCaseID BA-CTSYD-DIS-SMS-NEGATIVE-UN0001
* @SYMComponent telephony_ctsy
* @SYMTestCaseDesc Test handing in CTSY dispatch when the NackSmsStored API is disabled
* @SYMTestPriority High
* @SYMTestActions Disable API, call API, check correct error returned
* @SYMTestExpectedResults Pass
* @SYMTestType CT
*/
void CCTsySmsFUNegative::TestNackSmsStoredL()
{
TConfig config;
config.SetSupportedValue(MLtsyDispatchSmsNackSmsStored::KLtsyDispatchSmsNackSmsStoredApiId, EFalse);
config.PushL();
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMobileSmsMessaging messaging;
TInt err = messaging.Open(iPhone);
ASSERT_EQUALS(KErrNone, err);
CleanupClosePushL(messaging);
RBuf8 data;
CleanupClosePushL(data);
TRequestStatus reqStatus;
TRequestStatus mockLtsyStatus;
RMobileSmsMessaging::TMobileSmsReceiveAttributesV1 receiveAttr;
RMobileSmsMessaging::TMobileSmsReceiveAttributesV1Pckg receiveAttrPckg(receiveAttr);
_LIT8(KMessage, "Happy New Year");
TBuf8<100> forMsg;
// receiving message:
messaging.ReceiveMessage(reqStatus, forMsg, receiveAttrPckg);
TSmsMsg smsMsg;
TSmsMsg* smsMsgPtr(&smsMsg);
TBool ind(EFalse);
smsMsg.iSmsClass2 = ETrue;
smsMsg.iDeleteAfterClientAck = ETrue;
smsMsg.iSmsMsg.Copy(KMessage);
TMockLtsyData2<TBool, TSmsMsg*> compTsyData(ind, smsMsgPtr);
compTsyData.SerialiseL(data);
iMockLTSY.CompleteL(KMockLtsyDispatchSmsNotifyReceiveSmsMessageIndId, KErrNone, data);
User::WaitForRequest(reqStatus);
ASSERT_EQUALS(KErrNone, reqStatus.Int());
AssertMockLtsyStatusL();
TDesC8* msgPtr = const_cast<TDesC8*>(&KMessage);
TInt rpCause(0);
TMockLtsyData2<TDesC8*, TInt> expTsyData(msgPtr, rpCause);
data.Close();
expTsyData.SerialiseL(data);
messaging.NackSmsStored(reqStatus, KMessage, rpCause);
User::WaitForRequest(reqStatus);
ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(4, &config); // messaging, this, data, config
}
void CSandboxSession::ServiceL(const RMessage2 &aMessage)
{
if (aMessage.Function() >= EMaxArgs)
{
aMessage.Complete(KErrArgument);
return;
}
if (aMessage.Function() == EGetRecog2)
{
aMessage.WriteL(0, iBuf);
iBuf.Close();
aMessage.Complete(KErrNone);
}
else if (aMessage.Function() == EGetRecog)
{
if (iBuf.MaxLength() == 0)
{
iBuf.ReAllocL(1024); // Must be > sizeof(TDataType) otherwise the reallocating logic below is flawed
}
TUid uid = TUid::Uid(aMessage.Int0());
TUid destructorKey;
CApaDataRecognizerType* rec = static_cast<CApaDataRecognizerType*>(REComSession::CreateImplementationL(uid, destructorKey));
TInt count = rec->MimeTypesCount();
for (TInt j = 0; j < count; j++)
{
TDataType type = rec->SupportedDataTypeL(j);
TPckg<TDataType> buf(type);
if (iBuf.Length() + buf.Length() >= iBuf.MaxLength())
{
iBuf.ReAllocL(iBuf.MaxLength() * 2);
}
iBuf.Append(buf);
}
aMessage.Complete(iBuf.Size());
}
else if (aMessage.Function() == ECloseServer)
{
aMessage.Complete(KErrNone);
CActiveScheduler::Stop();
}
else if (aMessage.Function() == EGetVTablePtr)
{
TUid destructorKey;
TAny* obj = NULL;
obj = REComSession::CreateImplementationL(TUid::Uid(aMessage.Int0()), destructorKey);
TAny* vtablePtr = *((TAny**)obj);
TPckg<TAny*> res(vtablePtr);
aMessage.WriteL(1, res);
aMessage.Complete(KErrNone);
}
else
{
ASSERT(0);
}
}
int32_t FSocket::readBuffer(int8_t* buffer, int32_t maxLen)
{
StringBuffer errorMsg;
RBuf8 data;
data.CreateL(maxLen);
// Receives data from a remote host and completes when data is available.
TSockXfrLength len;
iSocket.RecvOneOrMore(data, 0, iStatus, len);
User::WaitForRequest(iStatus);
TInt msgLen = len();
if (iStatus == KErrNone) {
if (msgLen <= maxLen) {
// OK. Copy the message into the preallocated buffer.
memcpy(buffer, data.Ptr(), msgLen);
data.Close();
return msgLen;
}
else {
errorMsg.sprintf("FSocket: error reading, message too big (%d > %d) -> rejected.",
(int)msgLen, (int)maxLen);
goto error;
}
}
else if (iStatus == KErrEof) {
// Either the remote connection is closed, or the socket has been shutdown.
errorMsg = "FSocket: read interrupted (connection closed)";
goto error;
}
else {
errorMsg.sprintf("FSocket: error reading on socket (status = %d)", iStatus.Int());
goto error;
}
error:
LOG.error("%s", errorMsg.c_str());
buffer = NULL;
data.Close();
return -1;
}
// ---------------------------------------------------------
// CMMKeyBearer::SendResponse()
//
// ---------------------------------------------------------
//
TInt CMMKeyBearer::SendResponse(TUid /* aInterfaceUid */,
TUint /*aOperationId*/,
TUint /*aTransactionId*/, // we don't care about this transaction ID
RBuf8& aData ,
const TRemConAddress& /*aAddr*/)
{
FUNC_LOG;
aData.Close();
return KErrNone;
}
TInt GetRecogniserInfo(TUid aImplementationUid, RArray<TDataType>& aMimeTypes)
{
TInt size = SendReceive(EGetRecog, TIpcArgs(aImplementationUid.iUid));
if (size < 0) return size;
TInt err = aMimeTypes.Reserve(size/sizeof(TDataType));
if (err) return err;
RBuf8 buf;
err = buf.Create(size);
if (err) return err;
err = SendReceive(EGetRecog2, TIpcArgs(&buf));
if (err) { buf.Close(); return err; }
const TDataType* ptr = (const TDataType*)buf.Ptr();
for (TInt i = 0; i < size/sizeof(TDataType); i++)
{
err = aMimeTypes.Append(ptr[i]);
if (err) break;
}
buf.Close();
return err;
}
bool ChatSessionImpl::sendChatData(QString newChatData)
{
TPtrC16 dataPtr(reinterpret_cast<const TUint16*>(newChatData.utf16()));
RBuf8 chatData;
chatData.Create(300);
chatData.Copy(dataPtr);
mMessageSource->SendDataL(chatData);
chatData.Close();
return true;
}
void CCSatRefreshFU::PrepareRefreshDispatchL()
{
RBuf8 data;
CleanupClosePushL(data);
TUint8 pcmdCode = KRefresh;
TMockLtsyData1<TUint8> expLtsyData(pcmdCode);
expLtsyData.SerialiseL(data);
iMockLTSY.ExpectL(MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId,data);
data.Close();
CleanupStack::PopAndDestroy(1);
}
void CCSatRefreshFU::CompleteRefreshDispatchL(const TDesC8& aTlvDsc, TInt aRes)
{
RBuf8 data;
CleanupClosePushL(data);
TDesC8* tlvDscPtr = const_cast<TDesC8*>(&aTlvDsc);
TMockLtsyData1<TDesC8*> tlvDscPack(tlvDscPtr);
tlvDscPack.SerialiseL(data);
iMockLTSY.CompleteL(KMockLtsyDispatchSatPcmdIndId, aRes, data, KDelay);
data.Close();
CleanupStack::PopAndDestroy(1);
}
void CTestRControlChannel::ExtractServiceDescriptionL (const TDesC& aConfigSection, CUPnPServiceRegisterParamSet& aServiceRegisterParamSet)
{
RFs fs;
RFile file;
RBuf8 buf;
User::LeaveIfError(fs.Connect());
CleanupClosePushL(fs);
TPtrC descriptionPath;
_LIT(KDescriptionPath, "Description_Path");
GetStringFromConfig(aConfigSection, KDescriptionPath, descriptionPath);
TInt err = file.Open(fs, descriptionPath, EFileShareReadersOnly);
// For Hardware system path is c:, so descriptionPath value present in '.ini' is referring 'c:'
if ( err == KErrPathNotFound )
{
RBuf fileName;
TDriveName aSystemDrive;
TDriveUnit driveunit(RFs::GetSystemDrive());
aSystemDrive.Zero();
aSystemDrive=driveunit.Name();
fileName.CreateL ( descriptionPath.Length () );
fileName.Zero();
fileName.Append(aSystemDrive);
fileName.Append ( descriptionPath.Mid ( aSystemDrive.Length () ) );
err = file.Open(fs, fileName, EFileShareReadersOnly);
}
if (err != KErrNone)
{
User::LeaveIfError(err);
}
CleanupClosePushL(file);
TInt fileSize = 0;
file.Size(fileSize);
buf.Create(fileSize);
err = file.Read(buf, fileSize);
aServiceRegisterParamSet.SetServiceDescriptionL ( buf );
CleanupStack::PopAndDestroy(2 );
buf.Close();
_LIT(KInfoLogFile, "CRControlChannelObserver::ExtractServiceDescriptionL End.... \n");
INFO_PRINTF1(KInfoLogFile);
}
EXPORT_C SMetaDataNetCtor* SMetaDataNetCtorExt::LoadL(TPtrC8& aDes)
{
TUint8* ptr = const_cast<TUint8*> ( aDes.Ptr() );
TPtr8 ptr2 ( ptr, aDes.Length() );
RBuf8 buf;
buf.CreateL(aDes);
TPtrC8 ptr3 (buf.Ptr(), buf.Length());
CMetaDataVirtualCtorInPlace* vctr = SockManGlobals::Get()->SelfWorker()->TransportGlobals().VirtualCtor();
SMetaDataNetCtor* meta = vctr->New(ptr3, ptr2);
TInt len = buf.Length() - ptr3.Length();
aDes.Set(aDes.Ptr() + len, aDes.Length() - len);
buf.Close();
return meta;
}
TInt InternalizeDesL(RBuf8& aDes, RReadStream& aStream)
{
TInt length = aStream.ReadInt32L();
aDes.Close();
if (length > 0)
{
aDes.CreateL(aStream, length);
}
else
{
aDes.CreateL(KNullDesC8);
}
return length;
}
int main()
{
__UHEAP_MARK;
{
_LIT(myTlitc,"hellohello");
wchar_t* myWchar = new wchar_t[30];
int size = 30;
int retval[10];
retval[0] = Tlitc16ToWchar(myTlitc,myWchar,size);
RBuf8 buf;
buf.CreateL(60);
retval[1] = WcharToRbuf8(myWchar,buf);
wstring str;
retval[2] = Rbuf8ToWstring(buf,str);
TBuf16 <30> tbuf;
retval[3]= WstringToTbuf16(str,tbuf);
wchar_t* myfinalstring= new wchar_t[15];
int size_new=15;
retval[4]= Tbuf16ToWchar(tbuf,myfinalstring,size_new);
for(int i=1; i<=4; i++)
{
if (retval[i]!= 0)
printf("Conversion failed for retval\n",retval[i]);
}
if(!wcscmp(myWchar,myfinalstring))
{
printf("\n\n\nintegration_test_scenario27 success");
}
else
{
assert_failed = true;
printf("\n\n\nintegration_test_scenario27 failure");
}
delete[] myWchar;
buf.Close();
delete[] myfinalstring;
}
__UHEAP_MARKEND;
testResultXml("integration_test_scenario27");
return 0;
}
TInt CGavdp::AddSEPCapability(const TAvdtpServiceCapability& aCapability)
{
__ASSERT_ALWAYS(iState==EConfiguringLocalSEP || iState==EConfiguringRemoteSEP,
Panic(EGavdpBadState));
// convert into protocol form - this is a handy way to get a descriptor for IPC purposes
// if AVDTP requires the reverse operation it is of course allowed to get back to the T class form
RBuf8 buf;
TInt err = aCapability.AsProtocol(buf);
if (err==KErrNone)
{
err = AvdtpRequester().SetOpt(EAddCapabilitySelection,KSolBtAVDTPSignalling, buf);
}
buf.Close();
return err;
}
