// Copyright (c) 1997-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:

//

#include "FAXSERV.H"

#include "fax_reversebytes.h"

#include "FONT8X16.DAT"

#include "ZEROS.DAT"

#include "FAXMDRV.H"

#include "FAXMODEM.H"

#include "FAXLOG.H"

#include <et_phone.h>

const TInt KLineReadTimeout=6;				// < The time-out (in secs) for a line read

const TInt KECMLineReadTimeout=132;			// < The time-out (in secs) for a line read when using Error Correction Mode

const TInt KSubsequentLineReadTimeout=10;	// < The time-out (in secs) for a subsequent line read

const TInt KSubsequentECMLineReadTimeout=140;	// < The time-out (in secs) for a subsequent line read when using Error Correction Mode

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

// we need to keep a local pointer to the current TDialstorModemPreferences in order to

 // do whatever is required

void CFaxModemDriver::ConstructL (TFaxServerSessionSettings * iFaxServerSessionSettings, RFax::TProgress & aProgress)

{

	iModem = CFaxModem::NewL (iFaxServerSessionSettings, aProgress);

}

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

CFaxModemDriver::CFaxModemDriver()

                :CBase(), iSharedHandles(NULL)

{

}

CFaxModemDriver::~CFaxModemDriver ()

{

	delete iModem;

}

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

// function to check that we don't send commands out when there's less than half a second

// before the next RING comes in

/**

*	function to check that we don't send commands out when there's less than half a second

*	before the next RING comes in.

*	This function has been modified by Dmitry Lyokhin for the sake of PIA-586KGE defect fix

*

* @param	aCommand	-	contains the command to be sent to the modem.

*

* @see	ExportL function

*

* @return	number of symbols sent to the modem.

*			

*

*/

TInt CFaxModemDriver::CheckCadenceExportL(const TDesC8 & aCommand)

{

	const TInt RingTimeout_Sec	= 5;		//-- 5 sec. waiting for 'RING' timeout

	const TInt RingCadence_uSec	= 3000000;	//-- 3 sec. time span after 'RING' receiving during that commands 

											//-- can be sent to the modem

	const TInt CmdSendDelay_uSec= 100000;	//-- 100 ms delay between adjacent commands to the modem

	TTime CurrentTime;

    __FLOG_FAXSRV( _L8("-CFaxModemDriver::CheckCadenceExportL entering"));

	//-- @note iCadence now is used like a flag. If its value is 0 (thai is set initially) we will

	//-- try to wait for 'RING' indication i.e synchronize with incoming rings. Otherwise - no.

	while( iCadence.Int64() == 0 )

	{

		if(iTimeOfLastRing.Int64() == 0) 

		{//-- we need to wait for 'RING' from the modem

            __FLOG_FAXSRV( _L8("-CFaxModemDriver::CheckCadenceExportL waiting for RING"));

			//-- wait for 'RING' from modem

			if( iModem->GetMatchL (_L8 ("RING"), RingTimeout_Sec) == 0) 

			{	//User::Leave(KFaxErrReceiveTimeout); //-- 'RING' waiting timeout, leaving

				//-- There is no 'RING'indication, no we will not leave, instead of that

				//-- disable sync. with incoming rings and pass on to sending commands to the modem straightforward.

				iCadence = 1;

				break;

			}

			iTimeOfLastRing.UniversalTime(); //-- note the time

		}

		//-- get current time and check if we are in time to send a command to the modem

		CurrentTime.UniversalTime ();

		if( CurrentTime < iTimeOfLastRing + TTimeIntervalMicroSeconds32(RingCadence_uSec) )

			break; //-- send the command

		else

		{	//-- wait for the next 'RING'

            __FLOG_FAXSRV( _L8("-CFaxModemDriver::CheckCadenceExportL Resetting"));

			iTimeOfLastRing = 0;

		}

	}

	//-- I had to introduce this delay between sending adjacent commands to the modem because

	//-- some modems (e.g. Nokia9210) lose data.

	iModem->Silence(CmdSendDelay_uSec);

	//-- send the command

	return iModem->ExportL (aCommand);

}

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

// if we have called FaxInL with a dial request, it calls this routine

 // to dial up a fax on demand service

 //

 // if not polling, we end with a colon to return to command mode and then

 // we delay for whatever time has been requested by the user

 // before returning, at which point FaxInL continues with ATA

void CFaxModemDriver::DialFaxOnDemandL ()

{

	iModem->ExportL (_L8 ("ATD"));

	iModem->ExportL (iFaxServerSessionSettings->iPhoneNumber);

	if (iFaxServerSessionSettings->iMode & KFaxPoll)

		iModem->TxcharL (Kreturn);

	else

		{

		iModem->ExportL (_L8 (";"));

		iModem->TxcharL (Kreturn);

		if ((iModem->GetMatchL (_L8 ("OK"), KDialTimeout)) == 0)

			User::Leave (KFaxErrNoDial);

		iModem->Silence (CLK_TCK * iFaxServerSessionSettings->iFaxOnDemandDelay);

		}

}

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

// now the routines to add a header line to the top of each fax page

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

// we send four blank scan lines

 // we create a line of text containing time and date,

 // the Fax ID and Username,

 // the page number and total number of pages,

 // we digitize that, and send it out

 // our font height is 16 so that means 20 scan lines

 // are added to the top of each sent fax

void CFaxModemDriver::SendFaxHeaderL ()

{

	TFaxHeaderInfo faxHeader;

	TRawScanLine headline;

	TRawScanLine fontline;

	TBuf8 < KFaxT4MaxDesLength > encodedHeadLine;

	TTime timeOfTransmission;

	TBuf < 12 > timeText;

	timeOfTransmission.HomeTime();

	timeOfTransmission.FormatL (timeText, (_L ("%F%D%M%Y%H%T")));

	iModem->iOurMessage.Format (_L8 ("Sending page header"));

	iModem->ProgressUpdateL ();

	for (TInt r = iModem->iProgress.iResolution ; r >= 0; r--)

		{

		for (TInt x = 0, y = 4 ; x < 4; x++)

			{

			iModem->iTransmitBuffer.Append (0x00);

			if (iModem->iProgress.iCompression)

				{

				iModem->iTransmitBuffer.Append (Invert (0x00));

				iModem->iTransmitBuffer.Append (Invert (0x34));

				y = 5;

				}

			else

				iModem->iTransmitBuffer.Append (Invert (0x14));

			iModem->iTransmitBuffer.Append (Invert (0xD9));

			iModem->iTransmitBuffer.Append (Invert (0xA8));

			padLineL (y);

			}

		}

	CFaxT4 * faxT4 =CFaxT4::NewLC();

	faxT4->PageInitialize (iModem->iProgress.iResolution, iModem->iProgress.iCompression);

	if(!iSharedHandles)

		{

		User::Leave(KErrBadHandle);

		}

	CFaxHeaderLines * faxheader = CFaxHeaderLines::NewLC (&iSharedHandles->File());	

	faxheader->ReadFaxHeaderInfoL (faxHeader);

	for (TInt n = 0; n < 12; n++)

		timeText[n] -= '0';

	// Forces 2 digit day - 2 digit month - 4 digit year - 2 digit hour - 2 digit minute

	for (TInt scanline = 0; scanline < faxHeader.iHeaderFontHeightInLines; scanline++)

		{

		faxheader->ReadRawHeaderLineL (scanline, headline);

		faxheader->ReadRawFontLineL (scanline, fontline);

		for (TInt fontByte = 0; fontByte < faxHeader.iHeaderFontWidthInBytes; fontByte++)

			{

			headline[((faxHeader.iOffsetToDay) * faxHeader.iHeaderFontWidthInBytes) + fontByte] = fontline[(timeText[0] * faxHeader.iHeaderFontWidthInBytes) + fontByte];

			headline[((faxHeader.iOffsetToDay + 1) * faxHeader.iHeaderFontWidthInBytes) + fontByte] = fontline[(timeText[1] * faxHeader.iHeaderFontWidthInBytes) + fontByte];

			headline[((faxHeader.iOffsetToMonth) * faxHeader.iHeaderFontWidthInBytes) + fontByte] = fontline[(timeText[2] * faxHeader.iHeaderFontWidthInBytes) + fontByte];

			headline[((faxHeader.iOffsetToMonth + 1) * faxHeader.iHeaderFontWidthInBytes) + fontByte] = fontline[(timeText[3] * faxHeader.iHeaderFontWidthInBytes) + fontByte];

			headline[((faxHeader.iOffsetToYear) * faxHeader.iHeaderFontWidthInBytes) + fontByte] = fontline[(timeText[4] * faxHeader.iHeaderFontWidthInBytes) + fontByte];

			headline[((faxHeader.iOffsetToYear + 1) * faxHeader.iHeaderFontWidthInBytes) + fontByte] = fontline[(timeText[5] * faxHeader.iHeaderFontWidthInBytes) + fontByte];

			headline[((faxHeader.iOffsetToYear + 2) * faxHeader.iHeaderFontWidthInBytes) + fontByte] = fontline[(timeText[6] * faxHeader.iHeaderFontWidthInBytes) + fontByte];

			headline[((faxHeader.iOffsetToYear + 3) * faxHeader.iHeaderFontWidthInBytes) + fontByte] = fontline[(timeText[7] * faxHeader.iHeaderFontWidthInBytes) + fontByte];

			headline[((faxHeader.iOffsetToHour) * faxHeader.iHeaderFontWidthInBytes) + fontByte] = fontline[(timeText[8] * faxHeader.iHeaderFontWidthInBytes) + fontByte];

			headline[((faxHeader.iOffsetToHour + 1) * faxHeader.iHeaderFontWidthInBytes) + fontByte] = fontline[(timeText[9] * faxHeader.iHeaderFontWidthInBytes) + fontByte];

			headline[((faxHeader.iOffsetToMinute) * faxHeader.iHeaderFontWidthInBytes) + fontByte] = fontline[(timeText[10] * faxHeader.iHeaderFontWidthInBytes) + fontByte];

			headline[((faxHeader.iOffsetToMinute + 1) * faxHeader.iHeaderFontWidthInBytes) + fontByte] = fontline[(timeText[11] * faxHeader.iHeaderFontWidthInBytes) + fontByte];

			// put the page info in

			if (iModem->iProgress.iPage > 9)

				headline[((faxHeader.iOffsetToCurrentPage) * faxHeader.iHeaderFontWidthInBytes) + fontByte] = fontline[((iModem->iProgress.iPage / 10) * faxHeader.iHeaderFontWidthInBytes) + fontByte];

			headline[((faxHeader.iOffsetToCurrentPage + 1) * faxHeader.iHeaderFontWidthInBytes) + fontByte] = fontline[((iModem->iProgress.iPage % 10) * faxHeader.iHeaderFontWidthInBytes) + fontByte];

			if (iFaxServerSessionSettings->iTxPages > 9)

				headline[((faxHeader.iOffsetToTotalPages) * faxHeader.iHeaderFontWidthInBytes) + fontByte] = fontline[((iFaxServerSessionSettings->iTxPages / 10) * faxHeader.iHeaderFontWidthInBytes) + fontByte];

			headline[((faxHeader.iOffsetToTotalPages + 1) * faxHeader.iHeaderFontWidthInBytes) + fontByte] = fontline[((iFaxServerSessionSettings->iTxPages % 10) * faxHeader.iHeaderFontWidthInBytes) + fontByte];

			}

		// we send the line once in normal resolution but twice in fine resolution

		for (TInt r = iModem->iProgress.iResolution ; r >= 0; r--)

			{

			faxT4->EncodeScanLine (headline, encodedHeadLine);

			// always add the extra null at the start for the initial eol

			iModem->iTransmitBuffer.Append (Knul);

			// and then invert and finally send the encoded line

			const TUint8 *px = CONST_CAST (TUint8 *, encodedHeadLine.Ptr ());

			const TUint8 *ex = px + encodedHeadLine.Length ();;

			TUint8 thisChar;

			TInt bytesSent = 0;

			while (px < ex)

				{

				thisChar = Invert (*px++);

				iModem->iTransmitBuffer.Append (thisChar);

				if (thisChar == Kdle)

					iModem->iTransmitBuffer.Append (Kdle);

				iModem->SendTransmitBufferL ();

				bytesSent++;

				}

			padLineL (bytesSent);

			}

		}

	CleanupStack::PopAndDestroy(faxheader);

    CleanupStack::PopAndDestroy(faxT4);

}

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

// this function handles line padding out for minimum scan line times

 // this feature should really only be needed on class 1 modems ...

 // it takes a single integer parameter, which is the number of bytes sent

void CFaxModemDriver::padLineL (TInt aByteCount)

{

	if (iFaxServerSessionSettings->iFaxClass == EClass1)

		{

		while (iMinlinelength > aByteCount)

			{

			aByteCount++;

			iModem->iTransmitBuffer.Append (Knul);

			iModem->SendTransmitBufferL ();

			}

		}

}

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

// rewritten to avoid using any AT commands August 1997 Andrew Margolis

 // pointer arithmetic courtesy of Andrew Thoelke

 // Though this doesn't use any AT command but it does need to know

 // about the various modem classes ... GetFaxDataL is in the same boat

// the client has buffered up lines to minimize interaction

 // aData starts with a TInt containing the number of lines

 // Each line follows, preceded with a TInt containing its length

 // which must be copied as it might not be aligned on a 4-byte

 // boundary

TInt CFaxModemDriver::SendFaxDataL (const TDesC8 * aData)

{

	TUint8 thisChar;

	TInt ticks;

	TInt numberOfLines;

	TInt lengthOfLine;

	TUint8 *thisLine = CONST_CAST (TUint8 *, (*aData).Ptr ());

	Mem::Copy (&numberOfLines, thisLine, sizeof (TInt));

	thisLine += sizeof (TInt);

	// buffering debug message

	iModem->iOurMessage.Format (_L8 ("%u lines in buffer taking up %u bytes"), numberOfLines, (*aData).Length ());

	iModem->ProgressUpdateL ();

	while (numberOfLines--)

		{

		Mem::Copy (&lengthOfLine, thisLine, sizeof (TInt));

		thisLine += sizeof (TInt);

		iModem->iProgress.iLines++;

		TInt bytesSent = 0;

		const TUint8 *px = thisLine;

		const TUint8 *ex = px + lengthOfLine;

		while (px < ex)

			{

			thisChar = Invert (*px++);

			iModem->iTransmitBuffer.Append (thisChar);

			if (thisChar == Kdle)

				iModem->iTransmitBuffer.Append (Kdle);

			iModem->SendTransmitBufferL ();

			bytesSent++;

			}

		padLineL (bytesSent);

		// we must check for cancel commands from the modem in class 2.0 transmission

		if (iFaxServerSessionSettings->iFaxClass == EClass2point0)

			{

			while (iModem->Rxstat () != 0)

				{

				ticks = CLK_TCK;

				iModem->RxcharWaitL (ticks);

				if (iModem->iReadone[0] == Kcan)

					{

					iModem->TxcharL (Kdle);

					iModem->TxcharL (Ketx);

					iModem->CommitTransmitBufferL ();

					iModem->Xonoff ();

					iModem->GetMatchL (_L8 ("OK"), 5);

					return (KFaxErrModemDisconnect);

					}

				}

			}

		thisLine += lengthOfLine;

		}

	return (KErrNone);

}

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

 // This function takes a pointer to a binary data buffer.

 // We are guaranteed that the buffer is big enough to take

 // two entire scan lines up to KMaxT4Des in size.

 // We call GetLineL to fill the buffer up with scan lines, and

 // we keep a count of the number of lines received as an integer

 // at the start of the buffer.  We return when either we haven't

 // enough room to guarantee another line, or when we have received

 // a line of zero length, which means an end of page. The descriptor

 // is set to the correct length on return

 // So on return, aData starts with a TInt containing the number of lines

 // Each line follows, preceded with a TInt containing its length

 // which must be copied as it might not be aligned on a 4-byte

 // boundary - a line of zero length indicates we have reached

 // the end of the page

void CFaxModemDriver::GetFaxDataL (TDes8 * aData)

{

	TUint8 *startData;

	TUint8 *lineData;

	const TUint8 *maxData;

	TInt lineLength;

	TInt numberOfLines = 0;

	lineData = startData = CONST_CAST (TUint8 *, (*aData).Ptr ());

	maxData = startData + (*aData).MaxLength () - KMaxT4Des - sizeof (TInt);

	(*aData).SetMax ();

	lineData += sizeof (TInt);

	for (;;)

		{

		numberOfLines++;

		lineLength = GetLineL (lineData);

		Mem::Copy (lineData, &lineLength, sizeof (TInt));

		lineData += sizeof (TInt);

		lineData += lineLength;

		if (lineData > maxData)

			break;

		if (lineLength == 0)

			break;

		}

	Mem::Copy (startData, &numberOfLines, sizeof (TInt));

	(*aData).SetLength (lineData - startData);

	// buffering debug message

	iModem->iOurMessage.Format (_L8 ("%u lines in buffer taking up %u bytes"), numberOfLines, (*aData).Length ());

	iModem->ProgressUpdateL ();

}

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

// This function takes a pointer to a binary data buffer.

 // We are guaranteed that the buffer is big enough to take

 // an entire scan line up to KMaxT4Des in size.

 // We receive the scan line, with a leave if we timeout.

 // We return with the length of the scan line and the buffer has

 // a space for this to be placed as an integer by the caller,

 // followed by the scan line data.  If the length of the scan line

 // is zero, we have reached the end of the page

TInt CFaxModemDriver::GetLineL (TUint8 * aFaxData)

{

	TUint8 *lineStart;

	TUint8 *lineEnd;

	TUint8 *currentByte;

	lineStart = currentByte = (aFaxData + sizeof (TInt));

	lineEnd = lineStart + KMaxT4Des;

	TUint8 thisChar = 0;

	TUint8 leading0s = 0;

	TUint8 trailing0s = 0;

	TInt nullcount = 0;

	TInt ticks = CLK_TCK * KLineReadTimeout;

	if (iModem->iProgress.iECM != 0)

		ticks = CLK_TCK * KECMLineReadTimeout;

	iModem->iProgress.iLines++;

	TInt bol = 1;

	TUint8 lastChar = 0xff;

	// lastChar set to 0xff flags the entry to the function

	// during iterations lastChar must be either 0 or 1

	// we always come here just after detecting an EOL, and the character

	// which contains the EOL bit is guaranteed to be re-readable

	// lastChar set to 0xff indicates that's is not been read,

	// so we re-read it, set its trailing0s, and put it in the buffer

	// without bothering to do any dle checking (we already know it's ok)

	for (;;)

		{

		if (lastChar == 0xff)

			{

			lastChar = 0;

			thisChar = iModem->iReadone[0];

			}

		else

			{

			if ((iModem->RxcharWaitL (ticks)) == 0)

				User::Leave (KFaxErrReceiveTimeout);

			thisChar = iModem->iReadone[0];

			// check if we have the character after a leading dle

			// if we have unmark the last character as being a dle -

			// dle etx is end of data

			// dle dle is a shielded dle

			// dle sub is two times dle for class 2.0 only

			// dle and anything else we ignore

			if (lastChar == Kdle)

				{

				lastChar = 0;

				if (thisChar == Ketx)

					{

					iModem->iOurMessage.Format (_L8 ("<dle><etx> detected after %u lines"), iModem->iProgress.iLines);

					iModem->ProgressUpdateL ();

					return (0);

					}

				if (iFaxServerSessionSettings->iFaxClass == EClass2point0)

					{

					if (thisChar == 0x1a)

						{

						thisChar = Kdle;

						*currentByte++ = Invert (thisChar);   // invert class 2.0

						if (currentByte == lineEnd)

							{

							return (KMaxT4Des);

							}

						trailing0s = 4;

						}

					}

				if (thisChar != Kdle)

					continue;

				}                   // drop through only with a data dle

			// if not a trailing dle

			// check if this character is itself a leading dle

			// drop through only if it isn't

			else if (thisChar == Kdle)

				{

				lastChar = Kdle;

				continue;

				}

			}

		// if we've received six EOL codes already, ignore everything

		// till dle etx arrives

		if (bol == 6)

			continue;

		// have we a null ? if yes we ignore nulls if they come in

		// anything more than pairs - if no, we zero nullcount and