/*
* 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();
	}