/*

 * Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of the License "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 "sntpclientengine.h"

 #include "util.h"

 // 40 second timeout on operations

 #define SNTP_ENGINE_TIMEOUT 40000000 

 // NTP port

 #define SNTP_REMOTE_PORT 123

 _LIT(KNTPEpochDate,"19000000:");

 /* The simplest possible NTP request */

 static const TUint8 sntpRequest[48] = {

 	0x23, 0x00, 0x00, 0x00,

 	0x00, 0x00, 0x00, 0x00,

 	0x00, 0x00, 0x00, 0x00,

 	0x00, 0x00, 0x00, 0x00,

 	0x00, 0x00, 0x00, 0x00,

 	0x00, 0x00, 0x00, 0x00,

 	0x00, 0x00, 0x00, 0x00,

 	0x00, 0x00, 0x00, 0x00,

 	0x00, 0x00, 0x00, 0x00,

 	0x00, 0x00, 0x00, 0x00,

 	0x00, 0x00, 0x00, 0x00,

 	0x00, 0x00, 0x00, 0x00 };

 /* The main engine of the SNTP client */

 CSNTPClient* CSNTPClient::NewL(TCommandLineArgs& aArgs)

 	{

 	CSNTPClient* self = CSNTPClient::NewLC(aArgs);

 	CleanupStack::Pop(self);

 	return self;

 	}

 CSNTPClient* CSNTPClient::NewLC(TCommandLineArgs& aArgs)

 	{

 	CSNTPClient* self = new (ELeave) CSNTPClient(aArgs);

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	return self;

 	}

 TSNTPClientState CSNTPClient::State()

 	{

 	return iState;

 	}

 void CSNTPClient::Start()

 	{

 	iState = EStateResolve;

 	iResolver.GetByName(*(iArgs.iServers[iServerIndex]), iNameEntry, iStatus);

 	SetActive();

 	iTimer->After(SNTP_ENGINE_TIMEOUT);

 	}

 CSNTPClient::~CSNTPClient()

 	{

 	Cancel();

 	iResolver.Close();

 	iSock.Close();

 	iSockServ.Close();

 	delete iTimer;

 	}

 CSNTPClient::CSNTPClient(TCommandLineArgs& aArgs)

 	: CActive(EPriorityStandard), iArgs(aArgs)

 	{

 	}

 void CSNTPClient::ConstructL()

 	{

 	User::LeaveIfError(iSockServ.Connect());

 	User::LeaveIfError(iSock.Open(iSockServ, KAfInet, KSockDatagram, KProtocolInetUdp));

 	User::LeaveIfError(iResolver.Open(iSockServ, KAfInet, KProtocolInetUdp));

 	iTimer = CTimeOutTimer::NewL(EPriorityHigh, *this);

 	CActiveScheduler::Add(this);

 	}

 void CSNTPClient::RunL()

 	{

 	if (iStatus.Int() < 0)

 		{

 		User::Leave(iStatus.Int());

 		}

 	switch (iState)

 		{

 	case EStateResolve:

 		iTimer->Cancel();

 		iBuffer.Zero();

 		iBuffer.Append(sntpRequest, 48);

 		// set the port on the address

 		iNameEntry().iAddr.SetPort(SNTP_REMOTE_PORT);

 		iState = EStateWrite;

 		iSock.SendTo(iBuffer, iNameEntry().iAddr, 0, iStatus);

 		SetActive();

 		iTimer->After(SNTP_ENGINE_TIMEOUT);

 		break;

 	case EStateWrite:

 		iTimer->Cancel();

 		iState = EStateRead;

 		iBuffer.Zero();

 		iSock.RecvFrom(iBuffer, iNameEntry().iAddr, 0, iStatus);

 		SetActive();

 		iTimer->After(SNTP_ENGINE_TIMEOUT);

 		break;

 	case EStateRead:

 		{

 		iTimer->Cancel();

 		SetTimeL();

 		iStatus = KRequestPending;

 		iState = EStateComplete;

 		TRequestStatus* status = &iStatus;

 		SetActive();

 		User::RequestComplete(status, KErrNone);

 		break;

 		}

 	case EStateComplete:

 		CActiveScheduler::Stop();

 		// done

 		break;

 	default:

 		// wuh oh. BC break!

 		User::Leave(KErrArgument);

 		break;

 		}

 	}

 void CSNTPClient::DoCancel()

 	{

 	iTimer->Cancel();

 	switch (iState)

 		{

 	case EStateResolve:

 		iResolver.Cancel();

 		break;

 	case EStateWrite:

 		iSock.CancelSend();

 		break;

 	case EStateRead:

 		iSock.CancelRecv();

 		break;

 		}

 	}

 TInt CSNTPClient::RunError(TInt /* aError */)

 	{

 	// The current server didn't work, lets try the next if available.

 	iTimer->Cancel();

 	if (++iServerIndex < iArgs.iServers.Count())

 		{

 		Start();

 		}

 	else

 		{

 		iState = EStateFailed;

 		CActiveScheduler::Stop();

 		}

 	return KErrNone;

 	}

 void CSNTPClient::TimerExpired()

 	{

 	Cancel();

 	// The current server didn't work, lets try the next if available.

 	if (++iServerIndex < iArgs.iServers.Count())

 		{

 		Start();

 		}

 	else

 		{

 		iState = EStateAborted;

 		CActiveScheduler::Stop();

 		}

 	}

 void CSNTPClient::SetTimeL()

 	{

 	TUint32 timestamp(0);

 	/* Use the seconds from the transmit time field 

 	 */

 	for (TInt i = 40; i < 44; ++i)

 		{

 		timestamp = (timestamp << 8) + iBuffer[i];

 		}

 	// Obtain the time, including the specified timezone offset

 	TTimeIntervalMinutes mins(timestamp / 60);

 	TTimeIntervalSeconds secs(timestamp % 60);

 	TTime ntpTime;

 	User::LeaveIfError(ntpTime.Set(KNTPEpochDate));

 	ntpTime += mins;

 	ntpTime += secs;

 	// Apply offset and (possibly) daylight savings time

 	TTimeIntervalHours hours;

 	if (iArgs.iApplyDaylightSavings && Util::DaylightSavingsAppliesL(ntpTime))

 		{

 		hours = iArgs.iOffset + 1;

 		}

 	else

 		{

 		hours = iArgs.iOffset;

 		}

 	ntpTime += hours;

 	User::LeaveIfError(User::SetHomeTime(ntpTime));

 	}

 /* Timeout handler for read/write operations */

 CTimeOutTimer::CTimeOutTimer(const TInt aPriority)

     : CTimer(aPriority)

     {

     }

 CTimeOutTimer::~CTimeOutTimer()

     {

 	Cancel();

     }

 CTimeOutTimer* CTimeOutTimer::NewL(const TInt aPriority, MTimeOutNotify& aTimeOutNotify)

     {

     CTimeOutTimer *p = new (ELeave) CTimeOutTimer(aPriority);

     CleanupStack::PushL(p);

 	p->ConstructL(aTimeOutNotify);

 	CleanupStack::Pop();

     return p;

     }

 void CTimeOutTimer::ConstructL(MTimeOutNotify &aTimeOutNotify)

     {

 	iNotify=&aTimeOutNotify;

 	CTimer::ConstructL();

     CActiveScheduler::Add(this);

     }

 void CTimeOutTimer::RunL()

 // Timer request has completed, so notify the timer's owner

     {

 	iNotify->TimerExpired();

 	}