--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/obex/obexprotocol/obex/src/obexserver.cpp	Tue Feb 02 01:11:40 2010 +0200
@@ -0,0 +1,1588 @@
+// Copyright (c) 1997-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:
+//
+
+/**
+ @file
+ @internalComponent
+*/
+
+#include <charconv.h>
+#include <utf.h>
+#include <obex/internal/obexinternalheader.h>
+#include <obextransportinfo.h>
+#include <obex.h>
+#include <obex/internal/obexpacket.h>
+#include <obex/transport/obextransportcontrollerbase.h>
+#include <obex/internal/obextransportconstants.h>
+#include <obex/extensionapis/mobexserverrequestpacketnotify.h>
+#include <obex/internal/mobexserverrequestpacketnotifyregister.h>
+#include "logger.h"
+#include "obexsetpathdata.h"
+#include "OBEXUTIL.H"
+#include "authentication.h"
+#include "obexnotifyhandlerserver.h"
+#include "obexserverstatemachine.h"
+#include "obexservernotifysyncwrapper.h"
+#include "obexheaderutil.h"
+#include "obexserverrequestpacketengine.h"
+#include "obexpacketsignaller.h"
+
+#ifdef __FLOG_ACTIVE
+_LIT8(KLogComponent, "OBEX");
+#endif
+
+/**
+Constructor - set initial values 
+@internalTechnology
+*/
+CObexServer::CObexServer() : CObex()
+	{
+	iCurrentOperation = EOpIdle;
+	iEnabled = EFalse;
+
+	//the connectionID is fixed at the moment
+	ResetConnectionID();
+	SetConnectionID(0xc30fa596);
+
+	iTargetChecking = EIfPresent;
+	}
+
+void CObexServer::ConstructL(TObexTransportInfo& aObexTransportInfo)
+	{
+	CObex::ConstructL(aObexTransportInfo);
+	iNotifyHandler = new(ELeave)CObexNotifyHandlerServer(*this);
+	iTransportController->SetOwner(*iNotifyHandler);
+
+	iHeader = CObexHeader::NewL();
+	iStateMachine = CObexServerStateMachine::NewL(*this, *iTransportController);
+	iSyncWrapper = CObexServerNotifySyncWrapper::NewL(*this, *iStateMachine);
+	iPacketProcessSignaller = CObexPacketSignaller::NewL();
+	}
+
+/**
+Destructor. 
+*/
+CObexServer::~CObexServer()
+	{
+	FLOG(_L("CObexServer Destructor\r\n"));
+	Stop();
+	
+	delete iPacketProcessSignaller;
+	delete iSyncWrapper;
+	delete iStateMachine;
+	delete iHeader;
+	delete iNotifyHandler;
+	delete iServerRequestPacketEngine;
+	}
+
+void CObexServer::ResetConnectionID()
+	{
+	iConnectionID = KConnIDInvalid;
+	iConnectionIdSet = EFalse;
+	}
+
+void CObexServer::SetConnectionID(TUint32 aConnectionID)
+	{
+	iConnectionID = aConnectionID;
+	iConnectionIdSet = ETrue;
+	}
+
+TUint32 CObexServer::ConnectionID()
+	{
+	return (iConnectionID);
+	}
+
+TInt CObexServer::PrepareFinalChallResponse(CObexPacket& aPacket, TConnectState& aNextState)
+	{
+
+	FLOG(_L("CObexServer::PrepareFinalChallResponse\r\n"));
+
+	aPacket.SetOpcode(ERespSuccess); 
+
+	TInt retValue = AddConnectionIDHeader(aPacket);	
+	if (retValue == KErrNone)
+		{
+		FLOG(_L("PrepareFinalChallResponse ConnectionID header Added\r\n"));
+		if (iCallBack)
+			{
+			FLOG(_L("PrepareFinalChallResponse Requesting User Password\r\n"));
+
+			//the actual asking of the password happens later in the method OnPacketReceive
+			//wait for the reply
+			aNextState = EWaitForUserInput;
+			retValue = KErrGeneral; //mustn't send yet wait for reply from user
+			}
+		else //else can't Auth challenge so drop link
+			{
+			FLOG(_L("PrepareFinalChallResponse Can't request User Password for Chall dropping link\r\n"));
+
+			retValue = KErrIrObexConnectChallRejected;
+			aNextState = EConnTransport;
+			aPacket.SetOpcode(ERespNotImplemented);
+			}
+		}
+	else
+		{
+		aNextState = EDropLink;
+		}
+	return (retValue);
+	}
+
+
+/** A call back from the the service with the password required for use with generating 
+the challenge response. 
+
+@param aPassword Password
+
+@leave KErrNotReady if this function is not called from a MObexAuthChallengeHandler::GetUserPasswordL callback.
+
+@publishedAll
+@released
+*/
+EXPORT_C void CObexServer::UserPasswordL(const TDesC& aPassword)
+	{
+	LOG_LINE
+	LOG_FUNC
+
+	//now have a password, get a nonce, and get it hashed then reply
+	if (GetConnectState() == EWaitForUserInput)
+		{
+		FLOG(_L("CObexServer::UserPasswordL\r\n"));
+		PrepareChallResponseL(aPassword);
+		FLOG(_L("UserPasswordL - PrepareChallResponse Success\r\n"));
+
+		TObexInternalHeader hdr;
+		hdr.Set(TObexInternalHeader::EAuthResponse, (const_cast<TUint8*> (iOutgoingChallResp.Ptr())), iOutgoingChallResp.Size());
+		if(iTransportController->SendPacket().InsertData(hdr))
+			{
+			FLOG(_L("UserPasswordL Inserting EAuthResponse Header\r\n"));
+
+			SetConnectState(EConnObex); //all finished
+			iTransportController->SendPacket().SetFinal();
+			iTransportController->Send();
+			//inform the client that the connection was succesfull
+			iOwner->ObexConnectIndication(iRemoteInfo, TPtr8(NULL, 0));
+			iStateMachine->ConnectionComplete();
+			}
+		else
+			{
+			User::Leave(KErrGeneral);
+			}
+		}
+	else
+		{
+		User::Leave(KErrNotReady);
+		}
+	}
+
+
+TInt CObexServer::AddConnectionIDHeader(CObexPacket& aPacket)
+	{
+	TInt retValue = KErrNone;
+	//if the Target header was used for the connection
+	//then reply with ConnectionID and Who headers
+	if(iTargetReceived)
+		{
+		//this solution can only handle one connection at a time therefore
+		//can safely use the same connection ID repeatedly
+		//when used the ConnectionID must be first
+		TObexInternalHeader hdr;
+		FLOG(_L("CObexServer::AddConnectionIDHeader Inserting EConnectionID Header\r\n"));
+ 
+ 		hdr.Set(TObexInternalHeader::EConnectionID, iConnectionID);
+		
+		if(aPacket.InsertData(hdr))
+			{ 
+			// Connection ID header inserted correctly
+			// Now set a WHO header.
+			// This logic is a bit backwards due to problems with the 'no target header checking'
+			// state.  Instead of inserting our local Who header, we copy the Target header back.
+			// This works in the checking states because we drop any connection where the local
+			// Who is not identical to the Target header received.
+			// When not checking targets, this may mean that the client gets connected to a server
+			// which knows nothing about the service, yet thinks it is talking to a strict peer.
+			// However the server wouldn't understand what was going on anyway, so we're not really
+			// in a worse state than we would be if we did something more fancy.  Ultimately the
+			// application must drop the connection---probably by deleting the Obex server or
+			// returning errors to all attempted operations.
+			
+			FLOG(_L("CObexServer::AddConnectionIDHeader Inserting EWho Header\r\n"));
+
+			hdr.Set(TObexInternalHeader::EWho, (const_cast<TUint8*> (iRemoteInfo.iTargetHeader.Ptr())), 
+																iRemoteInfo.iTargetHeader.Size());
+			if(!aPacket.InsertData(hdr))
+				{
+				retValue = KErrGeneral;
+				}
+			}
+		else
+			{
+			retValue = KErrGeneral;
+			}
+		}
+	return (retValue);
+	}
+
+/**
+Allocates and constructs a new OBEX server object.
+
+The received protocol information object, aObexProtocolInfoPtr, specifies the 
+transport protocol to use:
+For the standard transports the following are used, TObexIrProtocolInfo for 
+IrDA, TObexBluetoothProtocolInfo for Bluetooth, TObexUsbProtocolInfo for USB.
+
+@param aObexProtocolInfoPtr Protocol information object describing the 
+transport to use
+@return New OBEX server object 
+
+@publishedAll
+@released
+*/
+EXPORT_C CObexServer* CObexServer::NewL(TObexProtocolInfo& aObexProtocolInfoPtr)
+	{
+	LOG_LINE
+	LOG_STATIC_FUNC_ENTRY
+
+	TObexProtocolPolicy defaultProtocolPolicy;	// no packet sizing policy specified, so use default		
+	TObexTransportInfo* transportInfo = IrOBEXUtil::CreateTransportInfoL(aObexProtocolInfoPtr, defaultProtocolPolicy);
+	CleanupStack::PushL(transportInfo);
+	CObexServer* server = CObexServer::NewL(*transportInfo);
+	CleanupStack::PopAndDestroy(transportInfo);
+	return server;
+	}
+
+/**
+Allocates and constructs a new OBEX server object with packet sizing 
+information.
+
+The received protocol information object, aObexProtocolInfoPtr, specifies the 
+transport protocol to use:
+For the standard transports the following are used, TObexIrProtocolInfo for 
+IrDA, TObexBluetoothProtocolInfo for Bluetooth, TObexUsbProtocolInfo for USB.
+
+The aObexProtocolPolicy parameter specifies the packet sizing policy for this 
+OBEX object.
+
+@param aObexProtocolInfoPtr Protocol information object describing the 
+transport to use
+@param aObexProtocolPolicy Protocol policy object specifying the packet sizes 
+to use
+@return New OBEX server object 
+	
+@publishedAll
+@released
+*/
+EXPORT_C CObexServer* CObexServer::NewL(TObexProtocolInfo& aObexProtocolInfoPtr, 
+										TObexProtocolPolicy& aObexProtocolPolicy)
+	{
+	LOG_LINE
+	LOG_STATIC_FUNC_ENTRY
+
+	TObexTransportInfo* transportInfo = IrOBEXUtil::CreateTransportInfoL(aObexProtocolInfoPtr, aObexProtocolPolicy);	
+	CleanupStack::PushL(transportInfo);
+	CObexServer* server =  CObexServer::NewL(*transportInfo);
+	CleanupStack::PopAndDestroy(transportInfo);
+	return server;
+	}
+
+/** 
+Allocates and constructs a new OBEX server object with packet sizing 
+information.
+
+The received transport information object, aObexTransportInfo, specifies the 
+transport protocol and packet sizes to use:
+For the standard transports the following are used, TObexIrProtocolInfo for 
+IrDA, TObexBluetoothProtocolInfo for Bluetooth, TObexUsbProtocolInfo for USB.
+
+@param aObexTransportInfo  Transport information object describing the 
+transport and packet sizes  to use
+@return New OBEX server object 
+
+@capability WriteDeviceData If the TObexIrV3TransportInfo is passed as the argument
+                            and the associated name is valid.
+
+@publishedAll
+@released
+*/
+EXPORT_C CObexServer* CObexServer::NewL(TObexTransportInfo& aObexTransportInfo)
+	{
+	LOG_LINE
+	LOG_STATIC_FUNC_ENTRY
+
+	CObexServer* self = new(ELeave) CObexServer();
+	CleanupStack::PushL(self);
+	self->ConstructL(aObexTransportInfo);
+	CleanupStack::Pop(self);
+	return(self);
+	}
+
+/** Starts the server, specifying a synchronous notification interface.
+
+If the server is already started, no state changes occur (i.e. any connections/operations 
+in progress are not interrupted), but the notifications will be sent to aOwner. 
+This allows "child" servers to take over ownership of existing connections. 
+
+Details of this function behaviour depend on the transport specified when 
+constructed: in general a listener socket is created, its port number registered 
+as appropriate, and an accept queued.
+
+@param aOwner Server notification interface
+@return KErrArgument if parameter is NULL, KErrAlreadyExists if server has already
+been started (but notification object will still be updated), otherwise a system wide
+error code 
+@panic OBEX EChangeInterfaceDuringWait when attempting to change the interface at an inappropriate time.
+
+@publishedAll
+@released
+*/
+EXPORT_C TInt CObexServer::Start(MObexServerNotify* aOwner)
+	{
+	LOG_LINE
+	LOG_FUNC
+
+	if(aOwner == NULL)
+		{
+		return(KErrArgument);
+		}
+	
+	// Pass this synchronous interface to the synchronous wrapper
+	// and pass the synchronous wrapper on to the asynchronous Start()
+	iSyncWrapper->SetNotifier(aOwner);
+	return Start(iSyncWrapper);
+	}
+
+
+/** Starts the server, specifying an asynchronous notification interface.
+
+If the server is already started, no state changes occur (i.e. any connections/operations 
+in progress are not interrupted), but the notifications will be sent to aOwner. 
+This allows "child" servers to take over ownership of existing connections. 
+
+Details of this function behaviour depend on the transport specified when 
+constructed: in general a listener socket is created, its port number registered 
+as appropriate, and an accept queued.
+
+@param aOwner Server notification interface
+@return KErrArgument if parameter is NULL, KErrAlreadyExists if server has already
+been started (but notification object will still be updated), otherwise a system wide
+error code 
+@panic OBEX EChangeInterfaceDuringWait when attempting to change the interface at an inappropriate time.
+
+@publishedAll
+@released
+*/
+EXPORT_C TInt CObexServer::Start(MObexServerNotifyAsync* aOwner)
+	{
+	if(aOwner == NULL)
+		{
+		return(KErrArgument);
+		}
+
+	iOwner = aOwner;											
+
+	iStateMachine->Start(*iOwner);
+	if(iEnabled)
+		{
+		return(KErrAlreadyExists);
+		}
+	iEnabled = ETrue;
+	return(AcceptConnection());
+	}
+	
+
+/** Disconnects any transfer in progress and disables further connections. 
+
+@publishedAll
+@released
+*/
+EXPORT_C void CObexServer::Stop()
+	{// Cancel and Disable accepts, and bring and transport down.
+	LOG_LINE
+	LOG_FUNC
+
+	if(!iEnabled)
+		{
+		return;
+		}
+	iEnabled = EFalse;
+	ControlledTransportDown();
+	
+	// just check that iTransportController is still valid here (that is what we
+	// aspect to be)
+	__ASSERT_DEBUG(iTransportController, IrOBEXUtil::Fault(ETransportControllerNotCreated));
+	
+	iTransportController->CancelAccept();
+	iStateMachine->Stop();
+	iOwner = NULL;
+	iSyncWrapper->SetNotifier(NULL);
+	}
+
+TInt CObexServer::AcceptConnection()
+	{
+	if(iEnabled && iOwner)
+		{
+		iCurrentOperation = EOpIdle;
+		TRAPD(err, iTransportController->AcceptConnectionL());
+		if(err != KErrNone)
+			{
+			iEnabled = EFalse;
+			}
+		return(err);
+		}
+	else
+		{
+		return(KErrNone);
+		}
+	}
+
+
+
+/** Sets a password required to access the server.
+
+When a password is set, a client must specify it to access the server.
+
+@param aPassword Password 
+
+@publishedAll
+@released
+*/
+EXPORT_C void CObexServer::SetChallengeL(const TDesC& aPassword)
+	{
+	LOG_LINE
+	LOG_FUNC
+
+	delete iChallPassword;
+	iChallPassword = NULL;
+	iChallPassword = HBufC8::NewL(aPassword.Length());
+	TPtr8 ptr = iChallPassword->Des();
+	CnvUtfConverter::ConvertFromUnicodeToUtf8(ptr, aPassword);
+	iChallenge = ETrue;
+	}
+
+/** Resets the password.
+
+After this call, a client does not need to provide a password to access the 
+server. 
+
+@publishedAll
+@released
+*/
+EXPORT_C void CObexServer::ResetChallenge()
+	{
+	LOG_LINE
+	LOG_FUNC
+
+	delete iChallPassword;
+	iChallPassword = NULL;
+	iChallenge = EFalse;
+	}
+
+/**	
+Specifies target header checking behaviour.
+	
+Supports three behaviours---never check, always check, and check only if a target
+header has been sent.  The default behaviour is to only check when a target header
+has been sent.
+	
+No checking allows a form of multiplexing to be used, where one server object may
+respond to multiple target headers.  The behaviour desired by the client can be
+determined by examining the target header specified in the Connect.
+	
+@param aChecking The desired level of target header checking.
+@publishedAll
+@released
+*/
+EXPORT_C void CObexServer::SetTargetChecking(TTargetChecking aChecking)
+	{
+	LOG_LINE
+	LOG_FUNC
+
+	iTargetChecking = aChecking;
+	}
+
+
+/**
+Prepare next packet for the connection attempt
+ConnectionID and Who headers are Mandatory if the Target header was used in the connection from
+@param aPacket Packet to fill
+@internalComponent
+*/
+TInt CObexServer::PrepareConnectPacket(CObexPacket& aPacket) 
+	{
+	FLOG(_L("CObexServer::PrepareConnectPacket\r\n"));
+	TInt retValue = KErrNone;
+	TConnectState nextState = GetConnectState();
+
+	if(!iTransportController->InsertLocalConnectInfo(aPacket, iLocalInfo.iVersion, iLocalInfo.iFlags))
+		{
+		FLOG(_L("PrepareConnectPacket Local data insertion FAILED\r\n"));
+		return(KErrGeneral);
+		}
+	FLOG(_L("PrepareConnectPacket Local data inserted\r\n"));
+
+	if(GetConnectState() == ESimpleConnRequest)	//no Auth requested by the Client
+		{
+		FLOG(_L("PrepareConnectPacket GetConnectState() == ESimpleConnRequest\r\n"));
+		//if the Server must challenge
+		if(iChallenge) 
+			{
+			FLOG(_L("PrepareConnectPacket Challenge Required\r\n"));
+
+			aPacket.SetOpcode(ERespUnauthorized);  
+			retValue = GenerateChallenge(aPacket);
+			if ( retValue == KErrNone ) 
+				{
+				FLOG(_L("PrepareConnectPacket Challenge generated\r\n"));
+				nextState = ESimpleConnChallIssued;
+				}
+			else
+				{
+				FLOG(_L("PrepareConnectPacket Challenge generation FAILED\r\n"));
+				nextState = EConnTransport;
+				aPacket.SetOpcode(ERespInternalError);
+				}
+			}
+		else //don't require Authentication
+			{
+			FLOG(_L("PrepareConnectPacket No Challenge Required\r\n"));
+
+			aPacket.SetOpcode(ERespSuccess); 
+			//if the Target header was used for the connection
+			//if so then reply with ConnectionID and Who headers
+			if ((retValue = AddConnectionIDHeader(aPacket)) == KErrNone)
+				{
+				FLOG(_L("PrepareConnectPacket ConnectionID Inserted\r\n"));
+				nextState = EConnObex;
+				}
+			else
+				{
+				nextState = EDropLink;
+				FLOG(_L("PrepareConnectPacket ConnectionID Insertion FAILED\r\n"));
+				}
+			}
+		} //end if(GetConnectState() == ESimpleConnRequest) 
+	else if (GetConnectState() == EChallConnRequested)
+		{
+		FLOG(_L("PrepareConnectPacket GetConnectState() == EChallConnRequested\r\n"));
+
+		//if the Server must challenge
+		if(iChallenge) 
+			{
+			FLOG(_L("PrepareConnectPacket Challenge required\r\n"));
+			aPacket.SetOpcode(ERespUnauthorized); 
+			retValue = GenerateChallenge(aPacket);
+			if ( retValue == KErrNone ) 
+				{
+				FLOG(_L("PrepareConnectPacket Challenge Generated\r\n"));
+				nextState = EChallConnChallIssued; //chall answered with another chall
+				}
+			else
+				{
+				FLOG(_L("PrepareConnectPacket Challenge Generation FAILED\r\n"));
+				nextState = EConnTransport;
+				aPacket.SetOpcode(ERespInternalError);
+				}
+			}
+		else //don't require Authentication
+			{ //the response would already have been verified in ParseConnectPacket() 
+			//get password from user, prepare a response to the challenge
+			FLOG(_L("PrepareConnectPacket Challenge Not Required\r\n"));
+			retValue = PrepareFinalChallResponse(aPacket, nextState);
+			}
+		} //end else if GetConnectState() == EChallConnRequested
+	else if (GetConnectState() == EFinalChallRxed)
+		{	//
+		retValue = PrepareFinalChallResponse(aPacket, nextState);
+		}
+	else if ( GetConnectState() == EFinalResponseReceived )
+		{ //the response had to be OK otherwise would never have gotten this far
+		aPacket.SetOpcode(ERespSuccess); 
+		//if the Target header was used for the connection
+		//if so then reply with ConnectionID and Who headers
+		if ((retValue = AddConnectionIDHeader(aPacket)) == KErrNone)
+			{
+			nextState = EConnObex;
+			FLOG(_L("PrepareConnectPacket ConnectionID header Added\r\n"));
+			}
+		else
+			{
+			nextState = EDropLink;
+			FLOG(_L("PrepareConnectPacket ConnectionID header Addition FAILED\r\n"));
+			}
+		}
+	else //it's all gone wrong
+		{
+		FLOG(_L("PrepareConnectPacket complete failure, bad state\r\n"));
+
+		//break connection, inform user
+		nextState = EConnTransport;
+		aPacket.SetOpcode(ERespInternalError);
+		retValue = KErrGeneral;
+		}
+	//if the Server is now connected inform the client
+	if ( nextState == EConnObex)
+		iOwner->ObexConnectIndication(iRemoteInfo, TPtr8(NULL, 0));
+
+	SetConnectState(nextState);
+	return(retValue);
+	}
+/**
+Prepare next packet for an  invalid connection attempt (i.e. the ParseConnectPacket failed).
+A fail response (to a connect request)  includes the version, flags, and packet size information.
+
+@param aPacket Packet to fill
+@internalComponent
+*/
+TInt CObexServer::PrepareErroredConnectPacket(CObexPacket& aPacket)
+	{
+	FLOG(_L("CObexServer::PrepareErroredConnectPacket\r\n"));
+	
+	if ( !iTransportController->InsertLocalConnectInfo(aPacket, iLocalInfo.iVersion, iLocalInfo.iFlags))
+		{
+		FLOG(_L("PrepareConnectPacket Local data insertion FAILED\r\n"));
+		return(KErrGeneral);
+		}	
+	return KErrNone;
+	}
+
+void CObexServer::SignalReadActivity()
+	{
+	iPacketProcessSignaller->Signal(EObexReadActivityDetected);
+	}
+	
+void CObexServer::CheckTarget(TConnectState& aNextState, TInt& aRetVal)
+	{
+	FLOG(_L("Local Who:\r\n"));
+	LOGHEXDESC(iLocalInfo.iWho);
+	FLOG(_L("Target:\r\n"));
+	LOGHEXDESC(iRemoteInfo.iTargetHeader);
+	
+	// Workaround for bug with PocketPC 2002---if target header is sixteen bytes of zeros, connect anyway.
+	_LIT8(KZeroTarget, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00");
+
+	// Allow connection iff:
+	//    PocketPC attempting to connect to inbox (Sixteen bytes of zeros), when no LocalWho
+	// or Target header matches LocalWho (includes Inbox connections)
+	
+	if (!(	// Negate as block below discards connection
+		    ((iLocalInfo.iWho == KNullDesC8) && (iRemoteInfo.iTargetHeader == KZeroTarget))
+		 || ( iLocalInfo.iWho == iRemoteInfo.iTargetHeader)
+	   ))
+		{
+		FLOG(_L("ParseConnectPacket ETarget header doesn't match local iWho, dropping link\r\n"));
+		aNextState = EConnTransport;
+		aRetVal = ERespNotFound;
+		}
+	}
+
+
+//if the Target header is sent then it must match the local iWho field
+TInt CObexServer::ParseConnectPacket(CObexPacket& aPacket)
+	{
+	TConnectState nextState = GetConnectState(); //must change otherwise it's all wrong
+	TBool challReceivedOK = EFalse; //authentication challenge received from client 
+									//after server has issued its own authentication challenge.
+	TBool respReceivedOK = EFalse;  //authentication received from client 
+									//after server has issued its own authentication challenge.
+	FLOG(_L("CObexServer::ParseConnectPacket\r\n"));
+
+	if(!iTransportController->ExtractRemoteConnectInfo(aPacket, iRemoteInfo.iVersion, iRemoteInfo.iFlags))
+		{
+		FLOG(_L("ParseConnectPacket remote connect info extraction FAILED\r\n"));
+		return KErrGeneral;
+		}
+	FLOG(_L("ParseConnectPacket remote connect info extracted\r\n"));
+
+	TObexInternalHeader hdr;
+  	iTargetReceived = EFalse; //if target received then must reply with ConnectionID
+
+	//if the present state is EConnTransport then no headers are actually
+	//required, a simple connect is sufficient
+	if(GetConnectState() == EConnTransport)
+		{
+		nextState = ESimpleConnRequest;
+		}
+
+	TInt retVal = KErrNone;
+	TBool authAttempted = EFalse;
+	
+	while (aPacket.ExtractData(hdr) && (nextState != EDropLink) && (nextState != EConnTransport))
+		{
+		switch(hdr.HI())
+			{
+			case TObexInternalHeader::ETarget:
+				{
+				FLOG(_L("ParseConnectPacket extracting ETarget header\r\n"));
+				iTargetReceived = ETrue;
+				//copy the target header into iRemoteInfo for the user
+				iRemoteInfo.iTargetHeader.Copy(hdr.HVByteSeq(), hdr.HVSize() > iRemoteInfo.iTargetHeader.MaxSize() ? iRemoteInfo.iTargetHeader.MaxSize() : hdr.HVSize());
+
+				if (iTargetChecking == EIfPresent)
+					{
+					FLOG(_L("EIfPresent target header checking..."));
+					CheckTarget(nextState, retVal);
+					}
+				}
+				break;
+			case TObexInternalHeader::EAuthChallenge:
+				{
+				FLOG(_L("ParseConnectPacket EAuthChallenge Header received processing\r\n"));
+				authAttempted = ETrue;
+				TRAPD(err, ProcessChallengeL(hdr));
+				if (!err)
+					{
+					FLOG(_L("ParseConnectPacket Processing Chall SUCCESS\r\n"));
+					if (GetConnectState() == EConnTransport)
+						{
+						nextState = EChallConnRequested;
+						}
+					else if ((GetConnectState() == ESimpleConnChallIssued) || (GetConnectState() == EChallConnChallIssued))
+						{
+						challReceivedOK = ETrue; //the response must be verified first
+						nextState = EFinalChallRxed;
+						}
+					else
+						{
+						nextState = EConnTransport;
+						retVal = ERespInternalError;
+						}
+					}
+				else
+					{
+					FLOG(_L("ParseConnectPacket Processing Chall FAILED\r\n"));
+
+					nextState = EConnTransport;
+					retVal = ERespInternalError;
+					}
+				}
+				break;
+			case TObexInternalHeader::EAuthResponse:
+				{
+				if (iChallenge)
+					//else there is no challenge password to check against!
+					{
+					FLOG(_L("ParseConnectPacket EAuthResponse Header received processing\r\n"));
+					authAttempted = ETrue;
+					TRAPD(err, ProcessChallResponseL(hdr));
+					if (err == KErrNone)
+						{
+						FLOG(_L("ParseConnectPacket Processing Chall Response SUCCESS\r\n"));
+						if (GetConnectState() == ESimpleConnChallIssued)
+							{
+							respReceivedOK =ETrue;
+							if (challReceivedOK) //was a new challenge issued by the Client?
+								{
+								nextState = EFinalChallRxed; //must respond to chall
+								}
+							else
+								{
+								nextState = EFinalResponseReceived; //everything is OK send Success
+								}
+							}
+						else if (GetConnectState() == EChallConnChallIssued)
+							{
+							respReceivedOK =ETrue;
+							if (challReceivedOK) //was a new challenge issued by the Client?
+								{
+								nextState = EFinalChallRxed; //must respond to chall
+								}
+							else
+								{
+								//If we do not later in the packet see a challenge,
+								//(in which case this 'nextState' value will be overwritten),
+								//the client will have come back WITHOUT re-issuing 
+								//either his original challenge or a new one.
+								//Treat as if client had never issued a challenge. 
+								//This sequence has been observed in FOMA phones.
+								nextState = EFinalResponseReceived; 
+								}
+							}
+						else
+							{
+							nextState = EConnTransport;
+							retVal = ERespInternalError;
+							}
+						}
+					else if (err == KErrAccessDenied)
+						{
+						nextState = EConnTransport;
+						retVal = ERespUnauthorized;
+						FLOG(_L("ParseConnectPacket Processing Chall Response FAILED with Access Denied\r\n"));
+						}
+					else
+						{
+						nextState = EConnTransport;
+						retVal = ERespInternalError;
+						FLOG(_L("ParseConnectPacket Processing Chall Response FAILED\r\n"));
+						}
+					}
+				else
+					{
+					// if no challenge was issued, then receiving a challenge response means the peer is badly
+					// behaved. For this case we simply ignore the header, anything else would be too drastic.
+					FLOG(_L("ParseConnectPacket Chall Response received when no Chall issued\r\n"));
+					}
+				}
+				break;
+		default:
+			break;
+			}
+		}
+		
+	if (((GetConnectState() == ESimpleConnChallIssued) || (GetConnectState() == EChallConnChallIssued)) && !respReceivedOK)
+		// Client's connect packet should have contained an authentication response.
+		// Treat as if we had rejected an authentication response.
+		{
+		nextState = EConnTransport;
+		retVal = ERespUnauthorized;
+		}
+		
+	if (iTargetChecking == EAlways)
+		{
+		FLOG(_L("EAlways target header checking..."));
+		CheckTarget(nextState, retVal);
+		}
+
+	if (!authAttempted && (GetConnectState() == ESimpleConnChallIssued))
+		nextState = ESimpleConnRequest;
+
+	SetConnectState(nextState);
+	
+	return retVal;
+	}
+
+
+/** 
+Check, if required, the object connection ID.
+
+@return ETrue if it was not necessary to receive the ConnectionID or
+		if it was necessary and was correctly received. Otherwise 
+		EFalse.
+@internalComponent
+*/
+TBool CObexServer::CheckObjectForConnectionId(CObexBaseObject& aObject)
+	{
+	TBool retValue = ETrue;
+
+	if( iTargetReceived )
+		{
+		retValue = EFalse;
+		if (aObject.iValidHeaders & KObexHdrConnectionID )
+			{
+			TUint32 connID = aObject.ConnectionID();
+			if (iConnectionIdSet && (iConnectionID == connID))
+				{
+				retValue = ETrue;
+				}
+			}
+		}
+	return (retValue);
+	}
+
+/**
+Check, if required, that the packet connection ID matches that of the Server's current connection
+@return ETrue if the connection ID matches or if Target was not used in the original connection
+@return EFalse if Target was not used in the original connection and the connection ID was not found
+@internalComponent
+*/
+TBool CObexServer::CheckPacketForConnectionId(CObexPacket& aPacket)
+	{
+	// Connection ID check is compulsory if Target was used in the original connection
+	if (!iTargetReceived)
+		{
+		return ETrue;
+		}
+
+	// Search for ConnectionID
+	// ConnectionID should be the first header, but we check all of them just in case
+	TObexInternalHeader header;
+	while (aPacket.ExtractData(header))
+		{
+		if (header.HI() == TObexInternalHeader::EConnectionID)
+			{
+			TUint32 newConnectionID = (header.HVByteSeq()[0] << 24) + (header.HVByteSeq()[1] << 16)
+						+ (header.HVByteSeq()[2] << 8)  + (header.HVByteSeq()[3]);
+
+			if (ConnectionID() == newConnectionID)
+				{
+				return ETrue;
+				}
+			}
+		}
+
+	// Target was used in original connection and could not find Connection ID
+	return EFalse;
+	}
+
+void CObexServer::OnPacketReceive(CObexPacket& aPacket)
+	{
+	FLOG(_L("CObexServer::OnPacketReceive\r\n"));
+	MObexServerRequestPacketNotify* packetNotify = NULL;
+	if (iServerRequestPacketEngine)
+		{
+		packetNotify = iServerRequestPacketEngine->RequestPacketNotify();		
+		}
+	// If a packet notify has been registered then we should tell it 
+	// about each request packet we receive.
+	if (packetNotify)
+		{
+		TObexResponse response;
+		TBool normalOperation = ETrue;
+		
+		// Rebuild full OBEX opcode to pass to observer
+		TObexOpcode opcode = aPacket.Opcode() | (aPacket.IsFinal() ? KObexPacketFinalBit : 0);
+		
+		switch (aPacket.Opcode())
+			{
+		case CObex::EOpConnect:
+				{
+				TObexConnectInfo connectInfo;
+				if (!iStateMachine->Transport().ExtractRemoteConnectInfo(aPacket, connectInfo.iVersion, connectInfo.iFlags))
+					{
+					// If the packet cannot be parsed correctly at this stage it is very malformed
+					// and so we should abort processing it for the server app, and defer handling
+					// the error to the state machine.
+					break;
+					}
+				
+				TObexInternalHeader header;
+				// Call ExtractData() until it returns 0 bytes read - then we know the extract
+				// point will have been reset so the CObexPacket can be parsed again in the 
+				// future.  For this reason do not attempt to optimise this loop.
+				while (aPacket.ExtractData(header))
+					{
+					switch (header.HI())
+						{
+					case TObexInternalHeader::ETarget:
+						 // Only take the first Target header found
+						 if (connectInfo.iTargetHeader.Length() == 0)
+							{
+							TInt size = header.HVSize() > connectInfo.iTargetHeader.MaxSize() ? connectInfo.iTargetHeader.MaxSize() : header.HVSize();
+							connectInfo.iTargetHeader.Copy(header.HVByteSeq(), size);
+							}
+						break;
+					case TObexInternalHeader::EWho:
+						 // Return the first Who header in packet
+						 if (connectInfo.iWho.Length() == 0)
+							{
+							TInt size = header.HVSize() > connectInfo.iWho.MaxSize() ? connectInfo.iWho.MaxSize() : header.HVSize();
+							connectInfo.iWho.Copy(header.HVByteSeq(), size);
+							}
+						break;
+					default:
+						break;
+						}
+					}
+				
+				normalOperation = packetNotify->RequestPacket(opcode, connectInfo, response);
+				}
+			break;
+		case CObex::EOpSetPath:
+				{
+				TObexSetPathData data;
+	
+				if (!aPacket.ExtractData(data))
+					{
+					// If the packet cannot be parsed correctly at this stage it is very malformed
+					// and so we should abort processing it for the server app, and defer handling
+					// the error to the state machine.
+					break;
+					}
+				CObex::TSetPathInfo info(data);
+					
+				TObexInternalHeader header;
+				// Call ExtractData() until it returns 0 bytes read - then we know the extract
+				// point will have been reset so the CObexPacket can be parsed again in the 
+				// future.  For this reason do not attempt to optimise this loop.
+				while(aPacket.ExtractData(header))
+					{
+					// Take the first name header we find.
+					if(!info.iNamePresent && header.HI() == TObexInternalHeader::EName && header.GetHVText(info.iName) == KErrNone)
+						{
+						info.iNamePresent = ETrue;
+						}
+					}
+	
+				normalOperation = packetNotify->RequestPacket(opcode, info, response);
+				}
+			break;	
+		case CObex::EOpDisconnect:
+		case CObex::EOpAbortNoFBit:
+		case CObex::EOpPut:
+		case CObex::EOpGet:	
+		default:
+			normalOperation = packetNotify->RequestPacket(opcode, response);
+			break;
+			}
+
+		if (!normalOperation) // Abandon processing of request
+			{
+			CheckServerAppResponseCode(aPacket.Opcode(), response); // a success response code => panic
+			iStateMachine->OverrideRequestHandling(response);
+			return;
+			}
+		}
+
+	// Normal processing
+	iStateMachine->OnPacketReceive(aPacket);
+	}
+
+/**
+This function is to ensure that a response a server application provides the Obex Server
+to respond to the Obex Client with when it has overriden the default handling of a request
+packet does not represent a success.
+
+The rationale for this is to attempt to keep the Obex peers synchronised.  As the packet has
+been dropped, the client should not be lead to believe it has been received successfully.
+
+Therefore, this function asserts that the application does not send a success response for 
+the request packet received.
+*/	
+void CObexServer::CheckServerAppResponseCode(TObexOpcode aOpcode, TObexResponse aResponse)
+	{
+	TBool valid = ETrue;
+	switch (aOpcode)
+		{
+		case CObex::EOpConnect:
+			if (aResponse == ERespSuccess)
+				{
+				valid = EFalse;
+				}
+			break;
+		case CObex::EOpPut:
+		case CObex::EOpGet:
+			if (aResponse == ERespSuccess || aResponse == ERespContinue)
+				{
+				valid = EFalse;
+				}
+			break;
+		case CObex::EOpSetPath:
+			if (aResponse == ERespSuccess)
+				{
+				valid = EFalse;
+				}
+			break;
+		case CObex::EOpDisconnect:
+		case CObex::EOpAbortNoFBit:
+			// We allow any response to a abort/disconnect request,
+			// as only success codes are allowed.
+		default:
+			break;
+		}
+	__ASSERT_ALWAYS(valid, IrOBEXUtil::Panic(EInvalidResponseCodeFromServerApp));
+	}
+
+void CObexServer::OnError(TInt aError)
+	{
+	FTRACE(FPrint(_L("OnError aError: %d iCurrentOperation: %d, iConnectState: %d"), aError, iCurrentOperation, iConnectState));
+
+	if (aError == KErrDisconnected)
+		{
+		// Note: It is not clear that iCurrentOperation is ever equal
+		// to EOpDisconnect but the check has been retained just in case
+		if ((iCurrentOperation != EOpDisconnect) && (iConnectState > EConnTransport))
+			{
+			 //extended error for IrObex,("peer device aborted data transmission/obex sending") 
+			iOwner->ErrorIndication(KErrIrObexServerPutPeerAborted);
+			}
+		}
+	else
+		{
+		iOwner->ErrorIndication(aError);
+		}
+	// The state machine needs to know about the error regardless of whether ErrorIndication() is called
+	iStateMachine->Error();
+	}
+
+void CObexServer::OnTransportUp()
+	{
+	iTargetReceived = EFalse;
+
+	// For servers on the device using USB, there is a possibility that
+	// this function can be called, even though the server is stopped,
+	// as OBEX does not control the transport, the USB host does.
+	// Hence the need to check if there is an active iOwner.
+	if (iOwner)
+		{
+		iOwner->TransportUpIndication();
+		}
+	iStateMachine->TransportUp(); // state machine needs to know about the event regardless of Server state
+	}
+
+/**
+Tell the MObexServerNotifyAsync observer the transport is down and listen
+for another connection.
+*/
+void CObexServer::OnTransportDown()
+	{// Cancel Anything waiting. Restart the accepter	
+
+	// For servers on the device using USB, there is a possibility that
+	// this function can be called, even though the server is stopped,
+	// as OBEX does not control the transport, the USB host does
+	// Hence the need to check if there is an active iOwner.
+	if (iOwner)
+		{
+		iOwner->TransportDownIndication();
+		}
+	iStateMachine->TransportDown(); // state machine needs to know about the event regardless of Server state
+	TInt err = AcceptConnection();
+	if(err != KErrNone)
+		Error(err);
+	}
+
+/** Signals an event has ocurred.
+
+@released
+@internalComponent
+@param aEvent The event that has occurred. (TObexPacketProcessEvent)
+*/
+void CObexServer::SignalPacketProcessEvent(TInt aEvent)
+	{
+	LOG_FUNC
+
+	// This is how we signal the completed send of an ACK to a disconnect 
+	// command. Tell the state machine so it can finish the disconnection 
+	// sequence.
+	if(aEvent & EObexWriteCompletedFinal)
+		{
+		iStateMachine->WriteComplete();
+		}
+
+	// Server will have definitely finished with the read packet so queue the next read
+	if(aEvent & EObexWriteCompleted)
+		{
+		iTransportController->Receive();
+		}
+		
+	if(aEvent & EObexReadActivityDetected)
+		{
+		iStateMachine->ReadActivityDetected();
+		}
+	}
+	
+// CObexServer
+/** Tests if the server is started, and is available to accept connections.
+	
+@return ETrue if the server is started, EFalse otherwise
+	
+@publishedAll
+@released
+*/
+EXPORT_C TBool CObexServer::IsStarted() 
+	{
+	LOG_LINE
+	LOG_FUNC
+
+	return iEnabled;
+	}
+
+/**
+Returns the operation currently being performed by the remote client, or 
+EOpIdle if between operations. Note that there is no implication of whether 
+the server is currently connected; EOpIdle will be returned regardless of 
+connection state, if no operation is currently being performed. Use 
+CObex::IsConnected () to find connection staus.
+
+@return Operation currently being performed by the remote client
+
+@publishedAll
+@released
+*/
+EXPORT_C CObex::TOperation CObexServer::CurrentOperation() const 
+	{
+	LOG_LINE
+	LOG_FUNC
+
+	return iCurrentOperation;
+	}
+
+/**
+Setter function to allow other classes in the DLL to set the Server's current operation.
+Used by the Server state machine.
+@see CObexServerStateMachine
+@param aOperation The operation currently being performed by the remote client
+@internalComponent
+*/
+void CObexServer::SetCurrentOperation(const CObex::TOperation aOperation)
+	{
+	iCurrentOperation = aOperation;
+	}
+
+/**
+Specify the set of headers to return to remote Obex client in final
+Put response packet. The total length of the headers when encoded 
+should not exceed the maximum Obex packet payload size.
+
+This function may be called at any point during a Put operation.
+Repeated calls to this replace rather than add to the header set
+for inclusion in the final Put response packet.
+
+It may be called with a NULL pointer, which means that no headers
+will be sent with the Put Final Response.
+
+Even if this function returns with an error (even KErrNotReady) a
+best-effort attempt will be made to send as many headers as will fit
+in the final Put response packet.
+
+@param aHeaderSet A set of headers to be encoded in the final Put
+response packet. Ownership of the header set always passes to 
+CObexServer.
+
+@return KErrNone if the operation completes successfully.
+		KErrNotReady if the current operation is not a Put.
+		KErrArgument if the length of the headers when encoded
+		exceeds the maximum Obex packet payload size.
+		
+@publishedAll
+@released
+*/
+EXPORT_C TInt CObexServer::SetPutFinalResponseHeaders(CObexHeaderSet* aHeaderSet)
+	{
+	LOG_LINE
+	LOG_FUNC
+
+	//	First, let the state machine take ownership of the headerset
+	iStateMachine->SetPutFinalResponseHeaderSet(aHeaderSet);
+
+	TInt err=KErrNone;
+
+	//	Easy check first - are we currently engaged in a Put?
+	if(iCurrentOperation != EOpPut)
+		{
+		err=KErrNotReady;
+		}
+
+	if(!err && aHeaderSet)
+		{
+		//	Next, the not so easy check. Will all the headers, when encoded,
+		//	fit inside a send packet? 
+		//	First, how much space do we have to play with?
+		TInt available = iTransportController->SendPacket().DataLimit() - KObexPacketHeaderSize;
+		
+		//	Next, what is the combined encoded size of all the headers?
+		TInt required = 0;
+		aHeaderSet->First();
+		while(aHeaderSet->This(iHeader) == KErrNone)
+			{
+			required+=iHeader->EncodedSize();
+			(void)aHeaderSet->Next();
+			}
+
+		if(required>available)
+			{
+			err=KErrArgument;
+			}
+		}
+		
+	return err;
+	}
+
+
+/**
+Complete an asynchronous callback, supplying a CObexBaseObject derived object.
+Passing in NULL results in an Obex level error being sent to the client -- the
+semantics are that either a PUT request has been rejected or a GET request has
+not found a suitable object to return.
+
+@panic Obex ENoNotificationToComplete Raised if the server does not have a request
+outstanding.
+@param aObject The object passed back from application
+@return result of state changes
+@publishedAll
+@released
+*/
+EXPORT_C TInt CObexServer::RequestIndicationCallback(CObexBaseObject* aObject)
+	{
+	LOG_LINE
+	LOG_FUNC
+	return iStateMachine->RequestNotificationCompleted(aObject);
+	}
+
+/**
+Complete an asynchronous callback, supplying a obex response code. Applications 
+should use this function when rejecting Get/Put RequestIndication in order to 
+specify the response code.
+
+@panic Obex ENoNotificationToComplete Raised if the server does not have a request
+outstanding.
+@panic Obex EInvalidResponseCodeFromServerApp raised if TObexResponse aResponseCode is outside range
+[1,255] or it is one of the successful response (e.g. ERespSuccess, ERespContinue) 
+@param TObexResponse aResponseCode Application's response to the indication as an Obex response Code. The Final bit is ignored.
+@return result of state changes
+@publishedAll
+@released
+*/
+EXPORT_C TInt CObexServer::RequestIndicationCallbackWithError(TObexResponse aResponseCode)
+	{
+	LOG_LINE
+	LOG_FUNC
+	return iStateMachine->RequestNotificationCompleted(aResponseCode);
+	}
+
+/**
+Complete an asynchronous callback, supplying a obex response code. Applications 
+should use this function when rejecting Get/Put RequestIndication in order to 
+specify the error code.
+
+@panic Obex ENoNotificationToComplete Raised if the server does not have a request
+outstanding.
+@panic Obex EInvalidResponseCodeFromServerApp raised if TObexResponse aResponseCode non-negtive. Note: KErrNone is 
+not acceptable because this function is only used when there is an error.
+@param aErrorCode Application's response to the indication as an Obex response Code. 
+@return result of state changes
+@publishedAll
+@released
+*/	
+EXPORT_C TInt CObexServer::RequestIndicationCallbackWithError(TInt aErrorCode)
+	{
+	LOG_LINE
+	LOG_FUNC
+	__ASSERT_ALWAYS(aErrorCode <= 0, IrOBEXUtil::Panic(EInvalidResponseCodeFromServerApp));
+	return iStateMachine->RequestNotificationCompleted(IrOBEXUtil::ObexResponse(aErrorCode, ERespSuccess));
+	}
+	
+	
+/**
+Complete an asynchronous callback, supplying a obex response code. This function is 
+used for asychronously handling PutComplete, GetComplete and SetPath Indication. 
+
+@panic Obex ENoNotificationToComplete Raised if the server does not have a request
+outstanding.
+@panic Obex EInvalidResponseCodeFromServerApp raised if TObexResponse aResponseCode is outside range
+[1,255] or it is ERespContinue (which would confuse the client)
+@param TObexResponse aResponseCode Application's response to the indication as an Obex response Code. The Final bit is ignored.
+@return result of state changes
+@publishedAll
+@released
+*/
+EXPORT_C TInt CObexServer::RequestCompleteIndicationCallback(TObexResponse aResponseCode)
+	{
+	LOG_LINE
+	LOG_FUNC
+	return iStateMachine->RequestCompleteNotificationCompleted(aResponseCode);
+	}
+
+/**
+Complete an asynchronous callback, supplying a obex response code. This function is 
+used for asychronously handling PutComplete, GetComplete and SetPath Indication. 
+
+@panic Obex ENoNotificationToComplete Raised if the server does not have a request
+outstanding.
+@panic Obex EInvalidResponseCodeFromServerApp raised if aErrorCode is positive, i.e. 
+invalid Symbian error code
+@param TObexResponse aResponseCode Application's response to the indication as a Symbian error code
+@return result of state changes
+@publishedAll
+@released
+*/
+EXPORT_C TInt CObexServer::RequestCompleteIndicationCallback(TInt aErrorCode)
+	{
+	LOG_LINE
+	LOG_FUNC
+	__ASSERT_ALWAYS(aErrorCode <= 0, IrOBEXUtil::Panic(EInvalidResponseCodeFromServerApp));
+	return iStateMachine->RequestCompleteNotificationCompleted(IrOBEXUtil::ObexResponse(aErrorCode, ERespSuccess));
+	}
+	
+/**
+Provides the pre-parsed contents of the most recently received request packet.
+
+@param aHeaderSet A reference to a pointer that will be modified to NULL if no headers
+are contained in the request packet, or to point to a new headerset containing
+representations of the headers within the packet. Ownership of the headerset
+(when aHeaderSet is not NULL) is passed to the caller.
+@return KErrNone if successful, otherwise a system wide error code.
+
+@publishedPartner
+@released
+*/
+EXPORT_C TInt CObexServer::PacketHeaders(CObexHeaderSet*& aHeaderSet)
+	{
+	FLOG(_L8("CObexServer::PacketHeaders"));
+
+	return DoPacketHeaders(aHeaderSet, NULL);	
+	}
+
+
+/**
+Provides the selectively pre-parsed contents of the most recently received request packet.
+
+@param aHeaderSet A reference to a pointer that will be modified to NULL if no interesting
+header are contained in the request packet, or to point to a new headerset containing
+representations of the headers within the packet that are of interest. Ownership of the 
+headerset (when aHeaderSet is not NULL) is passed to the caller.
+@param aHeaderCheck A reference to an MObexHeaderCheck derived class that encapsulates
+whether or not a particular header or headers should be included in the returned header
+set (i.e. whether the headers are "interesting").
+
+@return KErrNone if successful, otherwise a system wide error code.
+
+@publishedPartner
+@released
+*/
+EXPORT_C TInt CObexServer::PacketHeaders(CObexHeaderSet*& aHeaderSet, MObexHeaderCheck& aHeaderCheck)
+	{
+	FLOG(_L8("CObexServer::PacketHeaders (selective)"));
+
+	return DoPacketHeaders(aHeaderSet, &aHeaderCheck);
+	}
+
+/** Sets a read activity observer.
+
+This replaces any previous observer.  The observer will receive a callback
+when the first read arrives for a put or get request. 
+
+This does not transfer ownership.
+
+@publishedPartner
+@released
+@param aObserver The observer to receive packet process events.  This may
+				 be NULL.
+*/
+EXPORT_C void CObexServer::SetReadActivityObserver(MObexReadActivityObserver* aObserver)
+	{
+	iPacketProcessSignaller->SetReadActivityObserver(aObserver);
+	}
+/**
+Contains the functionality for the PacketHeader interface functions in a refactored way.
+
+@param aHeaderSet A reference to a pointer that will be modified to NULL if no interesting
+header are contained in the request packet, or to point to a new headerset containing
+representations of the headers within the packet that are of interest. Ownership of the 
+headerset (when aHeaderSet is not NULL) is passed to the caller.
+@param aHeaderCheck A pointer to an MObexHeaderCheck derived class that encapsulates
+whether or not a particular header or headers should be included in the returned header
+set (i.e. whether the headers are "interesting").  If the pointer is NULL then that is taken
+to mean that all headers should be added to the aHeaderSet.
+
+@return KErrNone if successful, otherwise a system wide error code.
+*/	
+TInt CObexServer::DoPacketHeaders(CObexHeaderSet*& aHeaderSet, MObexHeaderCheck* aHeaderCheck)
+	{
+	FLOG(_L8("CObexServer::DoPacketHeaders"));
+	
+	TRAPD(err, aHeaderSet = CObexHeaderSet::NewL());
+	if (err != KErrNone)
+		{
+		aHeaderSet = NULL;
+		return err;
+		}
+	
+	CObexPacket& packet = iTransportController->ReceivePacket();
+	
+	// for "non-standard" size requests ensure we correctly start
+	// extracting headers where they start.
+	switch (packet.Opcode())
+		{
+	case CObex::EOpConnect:
+			{
+			TObexConnectInfo connectInfo;
+			if (!iStateMachine->Transport().ExtractRemoteConnectInfo(packet, connectInfo.iVersion, connectInfo.iFlags))
+				{
+				err = KErrUnderflow;
+				}
+			}
+		break;
+	case CObex::EOpSetPath:
+			{
+			TObexSetPathData data;
+			if (!packet.ExtractData(data))
+				{
+				err = KErrUnderflow;
+				}
+			}
+		break;
+	default:	
+		break;	
+		}
+	
+	TBool interestingHeaders = EFalse;
+	TObexInternalHeader header;
+	// Call ExtractData() until it returns 0 bytes read - then we know the extract
+	// point will have been reset so the CObexPacket can be parsed again in the 
+	// future.  For this reason do not attempt to optimise this loop.
+	while(packet.ExtractData(header))
+		{
+		// if there was an error previously we want to just keep going through the
+		// loop to reset the CObexPacket extraction point.
+		if (err == KErrNone && (!aHeaderCheck || aHeaderCheck->Interested(header.HI())))
+			{
+			err = IrOBEXHeaderUtil::ParseHeader(header, *aHeaderSet);
+			if (!interestingHeaders && err == KErrNone)
+				{
+				interestingHeaders = ETrue;
+				}
+			}
+		}
+
+	if (err != KErrNone || !interestingHeaders)
+		{
+		delete aHeaderSet;
+		aHeaderSet = NULL;
+		}
+	return err;	
+	}
+
+/**
+Provides additional interfaces for CObexServer.
+
+@param aUid The UID of the interface that is required.
+@return A pointer to an instance implementing the interface represented by aUid.
+
+@leave KErrNotSupported if the given UID does not represent an interface CObexServer can provide.
+@leave KErrInUse if an instance of MObexServerRequestPacketNotifyRegister has already been provided
+				 by an earlier call to ExtensionInterfaceL, and it has not been released.
+
+@internalTechnology
+*/
+EXPORT_C TAny* CObexServer::ExtensionInterfaceL(TUid aUid)
+	{
+	// MObexServerRequestPacketNotifyRegister interface
+	if (aUid == KObexServerRequestPacketNotifyRegisterInterface)
+		{
+		// We only return an instance if there are no other packet access extensions
+		// hooked into the CObexServer instance (indicated by the existance of an engine).
+		if (iServerRequestPacketEngine)
+			{
+			User::Leave(KErrInUse);
+			}
+		iServerRequestPacketEngine = CObexServerRequestPacketEngine::NewL(*this);
+		return static_cast<MObexServerRequestPacketNotifyRegister*>(iServerRequestPacketEngine);
+		}
+	// if we don't know the interface UID then we don't support it.
+	User::Leave(KErrNotSupported);
+	return NULL; // to silence the compiler.
+	}
+
+/** 
+Returns a pointer to the TObexTransportInfo being used by the OBEX transport 
+layer. THE USER MUST NOT MODIFY THE OBJECT POINTED TO.
+This is useful primarily when using OBEX over RFCOMM and the user has 
+specified 'KRfcommPassiveAutoBind' as the port. KRfcommPassiveAutoBind makes 
+RFCOMM itself find a free port. The user needs to know which port is really 
+being used by RFCOMM in order to correctly populate the SDP record. 
+May be called meaningfully after CObexServer::Start has returned KErrNone. 
+@return Pointer to the transport layer's transport info.
+@publishedAll
+@released
+*/
+EXPORT_C const TObexTransportInfo* CObexServer::TransportInfo() const
+	{
+	LOG_LINE
+	LOG_FUNC
+
+	__ASSERT_DEBUG(iTransportController, IrOBEXUtil::Fault(ETransportControllerNotCreated));
+	return iTransportController->TransportInfo();
+	}
+