// 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:

// CFaxModem class implementation

// 

//

/**

 @file

*/

#include "FAXSERV.H"

#include <e32hal.h>

#include "FAXMODEM.H"

#include "FAXLOG.H"

// we embed this so that the session log tells us the version used

#define FaxTransVersionString "FAX SERVER SESSION LOG (Release 033)" 

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

CFaxModem::CFaxModem (RFax::TProgress & aProgress)      

:iProgress (aProgress)

   {

   }

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

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

   {

   CFaxModem *self = new (ELeave) CFaxModem (aProgress);

   CleanupStack::PushL (self);

   self->ConstructL (aFaxServerSessionSettings);

   return self;

   }

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

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

   {

   CFaxModem *self = NewLC (aFaxServerSessionSettings, aProgress);

   CleanupStack::Pop ();

   return self;

   }

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

void CFaxModem::ConstructL (TFaxServerSessionSettings * aFaxServerSessionSettings)

   {

   TInt r;

//   TBufC < 24 > logname (_L ("C:\\SYSTEM\\FAXLOG.TXT"));

//   RFsBase closefile;

    __FLOG_FAXSRV( _L8("CFaxModem::ConstructL entering"));

   iVerbose = 1;

// we start off with our timer functions

   iStartTime.UniversalTime();

// work out the granularity of the clock

   TTimeIntervalMicroSeconds32 ourGranularity;

   if (UserHal::TickPeriod (ourGranularity) == KErrNotSupported)

      User::Leave (KErrNotSupported);

   iGranularity = ourGranularity.Int ();

// calibrate a 2 ms timing loop - see notes at start of cfaxTransfer::ExportL

// this is only used for class 1 when iTimingLoopDelay is true

   iCalls = 0;

   TInt t;

   t = clock () + iGranularity;

   while (t > clock ())

	   ;        // wait for the clock to tick once

   t = clock () + iGranularity; // reset target

   while (t > clock ())         // wait for it to tick again

      iCalls++;                 // this time counting calls to clock

   iCalls *= (CLK_TCK / iGranularity);  // work out calls per second

   iCalls /= 500;               // and work out calls per 2 ms

   if (iCalls == 0)

      iCalls++;

#if defined (__WINS__)

#define PDD_NAME _L("ECDRV")

#define LDD_NAME _L("ECOMM")

#else

#define PDD_NAME _L("EUART1")

#define LDD_NAME _L("ECOMM")

#endif

   r = iFileSession.Connect (); // we may need the RFs link for PDD/LDD loading as well as the log

   if (r)

      User::Leave (KFaxFileSessionError);

   iFileSessionOpen = ETrue;

   if (iVerbose)

      {

//This is a log file that would normally only be created in debug builds, however due to the time critical nature of fax it is always generated

//to avoid timing differences between debug and release builds.

//With the introduction of platform security it not advisable to have a log file in a public directory so will now be created in the private dir 

//of the fax server.

	//create log in private path of server

	TFileName logfile;

	TDriveUnit driveUnit(EDriveC);	

	TDriveName drive=driveUnit.Name();

	logfile.Insert(0, drive);	

	//append private path

	TPath privatePath;

	iFileSession.PrivatePath(privatePath);

	logfile.Append(privatePath);

	//append subdir & file name

	logfile.Append(_L("fax\\FAXLOG.TXT"));	

	//generate dir

	TInt kerr(iFileSession.MkDirAll(logfile)); //the directory may not exist, So create one.

	if(kerr != KErrAlreadyExists)

		{

		User::LeaveIfError(kerr);

		}

	r = iFile.Replace(iFileSession, logfile, EFileWrite | EFileShareAny);

	if (r)

		{

		User::Leave (KFaxLogCreateError);	

		}

	iFileOpen = ETrue;

      }

/*

   r = User::LoadPhysicalDevice (PDD_NAME);

   if ((r != KErrNone) && (r != KErrAlreadyExists))

     User::Leave (KFaxPDDError);

   r = User::LoadLogicalDevice (LDD_NAME);

   if ((r != KErrNone) && (r != KErrAlreadyExists))

      User::Leave (KFaxLDDError);  

*/

   RCommServ s;

   r = s.Connect ();

   if (r)

      User::Leave (KFaxCommsServerError);

   r = s.LoadCommModule (aFaxServerSessionSettings->iPortDriverName);

   if (r)

      User::Leave (KFaxCommsPortError);   

   r = iCommSession.Open (s, aFaxServerSessionSettings->iCommPortName, ECommShared);

   if (r)

      User::Leave (KFaxCannotOpenPort);  

   iPortOpen = ETrue;

   iCommSession.Config (iRS232Settings);

   iRS232Settings ().iRate = EBps19200;

   iRS232Settings ().iHandshake = 0;

   iRS232Settings ().iTerminator[0] = Ketx;

   iRS232Settings ().iTerminator[1] = Kxon;

   iRS232Settings ().iTerminator[2] = Klinefeed;

   iRS232Settings ().iTerminatorCount = 3;

   r = iCommSession.SetConfig (iRS232Settings);

   if (r)

      User::Leave (KFaxConfigError);

   iCommSession.SetSignals (KSignalDTR, 0);

   iCommSession.SetSignals (KSignalRTS, 0);

   iCommSession.SetReceiveBufferLength (KBufSize);

   iCommSession.ResetBuffers();

   iTransmitBuffer.Zero ();

   iSendone.Zero ();

   SendL (iSendone);            // activate port -  switch on DTR/RTS

   iSendone.SetMax ();          // we send single characters via iSendone[0]

   TBuf8 < 20 > thisclass;

   thisclass.SetMax ();

   iOurMessage.Format (_L8 (FaxTransVersionString));

   ProgressUpdateL ();

   iOurMessage.Format (_L8 ("The clock ticks at %d Hz"), CLK_TCK / iGranularity);

   ProgressUpdateL ();

   iOurMessage.Format (_L8 ("Calibration of 2 ms timer at %u calls"), iCalls);

   ProgressUpdateL ();

   Speed (EBps19200);

   iOurMessage.Format (_L8 ("Initialising at 19200 bps ...."));

   ProgressUpdateL ();

// added by JerryC from faxtrans cfaxmodm.cpp

	  Silence (CLK_TCK);

      TxcharL (Kreturn);

      Silence ();

//	  Silence ();

//	  Silence ();

	  //  GetMatchL(_L8("OK"),3);

//   while (iCommSession.QueryReceiveBuffer()!=0) GetMatch (_L8 ("OK"), 1);

//   ExportL (_L8 ("AT+FCLASS=?\r"));

//   GetMatchL (_L8 ("OK"), 3);

//   GetMatchL (_L8 ("OK"), 3);

   //r = CLK_TCK;

   //while (RxcharWaitL (r));

// the addition ends here

//   TxcharL (Kreturn);

   iModemSet = ETrue;

   iTimingLoopDelay = EFalse;

   //-- Switch modem into command mode and clear its buffer. 

   SetModemCommandModeL(); 

   if ((aFaxServerSessionSettings->iFaxClass) == (TFaxClass) EClassAuto)

      {

      ExportL (_L8 ("AT+FCLASS=?\r"));

      if(0 == ImportL (thisclass, 2))

    	  {

    	  User::Leave (KFaxErrWrongModemType);

    	  }

      iOurMessage.Format (_L8 ("%S"), &thisclass);

      ProgressUpdateL ();

      if ((thisclass.FindF (_L8 ("ERROR"))) >= 0)

         User::Leave (KFaxErrWrongModemType);

      GetMatchL (_L8 ("OK"), 1);

      if ((thisclass.FindF (_L8 ("2.0"))) >= 0)

         {

         aFaxServerSessionSettings->iFaxClass = EClass2point0;

         }

      else if ((thisclass.FindF (_L8 ("2.1"))) >= 0)

         {

         aFaxServerSessionSettings->iFaxClass = EClass2point0;

         }

      else if ((thisclass.FindF (_L8 ("2"))) >= 0)

         {

         aFaxServerSessionSettings->iFaxClass = EClass2;

         }

      else if ((thisclass.FindF (_L8 ("1"))) >= 0)

         {

         aFaxServerSessionSettings->iFaxClass = EClass1;

         }

      else if ((thisclass.FindF (_L8 ("1.0"))) >= 0)

         {

         aFaxServerSessionSettings->iFaxClass = EClass1;

         }

      else

         User::Leave (KFaxErrWrongModemType);

      User::Leave (KFaxOnlyJustAutoDetected);

      }

   thisclass.Copy (_L8 ("AT+FCLASS="));

   if (aFaxServerSessionSettings->iFaxClass == EClass2point0)

      {

      thisclass.Append (_L8 ("2.0\r"));

      }

   else if (aFaxServerSessionSettings->iFaxClass == EClass2)

      {

      thisclass.Append (_L8 ("2\r"));

      }

   else if (aFaxServerSessionSettings->iFaxClass == EClass1)

      {

      thisclass.Append (_L8 ("1\r"));

      iTimingLoopDelay = ETrue;

      }

   else

      User::Leave (KFaxErrWrongModemType);

   Silence ();

   ExportL (thisclass);

   if ((GetMatchL (_L8 ("OK"), 1)) == 0)		

      User::Leave (KFaxErrWrongModemType);

   //Speed (EBps19200);

   if (aFaxServerSessionSettings->iFaxInitString.Length ())

      {

      ExportL (aFaxServerSessionSettings->iFaxInitString);

      ExportL (_L8 ("\r"));

      //GetMatchL (_L8 ("OK"), 3);

      }

	else 

		{

		ExportL (_L8 ("AT\r"));

		}

   if ((GetMatchL (_L8 ("OK"), 3)) == 0)

      User::Leave (KFaxBadInitialization);

    __FLOG_FAXSRV( _L8("CFaxModem::ConstructL exiting"));

   }

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

CFaxModem::~CFaxModem ()

	{

//	iOurMessage.Format (_L8 ("Entering CFaxModem Destructor"));

//	ProgressUpdateL ();

    __FLOG_FAXSRV( _L8("CFaxModem::~CFaxModem"));

	iCancel = 2;

	if (iModemSet)

		{

		Xonoff ();

		Dropdtr ();

		TRAPD(ret, SetModemCommandModeL()); //-- Switch modem into command mode and clear its buffer. 

		TRAP (ret, HangupProcedureL());		//-- Issue hung up commands

		Silence ();

		}

	if (iPortOpen)

		{

		iCommSession.ResetBuffers ();

		iCommSession.Close ();

		}

	if (iFileOpen)

		{

		iFile.Close ();

		}

	if (iFileSessionOpen)

		iFileSession.Close ();

	}

/**

* Hang up. Senda 'ATH' command to the modem and sets Echo off, fax class = 0

*

* @note		This function can leave

*/

void CFaxModem::HangupProcedureL()

	{

	ExportL (_L8 ("ATH\r"));

	GetMatchL (_L8 ("OK"), 2);

	ExportL (_L8 ("ATE0+FCLASS=0\r"));  // Defect fix PBN-4ZLLX7, NM 23/07/01

	GetMatchL (_L8 ("OK"), 2);

	ExportL (_L8 ("\r"));

	}

/**

* Switch modem into command mode and clear its buffer. 

* LYN-585JMR defect fix. By Dmitry Lyokhin. 11.03.02

*

* @note		This function can leave

*/

void CFaxModem::SetModemCommandModeL(void)

{

	const TInt K_uS_ComWait=500000;			//-- used in cleaning up buffer. 0.5 sec timeout.

	ExportL (_L8("+++")); //-- switch the  modem to command mode

  	//-- clear modem's buffer by reading data

    while(iCommSession.QueryReceiveBuffer() > 0)

	 {

	  iCommSession.Read (iRecstat, K_uS_ComWait ,iReceiveBuffer);    // read data from the serial port

      User::WaitForRequest (iRecstat);

	 }

	Silence();

}

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

/*

TBool CFaxModem::CheckModemL (TFaxSettings * aFaxSettings)

   {

   TInt len = aFaxSettings->iDialStoreData.iModemInitString.Length ();

   for (TInt attempt = 0; attempt < 3; attempt++)

      {

      ExportL (_L8 ("ATH\r"));

      GetMatchL (_L8 ("OK"), 1);

      if (len)

         {

         ExportL (aFaxSettings->iDialStoreData.iModemInitString);

         ExportL (_L8 ("\r"));

         GetMatchL (_L8 ("OK"), 1);

         }

      iOurMessage.Format (_L8 ("ATE0X0Q0V1M%uL%uS0=0S8=%u\r"),

                          (TUint) aFaxSettings->iDialStoreData.iSpeaker,

                          (TUint) aFaxSettings->iDialStoreData.iSpeakerVolume,

                          aFaxSettings->iDialStoreData.iPauseTime);

      ExportL (iOurMessage);

      if (GetMatchL (_L8 ("OK"), 1) != 0)

         {

         Silence ();            // allow s-l-o-w modems to catch up with us

         return (ETrue);

         }

      }

   return (EFalse);

   }*/

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

/**

*

* @return	number of microseconds elapsed since calling CFaxModem::ConstructL().

*			

*/

TInt CFaxModem::clock ()

   {

   TTime now;

   now.UniversalTime ();

   TInt64 runningTime = now.MicroSecondsFrom (iStartTime).Int64 ();

   return I64LOW(runningTime);

   }

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

/**

*	Searches for a given substring in modem's answer.

*	also calls ProgressUpdate().

*

* @param	aMatstring	- sample string.

* @param	aMattime	- timeout in seconds.

*

* @see	ImportL function

*

* @return	0 -	given string (see param aMatstring) is found in modem answer.

*       	1 - sample not found or answer timeout.

*

* @leave	This function can leave

*/

TInt CFaxModem::GetMatchL (const TDesC8 & aMatstring, TInt aMattime)

   {

   TBuf8 < 64 > modemstring;

   TBuf8 < 64 > copymodemstring;

   modemstring.SetMax ();

   while (ImportL (modemstring, aMattime))

      {

      copymodemstring.Copy (modemstring);

      iOurMessage.Format (_L8 ("%S"), &copymodemstring);

      ProgressUpdateL ();

      if ((modemstring.FindF (aMatstring)) >= 0)

         return (1);

      }

   ProgressUpdateL ();

   return (0);

   }

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

/**

*	Gets textual answer from the modem.

*	Calls SubImportL() and ProgressUpdateL().

*

* @param	aLine	-	ref. to the string descriptor that will accept data from modem if any.

						will contain string in upper case without terminating 0x0d, 0x0a. 

* @param	aTimeout -	Timeout in seconds.

*

* @see	SubImport function

*

* @return	0 - if timeout occured or wrong input descriptor. Otherwise -

*				number of characters in string descriptor.

*

* @note		This function can leave

*/

TInt CFaxModem::ImportL (TDes8 & aLine, TInt aTimeout)

{

	const	TInt SubTimeout = 3; //-- modem response 3 seconds timeout 

	TInt	linestate		= 0;

	TInt	CurrTimeout;

   while( aTimeout > 0 )

   {

   	 if (aTimeout <= SubTimeout)	CurrTimeout = aTimeout;

	 else							CurrTimeout = SubTimeout;

     linestate = SubImportL (aLine, CurrTimeout);

		if (linestate) 

		{//-- a response from modem received

            __FLOG_FAXSRV2(_L8("mdm imp[%d]: %S"), aTimeout, &aLine);

			//-- look for '+CREG' or '+CGREG' answers from modem.

			//-- if found, ignore them and continue waiting.

			//-- these unwanted answers represent network registration status (unsolicited result code)

			//-- and interfere with fax modem responses. For more information see mm.tsy and gprs.tsy

			if ((aLine.FindF(_L8("REG"))) >= 0)

			{

				aLine.FillZ();

				aLine.Zero ();

			}

			else break; 

		}//if (linestate) 

		aTimeout -= SubTimeout;

		ProgressUpdateL ();

    }// while