/*

* Copyright (c) 2005-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:  

* System Includes

*

*/

#include <stdio.h>

#include <memory.h>

#include <assert.h>

#ifndef WIN32

#include <errno.h>

#include <unistd.h>

#endif

/*******************************************************************************

 *

 * Local Includes

 *

 ******************************************************************************/

#include "CUDPAirInterface.h"

/*******************************************************************************

 *

 * Definitions

 *

 ******************************************************************************/

#ifndef WIN32

#define SOCKET_ERROR        (-1)

#define INVALID_SOCKET      (-1)

#define ADDRESS_INTEGER     s_addr

#define closesocket(x)     (shutdown(x,SHUT_RDWR),close(x))

#else

typedef int socklen_t;

#endif

/*******************************************************************************

 *

 * Macro Functions

 *

 ******************************************************************************/

/*******************************************************************************

 *

 * Constructor - sets the passed pointers and sets the state to disabled

 *

 ******************************************************************************/

CUDPAirInterface::CUDPAirInterface( TPhoneData *aPhoneData, CLog *aLog  )

{

	// verify parameters 

	assert( aPhoneData != NULL );

	assert( aLog != NULL );

	// init state

	iPhoneData = aPhoneData;

	iProcessData = NULL;

	iLog = aLog;

	iFilter = NULL;

	memset( &iRemoteAddress, 0, sizeof(iRemoteAddress) );

	memset( &iLocalAddress, 0, sizeof(iLocalAddress) );

	iSockIncoming = INVALID_SOCKET;

	iSockOutgoing = INVALID_SOCKET;

	iExitFlag = 0;

	iRemoteAddressValid = 0;

}

CUDPAirInterface::~CUDPAirInterface( )

{

	// check the status of the sockets

	assert( iSockIncoming == INVALID_SOCKET );

	assert( iSockOutgoing == INVALID_SOCKET );

}

/*******************************************************************************

 *

 * PUBLIC METHOD: LISTEN-THREAD: ListenOnInterface. Binds to local port and 

 * then starts listening on this port for more incoming data. Any incoming data

 * is then sent to the datalink layer.

 *

 ******************************************************************************/

TAirInterfaceError CUDPAirInterface::ListenOnInterface( int *aErrCode )

{

	TDataPathError derr;

	int err, errcode;

	struct sockaddr_in remote_recv_addr;

	socklen_t addrlen;

	// verify params

	assert( aErrCode != NULL );

	*aErrCode = 0;

	// check that the local port is invalid

	assert( iSockIncoming == INVALID_SOCKET );

	// create the listening socket

	iSockIncoming = socket( AF_INET, SOCK_DGRAM, 0 );

	if( iSockIncoming == INVALID_SOCKET ) {

		*aErrCode = GetSocketError();

		return AIE_SOCKET_FAILED;

	}

	// if the exit flag is set then exit now

	if( iExitFlag != 0 ) {

	  closesocket( iSockIncoming );

	  iSockIncoming = INVALID_SOCKET;

	  return AIE_NONE;

	}

	// bind the listening socket -- bind to an ephemeral port

	iLocalAddress.sin_family = AF_INET;

	iLocalAddress.sin_port = htons(0);

	iLocalAddress.sin_addr.ADDRESS_INTEGER = INADDR_ANY;

	err = bind( iSockIncoming, (struct sockaddr*)&iLocalAddress, sizeof(iLocalAddress) );

	// get the allocated port info

	addrlen = sizeof(iLocalAddress);

	err = getsockname( iSockIncoming, (sockaddr*)&iLocalAddress, &addrlen );

	assert( err == 0 );

	// check for errors during the bind

	if( err != 0 ) {

	  closesocket( iSockIncoming );

	  iSockIncoming = INVALID_SOCKET;

	  *aErrCode = GetSocketError();

	  return AIE_BIND_FAILED;

	}

	// use the listening socket as the outgoing socket -- no reason we can't do 

	// this. It also means that we know the source port of the outgoing datagrams 

	// and hence we can do some proper NISTNET stuff

	iSockOutgoing = iSockIncoming;

	// read from the socket until an error occurs (this may be induced by another

	// thread closing the socket)

	while( 1 ) {

		// now read from the socket

		memset( &remote_recv_addr, 0, sizeof(remote_recv_addr) );

		addrlen = sizeof(remote_recv_addr);

		err = recvfrom( iSockIncoming, iPacketBuffer, KPCKTBUFFSIZE, 0, (struct sockaddr*)&remote_recv_addr, &addrlen );

		// check for errors

		if( err == SOCKET_ERROR ) {

		  closesocket( iSockIncoming );

		  iSockIncoming = iSockOutgoing = INVALID_SOCKET;

		  *aErrCode = GetSocketError();

		  return AIE_RECEIVE_FAILED;

		}

		// send the data to the filters

		if( iFilter != NULL ) {

			iFilter->ProcessIncomingData( iPacketBuffer, err );

		}

		// otherwise we have data to send to the datalink layer

		derr = iProcessData->ProcessUUData( iPacketBuffer, err, &errcode );

		if( derr != DPE_NONE ) {	

			iLog->WriteLogEntry( SV_WARNING, "CUDPAirInterface::ListenOnInterface", "ProcessUUData returned", derr, errcode );

		}

	}

	// code should never get here

	assert( !"INVALID CODE PATH" );

	return AIE_NONE;

}

/*******************************************************************************

 *

 * PUBLIC METHOD: MAIN-THREAD: StopInterface. Closes the socket (if it is open)

 * was called. We can't guarantee when the receiving thread will return. But it

 * must before any other calls can be made.

 *

 ******************************************************************************/

int CUDPAirInterface::StopInterface()

{

	// set the exit flag

	iExitFlag = 1;

	// close the socket if it is open

	if( iSockIncoming != INVALID_SOCKET ) {

	  closesocket( iSockIncoming );

	  iSockIncoming = iSockOutgoing = INVALID_SOCKET;

	}

	// done 

	return 0;

}

/*******************************************************************************

 *

 * PUBLIC METHOD: GetLocalAddress 

 *

 ******************************************************************************/

void CUDPAirInterface::GetLocalAddress( struct sockaddr_in *aLocalAddress )

{

	assert( aLocalAddress != NULL );

	*aLocalAddress = iLocalAddress;

}

/*******************************************************************************

 *

 * PUBLIC METHOD: SetRemoteAddress

 *

 ******************************************************************************/

void CUDPAirInterface::GetRemoteAddress( struct sockaddr_in *aRemoteAddress )

{

	*aRemoteAddress = iRemoteAddress;

}

/*******************************************************************************

 *

 * PUBLIC METHOD: SetRemoteAddress

 *

 ******************************************************************************/

void CUDPAirInterface::SetRemoteAddress( struct sockaddr_in aRemoteAddress )

{

	iRemoteAddressValid = 1;

	iRemoteAddress = aRemoteAddress;

}

/*******************************************************************************

 *

 * PUBLIC METHOD: SetDatalink

 *

 ******************************************************************************/

void CUDPAirInterface::SetDatalink( IProcessData *aProcessData )

{

	iProcessData = aProcessData;

}

/*******************************************************************************

 *

 * PUBLIC METHOD: RPC-THREAD. SetFilter, called by the main setup call in 

 * cphone - links up all the bits.

 *

 ******************************************************************************/

void CUDPAirInterface::SetFilter( IFilter *aFilter )

{

	iFilter = aFilter;

}

/*******************************************************************************

 *

 * PUBLIC METHOD: TE-THREAD: SendPacket, when data is received on the te 

 * channel it eventually makes its way here (in its thread) to send the 

 * data out the uu interface.

 *

 ******************************************************************************/

TDataPathError CUDPAirInterface::SendPacket( char *data, int len, int *aErrCode )

{

	int err;

	//verify the params

	assert( data != NULL );

	assert( aErrCode != NULL );

	*aErrCode = 0;

	// make sure the remote address is set - not an error

	if( iRemoteAddressValid == 0 ) {

		return DPE_NONE;

	}

	// send the packet - send in 4k chunks to avoid system defined UDP packet size limit

	err = sendto( iSockOutgoing, data, len, 0, (struct sockaddr*)&iRemoteAddress, sizeof(iRemoteAddress) );

	if( err == SOCKET_ERROR ) {

		*aErrCode = GetSocketError();

		return DPE_SEND_FAILED;

	}

	// done

	return DPE_NONE;

}

/*******************************************************************************

 *

 * PRIVATE METHODS: Helper functions

 *

 ******************************************************************************/

int CUDPAirInterface::GetSocketError()

{

#ifdef WIN32

	return WSAGetLastError();

#else

	return errno;

#endif

}