// 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 "FAXMDRV.H"

#include "FAXMODEM.H"

// this module has three parts

// first receive routines rx

// second transmit routines tx

// third utilities

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

CFaxModemDriver *CFaxClass1::NewLC (TFaxServerSessionSettings * aFaxServerSessionSettings, RFax::TProgress & aProgress)

{

	CFaxModemDriver *self = new (ELeave) CFaxClass1;

	CleanupStack::PushL (self);

	self->ConstructL (aFaxServerSessionSettings, aProgress);

	return self;

}

CFaxModemDriver *CFaxClass1::NewL (TFaxServerSessionSettings * aFaxServerSessionSettings, RFax::TProgress & aProgress)

{

	CFaxModemDriver *self = NewLC (aFaxServerSessionSettings, aProgress);

	CleanupStack::Pop ();

	return self;

}

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

// here we set up a fax receive - Phase A

// this does require HDLC frames to be sent

TInt CFaxClass1::RxConnectL ()

{

	TInt faxIdFcf;               // CSI or CIG

	TInt capabilityFcf;          // DIS or DTC

	TBuf8 < 3 > faxIdTxt;        // CSI or CIG

	TBuf8 < 3 > capabilityTxt;   // DIS or DTC

	TInt i, x;

	iDisBytes = 3;

	iOldFrame.Zero ();

	// we query the modem to find out what its speed capabilities are

    CheckCadenceExportL (_L8 ("AT+FRM=?\r"));

    // coverity[check_return]

    iModem->ImportL (iResults, 2);

    iModem->iOurMessage.Format (_L8 ("%S"), &iResults);

    iModem->ProgressUpdateL ();

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

	// the available speeds are stored in iResults

	// we set our proposed speed to the highest compatible with faxini settings

	if ((iResults.FindF (_L8 ("24"))) >= 0)

		iActualFaxSpeed = 24;

	else

		return (KFaxErrModemNotWorking);

	if ((iFaxServerSessionSettings->iMaxSpeed) > 2400)

		if ((iResults.FindF (_L8 ("48"))) >= 0)

			iActualFaxSpeed = 48;

	if ((iFaxServerSessionSettings->iMaxSpeed) > 4800)

		if ((iResults.FindF (_L8 ("96"))) >= 0)

			iActualFaxSpeed = 96;

	if ((iFaxServerSessionSettings->iMaxSpeed) > 9600)

		if ((iResults.FindF (_L8 ("145"))) >= 0)

			iActualFaxSpeed = 145;

	// we now prepare our DIS/DTC answer capabilities frame

	// the resolution and compression are taken from our settings

	for (x = 0; x < 5; x++)

		iDisFrame.byte[x] = 0;

	iDisFrame.bit.b09 = 0;

	iDisFrame.bit.b10 = 1;

	iDisFrame.bit.b20 = 1;

	iDisFrame.bit.b21 = 1;

	iDisFrame.bit.b22 = 1;

	iDisFrame.bit.b23 = 1;

	if (iFaxServerSessionSettings->iRxResolution == EFaxFine)

		iDisFrame.bit.b15 = 1;

	if (iFaxServerSessionSettings->iRxCompression == EModifiedRead)

		iDisFrame.bit.b16 = 1;

//	if (iFaxServerSessionSettings->iMode & KFaxWaitForRing)

//		{

	//	while ((iModem->GetMatchL (_L8 ("RING"), 3)) == 0);

	//	iTimeOfLastRing.UniversalTime();

//		}

//	else

//		{

		if (((iFaxServerSessionSettings->iMode & KFaxOffHook) == 0) && (!(iFaxServerSessionSettings->iMode & KFaxWaitForRing)))

//		if ((iFaxServerSessionSettings->iMode & KFaxOffHook) == 0)

			DialFaxOnDemandL ();

//		}

	// if we a trying to poll, we've dialled, so we wait for a DIS from the answerer

	// otherwise we do an answer ourselves

	if (iFaxServerSessionSettings->iMode & KFaxPoll)

		{

		faxIdFcf = KT30_CIG;

		faxIdTxt.Copy (_L8 ("CIG"));

		capabilityFcf = KT30_DTC;

		capabilityTxt.Copy (_L8 ("DTC"));

		iModem->iOurMessage.Format (_L8 ("about to poll fax"));

		}

	else

		{

		faxIdFcf = KT30_CSI;

		faxIdTxt.Copy (_L8 ("CSI"));

		capabilityFcf = KT30_DIS;

		capabilityTxt.Copy (_L8 ("DIS"));

		CheckCadenceExportL (_L8 ("ATA\r"));

		iModem->iOurMessage.Format (_L8 ("about to receive fax"));

		}

	iModem->iProgress.iPhase = ECallEstablishment;

	iModem->ProgressUpdateL ();

	for (;;)

		{

		if (!(iModem->ImportL (iResults, KT30_T1)))

			return (KFaxErrCannotConnect);

		iModem->iOurMessage.Format (_L8 ("%S"), &iResults);

		iModem->ProgressUpdateL ();

		if ((iResults.FindF (_L8 ("NO DIALTONE"))) >= 0 ||

			iResults.FindF (_L8 ("NO DIAL TONE")) >= 0)

			return (KFaxErrNoDialTone);

		if ((iResults.FindF (_L8 ("BUSY"))) >= 0)

			return (KFaxErrBusy);

		if ((iResults.FindF (_L8 ("NO ANSWER"))) >= 0)

			return (KFaxErrNoAnswer);

		if ((iResults.FindF (_L8 ("NO CARRIER"))) >= 0)

			return (KFaxErrNoCarrier);

		if ((iResults.FindF (_L8 ("CONNECT"))) >= 0)

			break;

		}

	if (iFaxServerSessionSettings->iMode & KFaxPoll)

		User::LeaveIfError (RxPrePollL ());

	else

		{

		iModem->iOurMessage.Format (_L8 ("Fax call detected"));

		iModem->ProgressUpdateL ();

		}

	iModem->iOurMessage.Format (_L8 ("sending %S"), &faxIdTxt);

	iModem->ProgressUpdateL ();

	iFrame.Zero ();

	iFrame.Append (KT30_CTLNXT);

	iFrame.Append (faxIdFcf);

	for (i = 20; i > iFaxServerSessionSettings->iFaxId.Length (); i--)

		iFrame.Append (0x20);

	for (i = iFaxServerSessionSettings->iFaxId.Length (); i;)

	iFrame.Append (iFaxServerSessionSettings->iFaxId[--i]);

	if (SendframeL (iFrame) != 1)

		return (KFaxErrCSIorCIG);

	// we follow that with our DIS frame

	iModem->iOurMessage.Format (_L8 ("sending %S"), &capabilityTxt);

	iModem->iProgress.iPhase = ESessionNegotiation;

	iModem->ProgressUpdateL ();

	iDisFrame.byte[1] &= 0xc3;

	switch (iActualFaxSpeed)

		{

		case 48:

			iDisFrame.byte[1] |= 0x08;

			break;                 /* V.27 4800+2400            */

		case 96:

			iDisFrame.byte[1] |= 0x0c;

			break;                 /* & V.29 9600+7200            */

		case 145:

			iDisFrame.byte[1] |= 0x2c;

			break;                 /* & V.17 14400+1200+9600+7200 */

		default:

			iDisFrame.byte[1] |= 0x00;     /* V.27 fallback 2400 only     */

		}

	iFrame.Zero ();

	iFrame.Append (KT30_CTLLST);

	iFrame.Append (capabilityFcf);

	for (i = 0; i < iDisBytes; i++)

		iFrame.Append (iDisFrame.byte[i]);

	if (SendframeL (iFrame) != 1)

		return (KFaxErrDISorDTC);

	// and now we await the negotiation from the caller

	// note that we'll resend the last frame (DIS or DTC) if we get no reply

	// until we get a TSI or a DCS (which show the DIS or DTC was received)

	return (RxPrePageL ());

}

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

// here we prepare for receiving via a poll

 // we have received a DIS in iResults, so check the polling bit

 // iResults[0] is the address

 // iResults[1] is the control

 // iResults[2] is the FCF

 // iResults[3] has bits 1-8 of the FIF

 // iResults[4] has bits 9-16 of the FIF

 // the polling bit is bit 9

TInt CFaxClass1::RxPrePollL ()

{

	TInt pollDocsAvailable = 0;

	TInt i;

	iResults.Copy (_L8 ("CALL JUST ANSWERED"));

	for (;;)

		{

		if (GetframeL (iResults) == 0)

			return (KFaxErrFrameFail);

		iModem->ProgressUpdateL ();

		// the third byte in the frame is the FCF (fax control field)

		switch ((TUint8) iResults[2])

			{

			case 0x20:            // this marks a non-standard frame, which we ignore

				iModem->iOurMessage.Format (_L8 ("NSF nonstandard facilities Frame"));

				iModem->ProgressUpdateL ();

				break;

			case 0x40:            // this marks the receiver ID

				iModem->iOurMessage.Format (_L8 ("CSI identity Frame"));

				iModem->ProgressUpdateL ();

				iModem->iProgress.iAnswerback.Zero ();

				for (i = 22; i > 2; i--)

					iModem->iProgress.iAnswerback.Append (iResults[i]);

				iModem->iOurMessage.Format (_L8 ("Remote fax ID is %S"), &iModem->iProgress.iAnswerback);

				iModem->ProgressUpdateL ();

				break;              // the capability frame should follows

			case 0x80:            // this marks the receiver capability frame

				iModem->iOurMessage.Format (_L8 ("DIS capability Frame"));

				iModem->ProgressUpdateL ();

				iFcfXbit = 1;       // we've received a DIS, so set the X bit

				pollDocsAvailable = iResults[4] & 0x01;     // and record the polling bit too

				break;

			case 0xfa:            // this means we were asked to disconnect

				RxDCNL ();

				return (KFaxErrRemoteDCN);

			default:;

			}

		// if a final frame we return

		// else we just issue AT+FRH=3 and continue

		if (iResults[1] & 0x10)

			break;

		iModem->ExportL (_L8 ("AT+FRH=3\r"));

		}

	if (pollDocsAvailable)

		{

		iModem->iOurMessage.Format (_L8 ("Polling bit set"));

		iModem->ProgressUpdateL ();

		return (KErrNone);

		}

	return (KFaxNothingToPoll);  // if the other machine isn't pollable we exit

}

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

// here we negotiate a fax reception - Phase B

 // this function is always called after we have connected. However,

 // it can be called at other times if we have requested a renegotiation

 // or if the sender want to change the fax parameters

TInt CFaxClass1::RxPrePageL ()

{

	TInt x, z, i, nullCounter;

	TUint8 thisChar, lastChar;

	TInt ticks;

	for (;;)

		{

		iModem->ExportL (_L8 ("AT+FRH=3\r"));

		if (GetframeL (iResults) == 0)

			return (KFaxErrFrameFail);

		iModem->iOurMessage.Format (_L8 ("Response received"));

		iModem->ProgressUpdateL ();

		// analyse the possible responses

		switch ((TUint8) iResults[2])

			{

			case 0x42:            // this is the sender ID - their capability should follow

				iModem->iOurMessage.Format (_L8 ("TSI identity Frame"));

				iModem->ProgressUpdateL ();

				iModem->iProgress.iAnswerback.Zero ();

				for (i = 22; i > 2; i--)

					iModem->iProgress.iAnswerback.Append (iResults[i]);

				iModem->iOurMessage.Format (_L8 ("Remote fax ID is %S"), &iModem->iProgress.iAnswerback);

				iModem->ProgressUpdateL ();

				break;

			case 0x82:            // here's the sender capability frame - the most complex case

				iModem->iOurMessage.Format (_L8 ("DCS capability Frame"));

				iModem->ProgressUpdateL ();

				for (i = 0; i < 5; i++)

					iDcsFrame.byte[i] = (TUint8) iResults[i + 3];

				// we have the DCS saved - we analyse it for speed and resolution and compression

				if (iDcsFrame.bit.b24 == 0)

					iDcsFrame.byte[3] = 0;

				iModem->iProgress.iResolution = TFaxResolution (iDcsFrame.bit.b15);

				iModem->iProgress.iCompression = TFaxCompression (iDcsFrame.bit.b16);

				switch (iDcsFrame.byte[1] & 0x3c)

					{

				case 0x08:

					iActualFaxSpeed = 48;

					break;        /* 4800  V.27 */

				case 0x04:

					iActualFaxSpeed = 96;

					break;        /* 9600  V.29 */

				case 0x0c:

					iActualFaxSpeed = 72;

					break;        /* 7200  V.29 */

				case 0x24:

					iActualFaxSpeed = 97;

					break;        /* 9600  V.17 */

				case 0x2c:

					iActualFaxSpeed = 73;

					break;        /* 7200  V.17 */

				case 0x20:

					iActualFaxSpeed = 145;

					break;        /* 14400 V.17 */

				case 0x28:

					iActualFaxSpeed = 121;

					break;        /* 12000 V.17 */

				default:

					iActualFaxSpeed = 24; /* 2400  V.27 */

					}

				i = (iActualFaxSpeed & (~1));

				// now we prepare to recieve the training frame that follows the DCS

				// we try to get the carrier at this speed three times before giving up

				for (x = 0; x < 3; x++)

					{

					iModem->iOurMessage.Format (_L8 ("setting %d00"), i);

					iModem->iProgress.iSpeed = (i * 100);

					iModem->ProgressUpdateL ();

					iResults.Copy (_L8 ("AT+FRM="));

					iResults.AppendNum (iActualFaxSpeed);

					iResults.Append (_L8 ("\r"));

					iModem->ExportL (iResults);

					z = FramestatL ();

					if (z == 1)

						break;

				if (z != 0)

					{

					iModem->TxcharL (Kcan);

					if (FramestatL () < 0)

						iModem->TxcharL (Kreturn);

					ReceiveSilenceL ();

					iModem->iOurMessage.Format (_L8 ("sending FTT"));

					iModem->ProgressUpdateL ();

					iFrame.Append (KT30_FTT);

					if (SendframeL (iFrame) == 0)

						return (KFaxErrTrainFail);

					break;

					}

					}

				if (x == 3)

					return (KFaxErrAtNegotiatedSpeed);

				// once we have a carrier, we start receiving the training frame

				// we look for a clear 750 milliseconds of zeros ending in <dle><etx>

				// this is determined by calculating the number of number of null bytes

				// taken at any given speed

				iModem->iOurMessage.Format (_L8 ("training .... "));

				iModem->ProgressUpdateL ();

				ticks = (CLK_TCK * 165) / 100;	// bug fix - was originally "CLK_TICK * (165/100)"

												// This failed because 165/100 is rounded to 1 because

												// ticks is an integer and that made the fax server

												// training for 1 second instead of 1.5

				for (lastChar = 0, nullCounter = 0;;)

					{

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

						{

						break;

						}

					thisChar = iModem->iReadone[0];

					if (nullCounter != (i * 75 / 8))

						{

						if (thisChar != 0)

							nullCounter = 0;

						else

							++nullCounter;

						}

					if ((thisChar == Ketx) && (lastChar == Kdle))

						break;

				lastChar = thisChar;

					}

				if (FramestatL () < 0)

					{

					iModem->TxcharL (Kcan);

					if (FramestatL () < 0)

						iModem->TxcharL (Kreturn);

					}

				// now we check the count of null bytes and either send FTT

				// (in which case the sender will send a new DCS and try again)

				// or else send CFR confirmation and wait for the first page

				iFrame.Zero ();

				iFrame.Append (KT30_CTLLST);

				if (nullCounter == (i * 75 / 8))

					{

					iModem->iOurMessage.Format (_L8 ("training OK"));

					iModem->ProgressUpdateL ();

					}

				else

					{

					ReceiveSilenceL ();

					iModem->iOurMessage.Format (_L8 ("sending FTT"));

					iModem->ProgressUpdateL ();

					iFrame.Append (KT30_FTT);

					if (SendframeL (iFrame) == 0)

						return (KFaxErrTrainFail);

					break;

					}

				iModem->iOurMessage.Format (_L8 ("sending CFR"));

				iModem->ProgressUpdateL ();

				iFrame.Append (KT30_CFR);

				if (SendframeL (iFrame) == 0)

					return (KFaxErrCFR);

				// after we send a CFR, we interpret a failure to

				// establish a high-speed carrier as an indication

				// that the sender didn't get our CFR, and will

				// act as if they received an FTT

				if (RxSetHighSpeedL () != KErrNone)

					break;

			return (KErrNone);

			// lastly, we cater for the sender disconnecting us,

			// either because we couldn't train or because our

			// capabilities were wrong, or because they were only trying

			// to hack our fax machine

			case 0xfa:

				RxDCNL ();

				return (KFaxErrRemoteDCN);

			default:;

			}

		}

}

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

// this is a small function to set a class 1 fax modem to phase C

 // reception speed (found in iActualFaxSpeed) in preparation for

 // receiving data.  This is called before the first page and also

 // between pages.  If the modem can't find a high speed carrier, we

 // leave the caller to decide what action to take - if we'd just sent a

 // page confirmation we should try resending our last negotiating frame

 // in case it was lost, but if we have just sent a CFR, we wait for the

 // sender to retrain.

// If the protocol is out of sync and we get a low speed carrier

 // then we'll get a +FCERROR response (same as ERROR)

TInt CFaxClass1::RxSetHighSpeedL ()

{

	TInt x, portSpeed;

	switch (iActualFaxSpeed)

		{

		case 145:

			x = 144;

			portSpeed = 146;

			break;

		case 121:

			x = 120;

			portSpeed = 122;

			break;

		case 97:

			x = 96;

			portSpeed = 98;

			break;

		case 73:

			x = 72;

			portSpeed = 74;

			break;

		default:

			x = portSpeed = iActualFaxSpeed;

		}

	iModem->iOurMessage.Format (_L8 ("setting %d00"), x);

	iModem->iProgress.iSpeed = (x * 100);

	iModem->ProgressUpdateL ();

	iResults.Copy (_L8 ("AT+FRM="));

	iResults.AppendNum (portSpeed);

	iResults.Append (_L8 ("\r"));