diff -r 000000000000 -r d0791faffa3f obex/obexprotocol/obextransport/src/ObexReaderBase.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/obex/obexprotocol/obextransport/src/ObexReaderBase.cpp Tue Feb 02 01:11:40 2010 +0200 @@ -0,0 +1,243 @@ +// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// + +#include +#include +#include +#include "logger.h" + +#ifdef __FLOG_ACTIVE +_LIT8(KLogComponent, "OBEXCT"); +#endif + +/** +*Constructor +*/ +EXPORT_C CObexReaderBase::CObexReaderBase(TPriority aPriority, + MObexTransportNotify& aOwner, + TObexConnectionInfo& aInfo) + : CObexActiveRW (aPriority, aOwner, aInfo) + { + LOG_LINE + LOG_FUNC + } + +/** +* Destructor +*/ +EXPORT_C CObexReaderBase::~CObexReaderBase() + { + LOG_LINE + LOG_FUNC + + Cancel(); + } + +/** +This function is a place holder for future use. If the iFuture1 variable is +used it will need this function for any allocation required. + +To prevent binary compatiblity breaks if the iFuture1 variable is used, this +function must be called from the +NewL of derived classes. +*/ +EXPORT_C void CObexReaderBase::BaseConstructL() + { + LOG_LINE + LOG_FUNC + } + +/** +Start transfer. Calls into CObexActiveRW, which eventually queues a read + +@param aPacket The Obex packet to read into. +*/ +EXPORT_C void CObexReaderBase::StartTransfer (CObexPacket& aPacket) + { + LOG_LINE + LOG_FUNC + + // Ensure that we don't try to queue two reads at once (this should probably + // never happen anyway). + if (IsActive()) + { + FLOG(_L("\treturning because already active...")); + return; + } + iGotHeader = EFalse; + // Initial packet size indicates how much data we should ask for on the + // first read + // Packet & stream based transports do the same thing here due to ESOCK + // flexibility. + // See Remaining() and CompleteTransfer() for a clearer picture + iPacketSize = 0; + aPacket.Init(0); + NewRequest (aPacket); + } + +/** +Check if the packet read is complete +@return ETrue if the read is complete. EFalse otherwise. +*/ +EXPORT_C TBool CObexReaderBase::CompleteTransfer () + { + LOG_LINE + LOG_FUNC + + iTransferError = KErrNone; + + // Can't check anything until we have at least the OBEX packet header + if (iCount >= KObexPacketHeaderSize) + {// iCount is the number of bytes read thus far + if (!iGotHeader) + { + iPacketSize = iPacket->PacketSize (); + + // Check packet's claimed size is at least as big as the header just sent + if ( iPacketSize < KObexPacketHeaderSize ) + { + iTransferError = KErrCommsFrame; + return ETrue; + } + TInt maxPacketSize = GetMaxPacketSize(); + LOG1(_L8("\taMaxPacketSize = %d"), maxPacketSize); + if (iPacketSize > maxPacketSize) + {// The peer is sending us a packet thats too large for us + iTransferError = KErrCommsFrame; + return (ETrue); + } + iGotHeader = ETrue; + OnReadActivity(); + } + + + if (iCount >= iPacketSize) + {// We've got the whole packet. + return (ETrue); + } + } + return (EFalse); + + } + +/** + Called when read activity is detected. + This method will certainly be called when read activity is + first detected on an Obex operation, and it may be called + from time to time thereafter until that Obex operation is + completed. +*/ +EXPORT_C void CObexReaderBase::OnReadActivity() + { + iOwner.SignalPacketProcessEvent(EObexReadActivityDetected); + } + +/** Performs any actions necessary on completion of a read. +*/ +EXPORT_C void CObexReaderBase::OnCompleteTransfer() + { + if(iTransferError) + { + iOwner.Error(iTransferError); + } + else + { + iOwner.Process(*iPacket); + } + } + +/* +Returns the number of bytes remaining to be read based on the default packet +size if the packet size is unknown, otherwise based on the packet size + +@return TInt the number of bytes remaining to be read +*/ +EXPORT_C TInt CObexReaderBase::Remaining() + { + LOG_LINE + LOG_FUNC + + + TInt remaining; + + if (iPacketSize == 0) + { + // If we don't know the size of the packet yet, ask for as much as + // an initial or default size (-iCount) specifies + TInt defaultPacketSize = GetInitialPacketSize(); + LOG1(_L8("\taRemainingLimit = %d"), defaultPacketSize); + remaining = defaultPacketSize - iCount; + } + else + { + remaining = iPacketSize - iCount; + } + + if (remaining < 0) + { + remaining = 0; + } + + return remaining; + } + +/** +This function returns the buffer size of the read packet. + +@return TInt the size of the buffer held by the iPacket member variable +*/ +EXPORT_C TInt CObexReaderBase::GetObexPacketBufferSize() + { + return iPacket->BufferSize(); + } + +/** +This function returns the size of the obex packet's header + +@return TInt the size of the obex header +*/ +EXPORT_C TInt CObexReaderBase::GetObexPacketHeaderSize() + { + return KObexPacketHeaderSize; + } + +/** +This function return the maximum limit the received data can be + +@return TInt the data limit of the obex packet +*/ +EXPORT_C TInt CObexReaderBase::GetObexPacketDataLimit() + { + return iPacket->DataLimit(); + } + +/** +This function is part of the extension pattern and is implemented by all +derived instantiable classes that need to extend it's interface. + +By default this returns null. Any derived class that is required to extend its +interface and that of this base class returns its new interface in the form of +an M class, that it extends, if and only if the corresponding TUid, aUid, is +received. Otherwise the function calls the base class implementation, +returning NULL. + +@return TAny* The M Class representing the extension to the interface +otherwise NULL +@param aUid The uid associated with the M Class that is being implemented +*/ +EXPORT_C TAny* CObexReaderBase::GetInterface(TUid /*aUid*/) + { + return NULL; + }