/*
* Copyright (c) 2007 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:  Receives incoming DHCPInform messages
*
*/


#include <e32std.h>
#include <es_sock.h>
#include "dhcpconstants.h"
#include "dhcppsylogging.h"
#include "dhcpsocketlistener.h"

const TInt KDhcpSizeOfMinXIDPacket = 0x08;
const TInt KDhcpLocationOfXIDField = 0x04;
const TInt KDhcpLengthOfXIDField = 0x04;
const TInt KDhcpPeriodicTimerIntervalOneAndHalfSec(1500000);

// ======== MEMBER FUNCTIONS ========


// ---------------------------------------------------------------------------
// NewL
// ---------------------------------------------------------------------------
//
CDhcpPsySocketListener* CDhcpPsySocketListener::NewL(RSocket* aSocket)
    {
    TRACESTRING ( "CDhcpPsySocketListener::NewL" );
    CDhcpPsySocketListener* self = new( ELeave ) CDhcpPsySocketListener(aSocket);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop();
    return self;
    }

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CDhcpPsySocketListener::~CDhcpPsySocketListener()
    {
    TRACESTRING( "CDhcpPsySocketListener::~CDhcpPsySocketListener" );
    Cancel();
    delete iRcvdDataHeapBufferPtr;
    delete iPeriodicTimer;
    }

// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
//
CDhcpPsySocketListener::CDhcpPsySocketListener( RSocket* aSocket) :
    CActive ( EPriorityStandard ), iSocket (aSocket),  iRcvdDataBuffer ( 0, 0, KDhcpPacketLength )
    {
    TRACESTRING( "CDhcpPsySocketListener::CDhcpPsySocketListener" );
    CActiveScheduler::Add( this );
    iAckPckg = TDhcpDataResponsePacket ();
    }

// ---------------------------------------------------------------------------
// CDhcpPsySocketListener::RcvDHCPMessage
//
// For receiving the message with a connectionless socket.
// This is done if no DHCP Server address was found with the Symbian way.
// Then we try it with Broadcast messages.
// ---------------------------------------------------------------------------
//
void CDhcpPsySocketListener::RcvDHCPMessageConnectionlessL(TRequestStatus& aStatus)
    {
    TRACESTRING( "CDhcpPsySocketListener::RcvDHCPMessageConnectionlessL" );
    aStatus = KRequestPending;
    iClientStatus = &aStatus;
    iIsConnectionless = ETrue;
    iRcvdDataHeapBufferPtr = HBufC8::NewL( KDhcpPacketLength );
    iRcvdDataBuffer.Set( iRcvdDataHeapBufferPtr->Des() );
    iRcvdDataBuffer.FillZ();
    iAddress.SetPort( KDhcpDefaultCliPort );
    iSocket->RecvFrom( iRcvdDataBuffer,
                       iAddress,
                       NULL,
                       iStatus,
                       iLen );
    StartTimer ();
    SetActive();
    }

// ---------------------------------------------------------------------------
// CDhcpPsySocketListener::RcvDHCPMessage
//
// For receiving DHCP message with a connected socket. If a DHCP server was
// found and a bind could be done.
// ---------------------------------------------------------------------------
//
void CDhcpPsySocketListener::RcvDHCPMessage(TRequestStatus& aStatus)
    {
    TRACESTRING( "CDhcpPsySocketListener::RcvDHCPMessage" );
    aStatus = KRequestPending;
    iClientStatus = &aStatus;
    iIsConnectionless = EFalse;
    iSocket->Recv( iAckPckg, 0 , iStatus, iLen );
    StartTimer ();
    SetActive();
    }

// ---------------------------------------------------------------------------
// CDhcpPsySocketListener::StartTimer
//
// Start timeout control for making sure that used client thread doesn't halt
// ---------------------------------------------------------------------------
//
void CDhcpPsySocketListener::StartTimer ()
    {
    TRACESTRING( "CDhcpPsySocketListener::StartTimer" );
    // Start the periodic timer, when ever the time elapsed
    // the PeriodicTimerCallBack() will get called.
    iPeriodicTimer->Start(KDhcpPeriodicTimerIntervalOneAndHalfSec,
            KDhcpPeriodicTimerIntervalOneAndHalfSec,
            TCallBack(PeriodicTimerCallBack, this));
    }

// ---------------------------------------------------------------------------
// RunL
// ---------------------------------------------------------------------------
//
void CDhcpPsySocketListener::RunL()
    {
    TRACESTRING2( "CDhcpPsySocketListener::RunL, %d", iStatus.Int() );
    TInt result = iStatus.Int();
    iPeriodicTimer->Cancel();
    if (result==KErrNone)
        {
        if ( iIsConnectionless )
            {
            iAckPckg.Copy( iRcvdDataHeapBufferPtr->Des() );
            }
        if (CheckAckXid ())
            {
            // Checks also that content is valid for location parsing.
            result = iAckPckg.ParseDHCPAck();
            }
        }
    TRequestStatus *status = iClientStatus;
    User::RequestComplete (status, result);
    }

// ---------------------------------------------------------------------------
// Return location civic information for caller
// ---------------------------------------------------------------------------
//
const TDesC8&   CDhcpPsySocketListener::LocationCivicInformation ()
    {
    TRACESTRING( "CDhcpPsySocketListener::LocationCivicInformation" );
    return iAckPckg.iCivicAddress;
    }

// ---------------------------------------------------------------------------
// Return geoConfig information for caller
// ---------------------------------------------------------------------------
//
const TDesC8&    CDhcpPsySocketListener::GeoConfigDhcpInformation ()
    {
    TRACESTRING( "CDhcpPsySocketListener::GeoConfigDhcpInformation" );
    return iAckPckg.iGeoConf;
    }

// ---------------------------------------------------------------------------
// Set transaction action id to follow
// ---------------------------------------------------------------------------
//
void CDhcpPsySocketListener::SetTransActionIdToFollow (TUint32 aXid)
    {
    TRACESTRING( "CDhcpPsySocketListener::SetTransActionIdToFollow" );
    iXid = aXid;
    }

// ---------------------------------------------------------------------------
// CDhcpPsySocketListener::CheckAckXid
//
// For checking if the XID (identifier of the DHCP message) of the received
// ACK - message matches the XID of the INFORM that was sent.
// ---------------------------------------------------------------------------
//
TBool CDhcpPsySocketListener::CheckAckXid()
    {
    TRACESTRING( "CDhcpPsySocketListener::CheckAckXID" );
    TBool retValue = EFalse;
    // Check if the message is the DHCP Ack that we wanted.
    // the length of the packet needs to be over 8 because otherwise
    // this leaves with error code.
    TRACESTRING2( "CDhcpPsySocketListener::CheckAckXID, ack length %d", iAckPckg.Length() );
    if ( iAckPckg.Length() > KDhcpSizeOfMinXIDPacket )
        {
        TUint32 ackXid = 0;
        // Copy the XID field from the message (4 octets from the 4:th octet)
        TPtrC8 xidPtr ( iAckPckg.Mid( KDhcpLocationOfXIDField, KDhcpLengthOfXIDField ) );
        ackXid = BigEndian::Get32(xidPtr.Ptr());
        // Compare the XID values
        if (ackXid == iXid)
            {
            TRACESTRING( "CDhcpPsySocketListener::CheckAckXID, true" );
            retValue = ETrue;
            }
        }
    return retValue;
    }

// ---------------------------------------------------------------------------
// CDhcpPsySocketListener::DoCancel
// ---------------------------------------------------------------------------
//
void CDhcpPsySocketListener::DoCancel()
    {
    TRACESTRING( "CDhcpPsySocketListener::DoCancel" );
    iPeriodicTimer->Cancel();
    iSocket->CancelRecv();
    }

// ---------------------------------------------------------------------------
// CDhcpPsySocketListener::ConstructL
// ---------------------------------------------------------------------------
//
void CDhcpPsySocketListener::ConstructL()
    {
    TRACESTRING ( "CDhcpPsySocketListener::ConstructL ");
    // Initialize the periodic timer.
    iPeriodicTimer = CPeriodic::NewL(CActive::EPriorityIdle);
    }

// ----------------------------------------------------------------------------
// CDhcpPsySocketListener::PeriodicTimerCallBack
// ----------------------------------------------------------------------------
//
TInt CDhcpPsySocketListener::PeriodicTimerCallBack(TAny* aAny)
    {
    TRACESTRING ( "CDhcpPsySocketListener::PeriodicTimerCallBack ");
    CDhcpPsySocketListener* self = STATIC_CAST(CDhcpPsySocketListener*, aAny);
    // Cancel outstanding requests
    self->CancelOutstandigRequest();
    return KErrNone;
    }

// ----------------------------------------------------------------------------
// CDhcpPsySocketListener::CancelOutstandigRequest
// ----------------------------------------------------------------------------
//
void CDhcpPsySocketListener::CancelOutstandigRequest ()
    {
    TRACESTRING ( "CDhcpPsySocketListener::CancelOutstandigRequest ");
    // Will cause outstanding request to complete prematurely
    iSocket->CancelRecv();
    }