// 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))

		{