/*

* 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 <assert.h>

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

 *

 * LocalIncludes

 *

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

#include "CSerialTcpRelay.h"

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

 *

 * Definitions

 *

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

#define SOCKET_TIMEOUT (1000)

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

 *

 * PUBLIC METHOD: CSerialTcpRelay

 *

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

CSerialTcpRelay::CSerialTcpRelay() : iSerialThread("SerialThread"), iSocketThread("SocketThread")

{

	iSerialPort = NULL;

	iSocket = INVALID_SOCKET;

	iState = iSerialState = iSocketState = RS_NEW;

}

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

 *

 * PUBLIC METHOD: ~CSerialTcpRelay

 *

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

CSerialTcpRelay::~CSerialTcpRelay()

{

	assert( iSocket == INVALID_SOCKET );

	assert( iState != RS_ACTIVE );

	assert( iSerialState != RS_ACTIVE );

	assert( iSocketState != RS_ACTIVE );

}

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

 *

 * PUBLIC METHOD: InitialiseRelay

 *

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

TRelayError CSerialTcpRelay::InitialiseRelay( CSerialPort *aSerialPort, SOCKADDR_IN aRemoteAddress, char *aInitialBuffer, int aBufferLength, int *aErrCode )

{

	int err;

	// check params

	assert( aSerialPort != NULL );

	assert( aErrCode != NULL );

	// save the state vars

	*aErrCode = 0;

	iSerialPort = aSerialPort;

	iRemoteAddress = aRemoteAddress;

	// open the socket

	iSocket = socket( AF_INET, SOCK_STREAM, 0 );

	if( iSocket == INVALID_SOCKET ){

		*aErrCode = WSAGetLastError();

		return RE_SOCKET_FAILED;

	}

	err = connect( iSocket, (struct sockaddr*)&iRemoteAddress, sizeof(iRemoteAddress) );

	if( err == SOCKET_ERROR ) {

		*aErrCode = WSAGetLastError();

		closesocket( iSocket );

		iSocket = INVALID_SOCKET;

		return RE_CONNECT_FAILED;

	}

	// if there is some initial data then send it

	if( (aInitialBuffer != NULL) && (aBufferLength > 0) ) {

		err = send( iSocket, aInitialBuffer, aBufferLength, 0 );

		if( err != aBufferLength ) {

			*aErrCode = WSAGetLastError();

			closesocket( iSocket );

			iSocket = INVALID_SOCKET;

			return RE_INITIAL_SEND_FAILED;

		}

	}

	// update the state

	iState = iSerialState = iSocketState = RS_ACTIVE;

	// ok we are ready to go

	return RE_SUCCESS;

}

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

 *

 * PUBLIC METHOD: ExecuteRelay

 *

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

TRelayError CSerialTcpRelay::ExecuteRelay()

{

	TThreadError terr;

	int errcode;

	// create the serial thread

	terr = iSerialThread.StartThread( CSerialTcpRelay::SerialThreadProc, this, &errcode );

	assert( terr == TE_NONE );

	// create the socket thread

	terr = iSocketThread.StartThread( CSerialTcpRelay::SocketThreadProc, this, &errcode );

	assert( terr == TE_NONE );

	// wait for the serial thread to exit

	terr = iSerialThread.WaitForThread( INFINITE );

	assert( terr == TE_NONE );

	// wait for the socket thread to exit

	terr = iSocketThread.WaitForThread( INFINITE );

	assert( terr == TE_NONE );

	// done

	iState = RS_CLOSED;

	return RE_SUCCESS;

}

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

 *

 * PRIVATE METHOD: ExecuteSerialThread

 *

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

TRelayError CSerialTcpRelay::ExecuteSerialThread()

{

	int err, bytes_read;

	DWORD dwModemStatus;

	// repeat...

	while( 1 ) {

		// read from the serial port

		bytes_read = SERIALREADBUFFSIZE;

		err = iSerialPort->ReceiveBytes( iSerialReadBuffer, &bytes_read );

		// if there was an error other than timeout then break

		if( err != 0 ) {

			break;

		}

		// write any received data to the socket - break on error

		if( bytes_read > 0 ) {

//			fprintf( stderr, "DEBUG: serial <-> socket (%d)\n", bytes_read );

			err = send( iSocket, iSerialReadBuffer, bytes_read, 0 );

			if( err != bytes_read ) {

				break;

			}

		}

		// check the serial line flags - if the peer has lowered cts or dsr then

		// we take this as meaning that they have closed the port

		err = GetCommModemStatus( iSerialPort->Handle(), &dwModemStatus );

		assert( err != 0 );

		if( ((dwModemStatus & MS_CTS_ON) == 0) ) {

			break;

		}

		// if the socket thread has exited then exit

		if( iSocketState == RS_CLOSED ) {

			break;

		}

	}

	// set my status to closed 

	iSerialState = RS_CLOSED;

	return RE_SUCCESS;

}

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

 *

 * PRIVATE METHOD: ExecuteSerialThread

 *

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

TRelayError CSerialTcpRelay::ExecuteSocketThread()

{

	int err, bytes_read, bytes_written;

	struct timeval read_timeout;

	fd_set read_fds;

	// repeat...

	while( 1 ) {

		// setup things

		read_timeout.tv_sec = 0;

		read_timeout.tv_usec = (SOCKET_TIMEOUT*1000);

		FD_ZERO( &read_fds );

		FD_SET( iSocket, &read_fds );

		// see if data is available

		err = select( 1, &read_fds, NULL, NULL, &read_timeout );

		// break on errors

		if( err == SOCKET_ERROR ) {

			break;

		}

		// if there is data available then read it - break on error

		if( err != 0 ) {

			bytes_read = recv( iSocket, iSocketReadBuffer, SOCKETREADBUFFSIZE, 0 );

			if( bytes_read <= 0 ) {

				break;

			}

		}

		// write any received data to the serial port - break on error

		if( bytes_read > 0 ) {

			bytes_written = bytes_read;

//			fprintf( stderr, "DEBUG: socket <-> serial (%d)\n", bytes_read );

			err = iSerialPort->SendBytes( iSocketReadBuffer, &bytes_written );

			if( err != 0 ) {

				break;

			}

		}

		// if the serial thread has exited then exit

		if( iSerialState == RS_CLOSED ) {

			break;

		}

	}

	// close the socket

	closesocket( iSocket );

	iSocket = INVALID_SOCKET;

	// set my status to closed 

	iSocketState = RS_CLOSED;

	return RE_SUCCESS;

}

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

 *

 * PRIVATE METHOD: Thread Entry Procs

 *

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

int CSerialTcpRelay::SerialThreadProc( CSerialTcpRelay *aRelay )

{

	return (int)aRelay->ExecuteSerialThread();

}

int CSerialTcpRelay::SocketThreadProc( CSerialTcpRelay *aRelay )

{

	return (int)aRelay->ExecuteSocketThread();

}