TInt CUptCsvGenerator::FillReferenceBuffer(RBuf8& aBufferName, const TInt& aAppendCount, const RArray<TInt64>& aData1Name, const TInt& aData1Count, const RArray<TInt64>& aData2Name, const TInt& aData2Count) { for(TInt i=0; i!=aAppendCount;i++) { // first line of data for(TInt j=0;j!=aData1Count;j++) { aBufferName.AppendNum(aData1Name[j]); //if(j!=aData1Count-1) if(j!=aData1Count) aBufferName.Append(KCsvComma); } // newline aBufferName.Append(KCsvNewLine); // second line of data with a potentially different number of elements for(TInt j=0;j!=aData2Count;j++) { aBufferName.AppendNum(aData2Name[j]); //if(j!=aData2Count-1) if(j!=aData2Count) aBufferName.Append(KCsvComma); } aBufferName.Append(KCsvNewLine); } return 0; }
/** 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; }
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); }
/** 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); }
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); } }
void CUPnPRControlChannelAO::RunL() { switch ( iState ) { case ERecv: { iTimer->Cancel (); if( iInComingAction.MaxLength() != KErrUnknown ) { if ( iCompleteBuffer.Length() == 0 ) { iCompleteBuffer.CreateL(iInComingAction.MessageDes().Length()); } else { TInt oldLen = iCompleteBuffer.Length(); iCompleteBuffer.ReAlloc ( oldLen + iInComingAction.MessageDes().Length() ); } iCompleteBuffer.Append(iInComingAction.MessageDes()); if( iCompleteBuffer.Length() == iInComingAction.MaxLength() ) { iInComingAction.ClearFlags(); SenddataL(); iState = EStop; } else { iControlChannel.Recv(iInComingAction, iStatus); iState = ERecv; SetActive(); } } else { iExepecteBufLen = iInComingAction.MaxLength(); RBuf8 completeData; completeData.CreateL( iExepecteBufLen ); completeData.Append(iInComingAction.MessageDes()); iControlChannel.Recv(iInComingAction, iStatus); SenddataL(); iState = EStop; } _LIT(KInfoLogFile, "CUPnPRControlChannelAO::RunL().... \n"); iManager->INFO_PRINTF1(KInfoLogFile); } break; case EStop: { CActiveScheduler::Stop(); _LIT(KInfoLogFile1, "CUPnPRControlChannelAO::RunL() Stop.... \n"); iManager->INFO_PRINTF1(KInfoLogFile1); } break; } }
void TBuildPublishAndRootDeviceInfo::DoL ( ) { if ( iContext.Node ( ).PublishInfo ( ) ) { return; } TUpnpMessage::TRegisterRootDevice& msg = message_cast< TUpnpMessage::TRegisterRootDevice > ( iContext.iMessage ); CUPnPDevice* device = static_cast <CUPnPDevice*> ( msg.iPtr ); CStringPoolManager& stringPoolMgr = iContext.Node ().ConnectionProvider ().StringPoolManager (); RStringPool& sp = stringPoolMgr.StringPool ( ); const TStringTable& upnpTable = stringPoolMgr.GetUPnPTable(); CUPnPPublishInfoElement* publishInfo = CUPnPPublishInfoElement::NewL ( ); CleanupStack::PushL ( publishInfo ); publishInfo->SetKeyL( iContext.Node ().ConnectionProvider ().RootDeviceLocation () ); publishInfo->SetSearchTargetL( KRootDevice ( ) ); //upnp:rootdevice publishInfo->SetCacheControlL( KCacheControl ); const TDesC8& udnPtr = device->Property( sp.String ( UPNPDESCRIPTIONXMLTAGS::EUdn, upnpTable ) ); const TDesC8& deviceTypePtr = device->Property( sp.String(UPNPDESCRIPTIONXMLTAGS::EDeviceType,upnpTable ) ); publishInfo->SetUuidL ( udnPtr ); // Set Usn to udn + devicetype TInt len = udnPtr.Length ( ) + KSeperator.iTypeLength + deviceTypePtr.Length ( ); RBuf8 tempBuf; tempBuf.CreateMaxL ( len ); CleanupClosePushL ( tempBuf ); tempBuf.Copy ( udnPtr ); tempBuf.Append ( KSeperator ( ) ); tempBuf.Append ( deviceTypePtr ); publishInfo->SetUsnL( tempBuf ); iContext.Node ( ).SetPublishInfoL ( publishInfo ); // store deviceType in SCPr node for reference in M-Search Response Activity iContext.Node ( ).SetRootDeviceUrnL ( deviceTypePtr ); CleanupStack::PopAndDestroy ( &tempBuf ); CleanupStack::Pop ( publishInfo ); }
void CDnsUpdateOption::ToStringL(RBuf8& aBuf8) const /** * Writes DNS update option data to a string suitable for sending out * on to the network * * @internalTechnology * */ { RBuf8 encodedDomainName; encodedDomainName.CleanupClosePushL(); TDomainNameArray domainNames; CleanupClosePushL(domainNames); domainNames.AppendL(iDomainName); CDomainNameCodec* domainNameEncoder = new(ELeave) CDomainNameCodec(); CleanupStack::PushL(domainNameEncoder); domainNameEncoder->EncodeL(domainNames, encodedDomainName); CleanupStack::PopAndDestroy(domainNameEncoder); CleanupStack::PopAndDestroy(&domainNames); // closes the RBuf8 aBuf8.Zero(); aBuf8.ReAllocL( 3 + encodedDomainName.Length() ); aBuf8.Append((TChar)(iFlags.Value())); aBuf8.Append((TChar)iRCode1); aBuf8.Append((TChar)iRCode2); aBuf8.Append(encodedDomainName); CleanupStack::PopAndDestroy(&encodedDomainName); // closes the array }
void UpnpUuid::GenerateUuidL(RBuf8& aUuid) { // uuid generation TUpnpUuid uuid; TUuidString8 uuidString; UpnpUuid::MakeUuid(uuid); TTime now; now.UniversalTime(); TInt64 randSeed = now.Int64(); TInt randomNum = Math::Rand(randSeed); uuid.iTimeLow = static_cast<TUint32>(randomNum); UpnpUuid::UuidToString(uuid, uuidString); aUuid.CreateL(KUuidString.iTypeLength+KUuidStringLen); aUuid.Copy(KUuidString); aUuid.Append(uuidString); }
void CDomainNameCodec::EncodeL(TDomainNameArray& aNames, RBuf8& aBuf8) { TUint requiredLength = 0; TUint8 nameIdx = 0; for (nameIdx=0;nameIdx<aNames.Count();nameIdx++) { // The total length required for the labels that comprise an // individual domain name needs to take into the length octet // for the initial label and the null-termination character. // Hence the '+ 2' below. requiredLength += (aNames[nameIdx].Length() + 2); // A further length check is performed on each domain name to // ensure it does not exceed the maximum length permitted according // to RFC 1035. if(aNames[nameIdx].Length() > KMaxDomainNameLength) { User::Leave(KErrArgument); } } aBuf8.Zero(); aBuf8.ReAllocL(requiredLength); TLex8 domainName; TPtrC8 currentLabel; for (nameIdx=0;nameIdx<aNames.Count();nameIdx++) { domainName.Assign(aNames[nameIdx]); domainName.Mark(); while (!domainName.Eos()) { TChar ch; do { ch = domainName.Get(); } while ( ch != TChar('.') && !domainName.Eos() ); // if not the end of the string, unget the previous char to skip the trailing // dot in our marked token // if( !domainName.Eos() ) { domainName.UnGet(); } currentLabel.Set(domainName.MarkedToken()); // move past the dot again, or do nothing in particular at EOS // domainName.Get(); User::LeaveIfError(currentLabel.Length() > KMaxDnsLabelLength ? KErrArgument : KErrNone); aBuf8.Append(TChar(currentLabel.Length())); aBuf8.Append(currentLabel); domainName.Mark(); } aBuf8.Append(TChar(0)); } }
// --------------------------------------------------------------------------------- // CUpnpTmServerDeviceXmlParser::StartL // Method which inputs xml formatted buffer content to the XML Parser // and invokes parsing // --------------------------------------------------------------------------------- // void CUpnpTmServerDeviceXmlParser::StartL() { OstTraceFunctionEntry0( CUPNPTMSERVERDEVICEXMLPARSER_STARTL_ENTRY ); TDriveNumber drive = RFs::GetSystemDrive(); //Find system's drive TBuf<UpnpString::KMaxFilenameLength> privatePath; TInt err = iFs.PrivatePath(privatePath); //Find the application's private path // a) If the Private Path is not found (for whatever reasons), // Create a private path in the System Drive if( err == KErrNotFound ) { User::LeaveIfError( iFs.CreatePrivatePath(drive) ); } // b) If Private Path is found but is a read-only or non-persistent drive // Create a private path in the system drive else use it else if( err == KErrNone ) { TDriveInfo driveInfo; User::LeaveIfError( iFs.Drive(driveInfo)); TUint driveAttr = driveInfo.iDriveAtt; if ( driveAttr == KDriveAttRom ) { User::LeaveIfError( iFs.CreatePrivatePath(drive) ); } } else { OstTrace1( TRACE_ERROR, CUPNPTMSERVERDEVICEXMLPARSER_STARTL, "CUpnpTmServerDeviceXmlParser::StartL;err=%d", err ); User::Leave(err); } privatePath.Append(KPublicDevicePath()); err = iFs.MkDirAll(privatePath); if( err && err != KErrAlreadyExists ) { OstTrace1( TRACE_ERROR, DUP1_CUPNPTMSERVERDEVICEXMLPARSER_STARTL, "CUpnpTmServerDeviceXmlParser::StartL;err=%d", err ); User::LeaveIfError(err); } iDeviceDir.CreateL(privatePath); RBuf8 rootDeviceBuf; CleanupClosePushL(rootDeviceBuf); rootDeviceBuf.CreateL(KBufSize); rootDeviceBuf.Append(KRootDeviceXmlLead()); // Appends the device icon list to the device xml buffer const RPointerArray<CUpnpTerminalModeIcon>& deviceList = iDeviceInfo.DeviceIconList(); TInt iconCount = deviceList.Count(); if ( iconCount > KErrNone ) { privatePath.Append(KIconDirectory()); err = iFs.MkDir(privatePath); // Creates icon directory if( err && err != KErrAlreadyExists ) { OstTrace1( TRACE_ERROR, DUP2_CUPNPTMSERVERDEVICEXMLPARSER_STARTL, "CUpnpTmServerDeviceXmlParser::StartL;err=%d", err ); User::LeaveIfError(err); } iIconDirectory.CreateL(privatePath); OstTrace1( TRACE_ERROR, DUP3_CUPNPTMSERVERDEVICEXMLPARSER_STARTL, "CUpnpTmServerDeviceXmlParser::StartL;iconCount=%d", iconCount ); rootDeviceBuf.Append(KStartIconList); for ( TInt i(0); i < iconCount; i++ ) { rootDeviceBuf.Append(KStartIcon); rootDeviceBuf.Append(KStartMimeType); rootDeviceBuf.Append(deviceList[i]->MimeType()); rootDeviceBuf.Append(KEndMimeType); rootDeviceBuf.Append(KStartWidth); rootDeviceBuf.AppendNum(deviceList[i]->Width()); rootDeviceBuf.Append(KEndWidth); rootDeviceBuf.Append(KStartHeight); rootDeviceBuf.AppendNum(deviceList[i]->Height()); rootDeviceBuf.Append(KEndHeight); rootDeviceBuf.Append(KStartDepth); rootDeviceBuf.AppendNum(deviceList[i]->Depth()); rootDeviceBuf.Append(KEndDepth); rootDeviceBuf.Append(KStartUrl); TBuf8<KMaxPath> iconBuf; const TDesC& fileName = deviceList[i]->IconFilename(); iconBuf.Copy(fileName); TBuf8<UpnpString::KDefaultStringLength> iconRelativeUrl(KScpdUrl()); // Extracts the actual input filepath and creates the relative url for the icon // to be provided in the device xml file iconRelativeUrl.Append(KIconPath()); // Extracts only filename and appends the same to url iconRelativeUrl.Append(iconBuf.Mid((iconBuf.LocateReverse(KDirectorySeparator))+1)); rootDeviceBuf.Append(iconRelativeUrl); delete iFileMan; iFileMan = NULL; iFileMan = CFileMan::NewL(iFs) ; // copies icon files to the private device directory User::LeaveIfError(iFileMan->Copy(fileName,iIconDirectory)); rootDeviceBuf.Append(KEndUrl); rootDeviceBuf.Append(KEndIcon); } rootDeviceBuf.Append(KEndIconList); } rootDeviceBuf.Append( iDeviceInfo.DeviceInfo()); rootDeviceBuf.Append( KRootDeviceXmlTrail() ); ParseL(*iParser, rootDeviceBuf ); CleanupStack::PopAndDestroy(&rootDeviceBuf); OstTraceFunctionExit0( CUPNPTMSERVERDEVICEXMLPARSER_STARTL_EXIT ); }
// -------------------------------------------------------------------------------------- // Serializes TXmlEngNode to buffer // -------------------------------------------------------------------------------------- // TInt CXmlEngSerializerXOP::SerializeL( RBuf8& aBuffer, const TXmlEngNode aRoot, const TXmlEngSerializationOptions& aOptions ) { if(aBuffer.Length()) { aBuffer.Close(); } LeaveIfXopIncludeL(aRoot); iDataContainerArray.Reset(); if(aOptions.iDataSerializer) { return CXmlEngSerializer::SerializeL(aBuffer, aRoot, aOptions); } TXmlEngSerializationOptions opt = aOptions; opt.iDataSerializer = this; RBuf8 xopDocument; CleanupClosePushL(xopDocument); aRoot.OwnerDocument().SaveL(xopDocument, aRoot, opt); if( iCleanXOPInfoset ) { if(xopDocument.Size() > aBuffer.MaxSize()) { aBuffer.ReAllocL( xopDocument.Size() ); } aBuffer.Append(xopDocument); } else { // adjust buffer size TInt bufSize = KXOPDocumentStart().Size() + KMimeRoot().Size() + xopDocument.Size() + KXOPDocumentEnd().Size(); for(TInt j = 0; j < iDataContainerArray.Count(); j++) { TPtrC8 contentTypeStr; if(GetContentTypeValue(iDataContainerArray[j], contentTypeStr)) { bufSize += KMimeHeaderContentType().Size() + contentTypeStr.Size() + KNewLine().Size(); } bufSize += KMimeHeaderStart().Size() + KMimeHeaderContentIdStart().Size() + iDataContainerArray[j].Cid().Length() + KMimeHeaderContentIdEnd().Size() + KNewLine().Size() + iDataContainerArray[j].Size(); } if (bufSize > aBuffer.MaxSize()) { aBuffer.ReAllocL( bufSize ); } // write to buffer aBuffer.Append(KXOPDocumentStart()); aBuffer.Append(KMimeRoot()); aBuffer.Append(xopDocument); for(TInt i = 0; i < iDataContainerArray.Count(); i++) { aBuffer.Append(KMimeHeaderStart); TPtrC8 contentTypeStr; if(GetContentTypeValue(iDataContainerArray[i], contentTypeStr)) { aBuffer.Append(KMimeHeaderContentType); aBuffer.Append(contentTypeStr); aBuffer.Append(KNewLine); } aBuffer.Append(KMimeHeaderContentIdStart); aBuffer.Append(iDataContainerArray[i].Cid()); aBuffer.Append(KMimeHeaderContentIdEnd); aBuffer.Append(KNewLine); switch(iDataContainerArray[i].NodeType()) { case TXmlEngNode::EBinaryContainer: { if(opt.iOptions & TXmlEngSerializationOptions::KOptionDecodeBinaryContainers ) { HBufC8* decodedData = CreateDecodedBufLC(iDataContainerArray[i].AsBinaryContainer().Contents()); aBuffer.Append(decodedData->Des()); CleanupStack::PopAndDestroy(); //decodedData } else { aBuffer.Append(iDataContainerArray[i].AsBinaryContainer().Contents()); } break; } case TXmlEngNode::EChunkContainer: { TPtrC8 data = TPtrC8( ((RChunk&)iDataContainerArray[i].AsChunkContainer().Chunk()).Base() + iDataContainerArray[i].AsChunkContainer().ChunkOffset(), iDataContainerArray[i].AsChunkContainer().Size()); if(opt.iOptions & TXmlEngSerializationOptions::KOptionDecodeBinaryContainers ) { HBufC8* decodedData = CreateDecodedBufLC(data); aBuffer.Append(decodedData->Des()); CleanupStack::PopAndDestroy(); //decodedData } else { aBuffer.Append(data); } break; } case TXmlEngNode::EFileContainer: { TInt size = iDataContainerArray[i].AsFileContainer().Size(); HBufC8* data = HBufC8::NewLC(size); TPtr8 dataPtr = data->Des(); iDataContainerArray[i].AsFileContainer().File().Read(dataPtr, size); if(opt.iOptions & TXmlEngSerializationOptions::KOptionDecodeBinaryContainers ) { HBufC8* decodedData = CreateDecodedBufLC(dataPtr); aBuffer.Append(decodedData->Des()); CleanupStack::PopAndDestroy(); //decodedData } else { aBuffer.Append(dataPtr); } CleanupStack::PopAndDestroy(); //data break; } } } aBuffer.Append(KXOPDocumentEnd); } CleanupStack::PopAndDestroy(); //xopDocument return aBuffer.Size(); }
void CDHCPMessageHeaderIP4::FinishL(TDesC8& aClientId) /** * Put finishing touches to message for sending * Basically copies in the magic cookie (99.130.83.99) * and the end marker then set the length of the descriptor * as we have been pushing data into the descriptor manually * * @param aClientId The client ID string to be added to the message * @see RFC 2131 for explanation of the magic cookie! * * @internalTechnology */ #endif //SYMBIAN_NETWORKING_DHCP_MSG_HEADERS { __CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPMessageBase::FinishL"))); #ifdef SYMBIAN_NETWORKING_DHCPSERVER if(!iDHCPServerImpl) { #endif // SYMBIAN_NETWORKING_DHCPSERVER TUint8 reqListArray[KDhcpParameterRequestListLen] = {EDHCPHostName, EDHCPDomainNameServer, EDHCPDomainName, EDHCPSubnetMask, EDHCPRouter, EDHCPBroadcastAddr, EDHCPSIPServers}; TPtr8 ptr(reqListArray, KDhcpParameterRequestListLen, KDhcpParameterRequestListLen); // +++++++++++++++++++++++ Client ID +++++++++++++++++++++++++++++++++++++++++/ AddOptionL(EDHCPClientID, aClientId.Length())->GetBodyDes().Copy(aClientId); #ifdef SYMBIAN_NETWORKING_DHCP_MSG_HEADERS RBuf8 appendOpCodeList; appendOpCodeList.CreateL(ptr); if (aOptionsPtr) { TInt optLen=aOptionsPtr->Length(); appendOpCodeList.ReAllocL(KDhcpParameterRequestListLen+optLen); appendOpCodeList.Append(aOptionsPtr->Ptr(),optLen); } AddOptionL(EDHCPParameterReqList, appendOpCodeList.Length())->GetBodyDes().Copy(appendOpCodeList); appendOpCodeList.Close(); #else // +++++++++++++++++++++++ Parameter Request List ++++++++++++++++++++++++++++/ AddOptionL(EDHCPParameterReqList, ptr.Length())->GetBodyDes().Copy(ptr); #endif // +++++++++++++++++++++++ Maximum message size (2 bytes) ++++++++++++++++++++/ AddOptionL(EDHCPMaxMsgSize, 2)->SetBigEndian(KDhcpMaxMsgSizeIP4); #ifdef SYMBIAN_NETWORKING_DHCPSERVER } #endif // SYMBIAN_NETWORKING_DHCPSERVER TInetAddr magic; _LIT(magicCookie, "99.83.130.99"); User::LeaveIfError(magic.Input(magicCookie)); // essential the magic cookie is correct iCookie.SetLittleEndian(magic.Address()); ASSERT(!iOptions.FindOption(EDHCPEnd)); AddOptionL(EDHCPEnd, 0); //add padding if msg shorter than 300 bytes TInt len=iMsg->Length(); TPtr8 des=iMsg->Des(); if (len<300) { des.AppendFill(EDHCPPad, 300-len); } }
void CServerCrashDataSource::SetRegValuesL( const TUint64 aThreadId, RRegisterList &aRegisterList ) { LOG_MSG2("->CServerCrashDataSource::SetRegValuesL(aThreadId=%Lu)\n", aThreadId); TInt numberOfRegisters = aRegisterList.Count(); RBuf8 ids; ids.CreateL( numberOfRegisters * sizeof(TFunctionalityRegister) ); ids.CleanupClosePushL(); TInt totalByteSize = 0; // Keeps track of the number of bytes that we are requesting for( TInt i=0; i < numberOfRegisters; i++ ) { TRegisterInfo reg = (TRegisterInfo)( aRegisterList[i].iId ); // iSize = (0 == 1 byte); (3 == 8 bytes) TInt byteSize = (aRegisterList[i].iSize) << 1; totalByteSize += byteSize; ids.Append( reinterpret_cast<const TUint8*>(®), sizeof(TRegisterInfo) ); } RBuf8 registerValues; registerValues.CreateL( totalByteSize ); registerValues.CleanupClosePushL(); RBuf8 registerFlags; registerFlags.CreateL( numberOfRegisters ); registerFlags.CleanupClosePushL(); LOG_MSG("CServerCrashDataSource::SetRegValuesL - reading registers\n"); User::LeaveIfError(iSecSess.ReadRegisters( aThreadId, ids, registerValues, registerFlags )); // Now copy the values back to the array and mark the availability from the flags TUint8* valuePtr = (TUint8*) registerValues.Ptr(); for( TInt i=0; i < numberOfRegisters; i++ ) { TRegisterData & reg = aRegisterList[i]; switch( reg.iSize ) { case 0: reg.iValue8 = *((TUint8 *)valuePtr); valuePtr += 1; break; case 1: reg.iValue16 = *((TUint16 *)valuePtr); valuePtr += 2; break; case 2: reg.iValue32 = *((TUint32 *)valuePtr); valuePtr += 4; break; case 3: reg.iValue64 = *((TUint64 *)valuePtr); valuePtr += 8; break; } if( EValid == registerFlags[i] ) { reg.iAvailable = ETrue; } else { reg.iAvailable = EFalse; } } CleanupStack::PopAndDestroy(®isterFlags); CleanupStack::PopAndDestroy(®isterValues); CleanupStack::PopAndDestroy(&ids); }
void CMsvPreferredDriveList::Print() { _LIT8(KLtBracket, "["); _LIT8(KRtBracket, "]: DRIVE-NUM: "); _LIT8(KDriveId, " DRIVE-ID: "); _LIT8(KStatus, " STATUS: "); _LIT8(KAvailable, "EMsvMessageStoreAvailableStatus"); _LIT8(KUnavailable, "EMsvMessageStoreUnavailableStatus"); _LIT8(KNotSupported, "EMsvMessageStoreNotSupportedStatus"); _LIT8(KDiskNotAvailable, "EMsvDriveDiskNotAvailableStatus"); _LIT8(KCorruptStore, "EMsvMessageStoreCorruptStatus"); _LIT8(KInvalid, "EMsvInvalidDriveStatus"); RFileLogger logger; if (logger.Connect() == KErrNone) { logger.CreateLog(_L("msgs"), _L("DriveList.txt"), EFileLoggingModeAppend); logger.SetDateAndTime(EFalse, EFalse); logger.Write(_L(" Preferred Drive List:")); logger.Write(_L("--------------------------------")); logger.Write(_L("")); } TInt count = Count(); for(TInt index = 0; index < count; ++index) { RBuf8 text; text.CreateL(100); text.Append(KLtBracket); text.AppendNum(index); text.Append(KRtBracket); text.AppendNum((*iDrives)[index].driveNum); text.Append(KDriveId); text.AppendNum((*iDrives)[index].driveId); text.Append(KStatus); switch((*iDrives)[index].status) { case EMsvMessageStoreAvailableStatus: text.Append(KAvailable); break; case EMsvMessageStoreUnavailableStatus: text.Append(KUnavailable); break; case EMsvMessageStoreNotSupportedStatus: text.Append(KNotSupported); break; case EMsvDriveDiskNotAvailableStatus: text.Append(KDiskNotAvailable); break; case EMsvMessageStoreCorruptStatus: text.Append(KCorruptStore); break; case EMsvInvalidDriveStatus: text.Append(KInvalid); break; } logger.Write(text); text.Close(); logger.Write(_L("")); } logger.CloseLog(); logger.Close(); }
/** This user-side method writes the column titles (from the KLit string defined in the relevent test.cpp to the user-specified csv file, according to the parameters for aTestType. @param aTestType is the enum identifier for the test in question @return KErrNone if command was prepared correctly and a system wide error code otherwise. */ TInt CUptCsvGenerator::WriteHeaderL(const TInt& aTestType) { RBuf8 buf; CleanupClosePushL(buf); TInt numbytes = 0; //test which testtype is to be written and //append the header string to the buffer and write it to the csv file //create general KGeneralHeader? //first identify which test switch(aTestType) { case 0: //KGeneralHeader=KApiCallHeader; //now create a buf large enough to contain the passed data and comma separators numbytes = sizeof(KApiCallHeader); buf.CreateL(numbytes); //append the relevant header to the file buf.Append(KApiCallHeader); break; case 1: //now create a buf large enough to contain the passed data and comma separators numbytes = sizeof(KOutputPluginHeader); buf.CreateL(numbytes); //append the relevant header to the file buf.Append(KOutputPluginHeader); break; case 2: //now create a buf large enough to contain the passed data and comma separators numbytes = sizeof(KOutputPluginHeader); buf.CreateL(numbytes); //append the relevant header to the file buf.Append(KOutputPluginHeader); break; //case 3://to be implemented on next iteration //break; //case 4://to be implemented on next iteration //break; default: // NB: change this to an empty string //now create a buf large enough to contain the passed data and comma separators numbytes = sizeof(KApiCallHeader); buf.CreateL(numbytes); //append the relevant header to the file buf.Append(KApiCallHeader); break; } //now create a buf large enough to contain the passed data and comma separators //numbytes = sizeof(KGeneralHeader); //buf.CreateL(numbytes); //append the relevant header to the file //buf.Append(KGeneralHeader); //append a newline to the buffer in preparation for the data buf.Append(KCsvNewLine); TInt startpos = 0; //go to the start of the file and write the buffer iCsvFile.Seek(ESeekStart, startpos); //nb: put in check incase this overwrites data when appending to a file?? User::LeaveIfError(iCsvFile.Write(buf)); //close and cleanup the heap objects buf.Close(); CleanupStack::PopAndDestroy(&buf); return KErrNone; }