--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/fax/faxclientandserver/FAXCLI/FAXCLI.CPP Wed Sep 01 12:40:21 2010 +0100
@@ -0,0 +1,1338 @@
+// 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 "CFAX32.H"
+#include "dial.h" // we no longer depend on DialStor, so must depend directly on Dial
+
+#include "FAXLOG.H"
+#include "faxsettings.h"
+
+ #include <commsdattypesv1_1.h>
+ #include <commsdatutils.h>
+ #include <commsdat_partner.h>
+
+ using namespace CommsDat;
+
+TInt FaxClientThread (TAny * session); // function declaration needed here
+//TInt FaxConverterThread (TAny *);
+//RSemaphore jerry;
+/********************************************************************/
+
+
+/********************************************************************/
+
+CFaxTransfer::CFaxTransfer()
+ : CBase()
+ {}
+
+EXPORT_C CFaxTransfer *CFaxTransfer::NewLC (const TFaxSettings & aFaxSettings)
+/** Constructs a CFaxTransfer object, which offers the publicly exported
+Symbian OS Fax Client API.
+As is usual in Symbian OS, the only difference between this function and
+NewL() is that this variant pushes the object to the cleanup stack.
+
+@param aFaxSettings A reference to a TFaxSettings object which contains
+persistent information applicable to all fax sessions.
+@return Pointer to the newly created object.
+@leave KErrNoMemory There is insufficient memory to perform the operation.
+@capability None
+*/
+ {
+ CFaxTransfer *self = new (ELeave) CFaxTransfer;
+ CleanupStack::PushL (self);
+ self->ConstructL (aFaxSettings);
+ return self;
+ }
+
+EXPORT_C CFaxTransfer *CFaxTransfer::NewL (const TFaxSettings & aFaxSettings)
+/** Constructs a CFaxTransfer object, which offers the publicly exported
+Symbian OS Fax Client API.
+
+@param aFaxSettings A reference to a TFaxSettings object, which
+contains persistent information applicable to all fax sessions.
+@return A pointer to the newly created object.
+@leave KErrNoMemory There is insufficient memory to perform the operation.
+@capability None
+*/
+ {
+ CFaxTransfer *self = NewLC (aFaxSettings);
+ CleanupStack::Pop ();
+ return self;
+ }
+/********************************************************************/
+
+void CFaxTransfer::ConstructL (const TFaxSettings & aFaxSettings)
+ {
+ // we now copy the TFaxSettings passed to us - we then
+ // validate the contents and fill in the DialStor bits.
+ // if we don't know the modem class we find it our here
+ iFaxSettings = aFaxSettings;
+ CFaxSettings *currentsettings;
+ currentsettings = CFaxSettings::NewL (); // bug fix thanks to MartinA
+ CleanupStack::PushL (currentsettings); // currentsettings saved
+ currentsettings->ValidateAndSetClassL (&iFaxSettings); // since this could leave
+ CleanupStack::PopAndDestroy (); // currentsettings deleted
+
+ // if (((TFaxClass) iFaxSettings.iFaxClass != EClass1) &&
+ // ((TFaxClass) iFaxSettings.iFaxClass != EClass2) &&
+ // ((TFaxClass) iFaxSettings.iFaxClass != EClass2point0))
+ // User::Leave (KFaxCannotAutodetect);
+
+ iFaxSessionSettings.iFaxClass = (TFaxClass) iFaxSettings.iFaxClass;
+ iFaxSessionSettings.iFaxId.Copy (iFaxSettings.iFaxId);
+ iFaxSessionSettings.iMaxSpeed = iFaxSettings.iMaxSpeed;
+ iFaxSessionSettings.iMinSpeed = iFaxSettings.iMinSpeed;
+ iFaxSessionSettings.iRxResolution = iFaxSettings.iPreferredResolution;
+ iFaxSessionSettings.iRxCompression = iFaxSettings.iPreferredCompression;
+ iFaxSessionSettings.iPreferredECM = iFaxSettings.iPreferredECM;
+ iFaxSessionSettings.iFaxOnDemandDelay = iFaxSettings.iFaxOnDemandDelay;
+
+ iSource = CFaxTransferSource::NewL ();
+ }
+/********************************************************************/
+
+CFaxTransfer::~CFaxTransfer ()
+/** Destructor
+
+Frees all resources owned by the object, prior to its destruction. */
+ {
+ delete iSource;
+ }
+/********************************************************************/
+
+// this function updates the TFaxTransferProgress structure for the
+// caller. It should be prior to inspection.
+
+EXPORT_C TInt CFaxTransfer::Progress ()
+/** Causes ETel to update the fax progress information in RFax::TProgress.
+
+It should be called prior to displaying the fax progress information.
+
+@return KErrNone if successful, otherwise another of the system-wide error
+codes.
+@capability None
+*/
+{
+ if (iFaxStarted)
+ {
+ iFaxClientProgress=EProgressRxTx;
+ return (iFax.GetProgress (iProgress));
+ }
+ if (iConverting)
+ {
+ iFaxClientProgress=EProgressConverting;
+ //aProgress=EProgressPreparing;
+ return (KErrNone);
+ }
+
+ //aProgress=EProgressInitialising;
+ return (KErrNone);
+}
+/********************************************************************/
+
+// this function tells faxtrans what phone number to dial
+// obviously only useful in a dialling mode !
+// the phone number is translated for the modem and service
+// and location required using dialstor facilities if they are
+// available - if not, the number is used in its raw state
+//
+// if use of a raw phonenumber is required then the inline function
+// SetPhoneNumber should be called instead.
+
+EXPORT_C void CFaxTransfer::SetPhoneNumberL (TDesC8 & aNumber)
+/** Resolves a local telephone number into an international number by
+taking account of the current location and country.
+The alternative SetPhoneNumber() should be used if the phone number
+must be used in its raw state. One of these functions must be called
+before CFaxTransfer::Start() when a fax is to be sent.
+This function may leave with KErrNoMemory if there is insufficient
+memory to perform the operation. The leave code is one of the system
+error codes: see system-wide error codes.
+The current location and country information is obtained from the
+location table in the communications database.
+The resolved number is then set as the actual phone number to dial.
+
+@param aNumber Descriptor containing the phone number to be resolved.
+@capability WriteUserData
+*/
+ {
+ SetPhoneNumber (aNumber);
+ TBuf < KMaxDialString > rawPhoneNumber;
+ rawPhoneNumber.Copy (aNumber);
+
+#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY
+ CMDBSession* db = CMDBSession::NewL(KCDVersion1_2);
+#else
+ CMDBSession* db = CMDBSession::NewL(KCDVersion1_1);
+#endif
+ CleanupStack::PushL(db);
+
+ // Read the currently selected connection preference and find preferred IAP
+ TInt prefRank = 1;
+
+ CCDConnectionPrefsRecord *connectionPrefs =
+ static_cast<CCDConnectionPrefsRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdConnectionPrefsRecord));
+ CleanupStack::PushL(connectionPrefs);
+ connectionPrefs->iRanking = prefRank;
+ connectionPrefs->iDirection = ECommDbConnectionDirectionOutgoing;
+ TBool error = connectionPrefs->FindL(*db);
+
+ // The following code is a temporary solution until an issue has been resolved in CommsDat
+ // start
+ CCDIAPRecord* tempPIapRecord =
+ static_cast<CCDIAPRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdIAPRecord));
+ tempPIapRecord->SetRecordId(connectionPrefs->iDefaultIAP);
+ connectionPrefs->iDefaultIAP.iLinkedRecord = tempPIapRecord;
+
+ CCDIAPRecord* pIapRecord = (CCDIAPRecord*)connectionPrefs->iDefaultIAP.iLinkedRecord;
+ pIapRecord->SetRecordId(connectionPrefs->iDefaultIAP);
+ pIapRecord->LoadL(*db);
+
+ CCDBearerRecordBase* tempBearerRecord =
+ static_cast<CCDBearerRecordBase*>(CCDRecordBase::RecordFactoryL(KCDTIdModemBearerRecord));
+ tempBearerRecord->SetRecordId(pIapRecord->iBearer);
+ pIapRecord->iBearer.iLinkedRecord = tempBearerRecord;
+
+ CCDBearerRecordBase* pBearerRecord = (CCDBearerRecordBase*) pIapRecord->iBearer.iLinkedRecord;
+ pBearerRecord->SetRecordId(pIapRecord->iBearer);
+ pBearerRecord->LoadL(*db);
+ // end
+
+ TUint32 iapId = pBearerRecord->iRecordTag;
+
+ CCDIAPRecord *iapRecord =
+ static_cast<CCDIAPRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdIAPRecord));
+ CleanupStack::PushL(iapRecord);
+ iapRecord->SetRecordId(iapId);
+ iapRecord->LoadL(*db);
+
+ // more temporary code
+ // start
+ CCDBearerRecordBase* tempLocationRecord =
+ static_cast<CCDBearerRecordBase*>(CCDRecordBase::RecordFactoryL(KCDTIdLocationRecord));
+ tempLocationRecord->SetRecordId(iapRecord->iLocation);
+ iapRecord->iLocation.iLinkedRecord = tempLocationRecord;
+
+ CCDLocationRecord* pLocationRecord = (CCDLocationRecord*)iapRecord->iLocation.iLinkedRecord;
+ pLocationRecord->SetRecordId(iapRecord->iLocation);
+ pLocationRecord->LoadL(*db);
+ // end
+
+ //CommsDat Migration: Would this be the correct way to check whether or not a linked record exists:
+ if (pLocationRecord == NULL)
+ {
+ iPhoneNumber.Copy(rawPhoneNumber);
+ }
+ else
+ {
+ TBuf<32> serviceType;
+ serviceType.Copy(iapRecord->iServiceType);
+
+ if (!serviceType.Compare(TBuf<32>(DIAL_OUT_ISP))) // Chargecard only valid for dial out ISP
+ {
+ // Get service type id
+ TUint32 serviceId = iapRecord->iService;
+
+ CCDDialOutISPRecord *ispRecord =
+ static_cast<CCDDialOutISPRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdDialOutISPRecord));
+ CleanupStack::PushL(ispRecord);
+ ispRecord->SetRecordId(serviceId);
+ ispRecord->LoadL(*db);
+ TUint32 locationId = 0;
+ TUint32 chargecardId = 0;
+ TRAPD(err,CommsDatUtils::CCommsDatUtils::ResolvePhoneNumberL(rawPhoneNumber, iPhoneNumber, TParseMode(EForDialing), locationId, chargecardId));
+ // if resolving the phone number fails, use the raw phone number
+ if (err)
+ {
+ iPhoneNumber.Copy(rawPhoneNumber);
+ }
+
+ CleanupStack::PopAndDestroy(ispRecord);
+ }
+ else
+ {
+ iPhoneNumber.Copy(rawPhoneNumber);
+ }
+ }
+ CleanupStack::PopAndDestroy(3); // db, connectionPrefs, iapRecord
+ }
+/********************************************************************/
+
+// in order to cancel a fax session we set a cancel flag in the lowest
+// level (CFaxModem) - if this has not yet been fully created then we set
+// a flag in the next level up (CFaxModemDriver) instead, which is always
+// going to be there as it is created via CFaxTransfer::ConstructL
+//
+// because of the way that the CFaxModem monitors its request flag
+// we need to avoid multiple cancel requests, so only the first call to
+// Cancel has any effect on it
+
+EXPORT_C void CFaxTransfer::Cancel ()
+/** Tells the fax engine to cancel the fax session at the first convenient
+opportunity.
+
+The caller should wait for cancellation to complete, which will usually be
+signalled by the fax thread's TRequestStatus completing with a KFaxCancelRequested
+error code. After the fax thread completes, Stop() should be called in the
+normal way.
+
+The function can be called at any time after the call to Start().
+@capability None
+*/
+ {
+ if ((iClientCancel == KRequestPending) || (iClientCancel == KErrNone))
+ {
+ TRequestStatus *cancelClient = &iClientCancel;
+ iDriverThread.RequestComplete (cancelClient, KErrCancel);
+ }
+ }
+/********************************************************************/
+
+EXPORT_C TInt CFaxTransfer::Start (TRequestStatus & aThreadStat)
+/**
+Start fax sending or receiving session by launching a separate high priority thread.
+A call to Start must be paired with a call to Stop as this is an EPOC32 requirement.
+
+@param aThreadStat thread logon request status
+@return thread creation code
+@capability NetworkServices
+@capability ReadUserData
+@capability WriteUserData
+*/
+ {
+ // the heap and stack sizes set here (4K each) are pure guesswork
+ // CFaxModemDriver has allocated heap space in the parent thread
+ // for any objects it needs to create after this stage
+ // stack sizes increased by 512K to allow etel to connect
+
+ TInt state = KErrNone;
+ TInt heapSize = 0x14000;
+ TInt stackSize = 0x14000;
+
+ __FLOG_FAXCLI(_L8(" "));
+ __FLOG_FAXCLI(_L8("-------------------------- new log --------------------------"));
+ __FLOG_FAXCLI(_L8("CFaxTransfer::Start, starting FaxClientThread"));
+ __FLOG_FAXCLI(_L8(" "));
+
+ state = iDriverThread.Create ((_L ("FaxClientThread")), FaxClientThread, stackSize, heapSize, heapSize, this, EOwnerThread);
+ if (state)
+ {
+ state = KFaxThreadError;
+ }
+ else
+ {
+ aThreadStat = KRequestPending;
+ if (iClientCancel != KErrCancel)
+ iClientCancel = KRequestPending;
+ iDriverThread.Logon (aThreadStat);
+ iDriverThread.SetPriority (EPriorityRealTime);
+ iDriverThread.Resume ();
+ }
+ return (state);
+ }
+/*********************************************************************/
+
+EXPORT_C void CFaxTransfer::Stop ()
+/** Kills the fax thread once it has completed.
+
+Fax threads do not kill themselves, so every successful call to CFaxTransfer::Start()
+must be paired with a call to CFaxTransfer::Stop().
+@capability NetworkServices
+@capability ReadUserData
+@capability WriteUserData
+*/
+ {
+ iDriverThread.Close ();
+ }
+/*********************************************************************/
+
+// this is a utility function which is the entry to our thread
+// it isn't part of any class, but we pass the address
+// of our CFaxTransfer in so that we can check the
+// session parameter and get back to the required function
+//
+// All possible leaves should be trapped as the return
+// from this function is the TRequestStatus which the
+// caller to CFaxTransfer::Start is waiting for.
+
+TInt FaxClientThread (TAny * session)
+ {
+
+
+ // start of unecessary bureaucracy - error checking left out
+/*#define CSY_NAME _L("ECUART")
+#define LDD_NAME _L("ECOMM")
+#if defined (__WINS__)
+#define PDD_NAME _L("ECDRV")
+#else
+#define PDD_NAME _L("EUART1")
+#endif*/
+
+/*
+ User::LoadPhysicalDevice (PDD_NAME);
+ User::LoadLogicalDevice (LDD_NAME);*/
+// jerry.CreateGlobal(_L("FaxCliSem"),0,EOwnerProcess);
+
+ RCommServ server;
+ // coverity[check_return]
+ server.Connect ();
+// end of unecessary bureaucracy
+
+ TInt state;
+ CTrapCleanup *cleanup = CTrapCleanup::New ();
+// CFaxTransfer *faxsession = (CFaxTransfer *) session;
+ CFaxTransfer *faxsession =reinterpret_cast<CFaxTransfer *>(session);
+ __FLOG_FAXCLI(_L8("FaxClientThread entering..."));
+
+ state = faxsession->iTelServer.Connect ();
+ if (state == KErrNone)
+ {
+ TBuf<KCommsDbSvrMaxFieldLength> tsyName;
+ TRAP(state,faxsession->GetPhoneModuleNameL(tsyName));
+ if (state==KErrNone)
+ {
+ state = faxsession->iTelServer.LoadPhoneModule (tsyName);
+ if (state == KErrNone)
+ {
+ RTelServer::TPhoneInfo phoneInfo;
+ state = faxsession->GetPhoneInfoForTsy(tsyName,phoneInfo);
+ if (state == KErrNone)
+ {
+
+ __FLOG_FAXCLI(_L8("FaxClientThread iPhone.Open"));
+ state = faxsession->iPhone.Open (faxsession->iTelServer, phoneInfo.iName);
+ if (state == KErrNone)
+ {
+
+ __FLOG_FAXCLI(_L8("FaxClientThread iLine.Open"));
+ state = faxsession->iLine.Open (faxsession->iPhone, _L ("Fax"));
+ if (state == KErrNone)
+ {
+ //
+ // If the call name has been provided, then open the
+ // existing call, otherwise open a new call.
+ //
+ if (faxsession->iCallName.Length() == 0)
+ {
+ __FLOG_FAXCLI(_L8("FaxClientThread iCall.OpenNewCall"));
+ state = faxsession->iCall.OpenNewCall (faxsession->iLine);
+ }
+ else
+ {
+ __FLOG_FAXCLI(_L8("FaxClientThread iCall.OpenExistingCall"));
+ state = faxsession->iCall.OpenExistingCall(faxsession->iLine, faxsession->iCallName);
+ }
+
+ if (state == KErrNone)
+ {
+ faxsession->iSource->iPage = 0;
+ if (faxsession->iMode & KFaxReceive)
+ {
+ faxsession->iFaxSessionSettings.iMode = RCall::EReceive;
+ TRAP (state, faxsession->FaxReceiveL ());
+
+ __FLOG_FAXCLI1(_L8("FaxClientThread FaxReceiveL exited state=%d"),state);
+
+ faxsession->iSource->CloseFaxInStore ();
+ }
+ else
+ {
+ faxsession->iFaxSessionSettings.iMode = RCall::ETransmit;
+ TRAP (state, faxsession->FaxTransmitL ());
+ faxsession->iSource->iInstream.Close ();
+ }
+
+ // we tidy up by deleting any objects created
+ // (it does no harm if their pointers are already NULL)
+ // and we close any streams (which also does no harm
+ // if they have already been closed)
+
+ faxsession->iFaxStarted = EFalse;
+ faxsession->iFax.Close ();
+ faxsession->iSource->CloseFaxStore ();
+ delete faxsession->iSource->iWriteFaxFile;
+ faxsession->iSource->iWriteFaxFile = NULL;
+ delete faxsession->iSource->iReadFaxFile;
+ faxsession->iSource->iReadFaxFile = NULL;
+
+ faxsession->iSource->iOutstream.Close ();
+ faxsession->iSource->iInstream.Close ();
+
+ RCall::TStatus callStatus;
+ faxsession->iCall.GetStatus(callStatus);
+
+ __FLOG_FAXCLI1(_L8("FaxClientThread callStatus=%d"),callStatus);
+
+ if (callStatus!=RCall::EStatusIdle)
+ faxsession->iCall.HangUp ();
+
+ __FLOG_FAXCLI(_L8("FaxClientThread iCall.Close"));
+ faxsession->iCall.Close ();
+ }
+
+ __FLOG_FAXCLI(_L8("FaxClientThread iLine.Close"));
+ faxsession->iLine.Close ();
+ }
+
+ __FLOG_FAXCLI(_L8("FaxClientThread iPhone.Close"));
+ faxsession->iPhone.Close ();
+ }
+ }
+ faxsession->iTelServer.UnloadPhoneModule (tsyName);
+ }
+ }
+ faxsession->iTelServer.Close ();
+ }
+
+ delete cleanup;
+
+// intercept the etel wrong modem type error
+ if (state == KErrEtelWrongModemType) state = KFaxErrWrongModemType;
+
+ return (state);
+ }
+
+/*********************************************************************/
+
+void CFaxTransfer::GetPhoneModuleNameL(TDes& aModuleName) const
+ {
+ // AnnW, 9/8/99 - This all assumes that we are taking the modem settings from the
+ // dial out IAP, which is fince for now, but may not be in the future? This may also
+ // need modifying for Linda?
+
+ CMDBSession* db = CMDBSession::NewL(KCDVersion1_1);
+ CleanupStack::PushL(db);
+
+ // Read the currently selected connection preference and find preferred IAP
+ TInt prefRank = 1;
+
+ CCDConnectionPrefsRecord *connectionPrefs =
+ static_cast<CCDConnectionPrefsRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdConnectionPrefsRecord));
+ CleanupStack::PushL(connectionPrefs);
+ connectionPrefs->iRanking = prefRank;
+ connectionPrefs->iDirection = ECommDbConnectionDirectionOutgoing;
+ connectionPrefs->FindL(*db);
+
+ // The following code is a temporary solution until an issue has been resolved in CommsDat
+ // start
+ CCDIAPRecord* tempPIapRecord =
+ static_cast<CCDIAPRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdIAPRecord));
+ tempPIapRecord->SetRecordId(connectionPrefs->iDefaultIAP);
+ connectionPrefs->iDefaultIAP.iLinkedRecord = tempPIapRecord;
+
+ CCDIAPRecord* pIapRecord = (CCDIAPRecord*)connectionPrefs->iDefaultIAP.iLinkedRecord;
+ pIapRecord->SetRecordId(connectionPrefs->iDefaultIAP);
+ pIapRecord->LoadL(*db);
+
+ CCDBearerRecordBase* tempBearerRecord =
+ static_cast<CCDBearerRecordBase*>(CCDRecordBase::RecordFactoryL(KCDTIdModemBearerRecord));
+ tempBearerRecord->SetRecordId(pIapRecord->iBearer);
+ pIapRecord->iBearer.iLinkedRecord = tempBearerRecord;
+
+ CCDBearerRecordBase* pBearerRecord = (CCDBearerRecordBase*) pIapRecord->iBearer.iLinkedRecord;
+ pBearerRecord->SetRecordId(pIapRecord->iBearer);
+ pBearerRecord->LoadL(*db);
+ // end
+
+ TUint32 iapId = pBearerRecord->iRecordTag;
+
+ CMDBField<TUint32>* bearerField = new(ELeave) CMDBField<TUint32>(KCDTIdIAPBearer);
+ CleanupStack::PushL(bearerField);
+ bearerField->SetRecordId(iapId);
+ bearerField->LoadL(*db);
+ TUint32 modemId = *bearerField;
+ CleanupStack::PopAndDestroy(bearerField);
+
+ CMDBField<TDesC>* tsyField = new(ELeave) CMDBField<TDesC>(KCDTIdTsyName);
+ CleanupStack::PushL(tsyField);
+ tsyField->SetRecordId(modemId);
+ tsyField->SetMaxLengthL(KMaxTextLength);
+ tsyField->LoadL(*db);
+ aModuleName = *tsyField;
+ CleanupStack::PopAndDestroy(tsyField);
+
+ CleanupStack::PopAndDestroy(2); // db, connectionPrefs
+ }
+
+void CFaxTransfer::CancelFaxServerSession ()
+ {
+ if (iMode & KFaxWaitForRing)
+ iCall.AnswerIncomingCallCancel ();
+ else
+ {
+ if (iMode & KFaxOffHook)
+ iCall.ConnectCancel ();
+ else
+ iCall.DialCancel ();
+ }
+ }
+/*********************************************************************/
+// receiving a fax is easy because it is passive
+// just open the file for receiving and off we go
+
+void CFaxTransfer::FaxReceiveL ()
+ {
+
+ __FLOG_FAXCLI(_L8("CFaxTransfer::FaxReceiveL entering"));
+
+ if (iMode & KFaxPoll)
+ iFaxSessionSettings.iFaxRetrieveType = RCall::EFaxPoll;
+ else
+ iFaxSessionSettings.iFaxRetrieveType = RCall::EFaxOnDemand;
+
+ iSource->OpenFaxInL (iReceiveFileName);
+
+ SetFaxSettingsL();
+
+ if (iMode & KFaxWaitForRing)
+ {//-- answering incoming call if fax is waiting for a call
+ iCall.AnswerIncomingCall (iTransferStatus);
+ if (iClientCancel != KRequestPending)
+ {//-- cancel request, leave
+ iCall.AnswerIncomingCallCancel ();
+ User::WaitForRequest(iTransferStatus);
+ User::Leave (KFaxCancelRequested);
+ }
+ }
+ else //if (iMode & KFaxWaitForRing)
+ {//-- if fax is not waiting for a call, dial
+ if (iMode & KFaxOffHook)
+ iCall.Connect (iTransferStatus);
+ else
+ {
+ if (iPhoneNumber.Length() == 0)
+ User::Leave (KErrCouldNotConnect);
+ iCall.Dial (iTransferStatus, iPhoneNumber);
+ }
+ }
+
+ TRequestStatus reqStatus;
+ RCall::TStatus callStatus;
+ iCall.NotifyStatusChange (reqStatus, callStatus);
+
+ for (;;)
+ {
+ User::WaitForAnyRequest ();
+ if (reqStatus != KRequestPending)
+ {
+ //-- Call status changed
+ if (reqStatus.Int () != KErrNone)
+ {
+ CancelFaxServerSession ();
+ User::Leave (reqStatus.Int ());
+ }
+ if (iMode & KFaxWaitForRing)
+ {//-- Fax is waiting for a ring
+ if (callStatus == RCall::EStatusRinging)
+ {//-- Call status is 'Ringing', continue waiting
+ iCall.NotifyStatusChange(reqStatus, callStatus);
+ reqStatus = KRequestPending;
+ continue;
+ }
+ else
+ //-- due to PIA-586KGE fix (changes in CATAnswerFax::Start()) 'Connecting' may be not noticed here
+ //-- so EStatusConnected state is ok
+ if (callStatus != RCall::EStatusAnswering && callStatus != RCall::EStatusConnected )
+ {
+ iCall.AnswerIncomingCallCancel ();
+ User::Leave (KFaxEtelServerError);
+ } //if (callStatus != RCall::EStatusAnswering)
+ } //if (iMode & KFaxWaitForRing)
+ else
+ {//-- Fax is not waiting for a ring
+ if (iMode & KFaxOffHook)
+ {
+ if (callStatus != RCall::EStatusConnecting)
+ {
+ iCall.ConnectCancel ();
+ User::Leave (KFaxEtelServerError);
+ }
+ }
+ else if (callStatus != RCall::EStatusDialling)
+ {
+ iCall.DialCancel ();
+ User::Leave (KFaxEtelServerError);
+ }
+ }
+ TInt ret = iFax.Open (iCall);
+ if (ret != KErrNone)
+ {
+ CancelFaxServerSession ();
+ User::Leave (ret);
+ }
+ iFaxStarted = ETrue;
+ reqStatus = KRequestPending;
+ }//if (reqStatus != KRequestPending)
+ else if (iClientCancel != KRequestPending)
+ {//-- Fax cancel request
+ if (iFaxStarted == EFalse)
+ iCall.NotifyStatusChangeCancel ();
+ CancelFaxServerSession ();
+ User::Leave (KFaxCancelRequested);
+ }
+ else if (iTransferStatus != KRequestPending)
+ {//--iCall.AnswerIncomingCall status changed
+ if (iFaxStarted == EFalse)
+ iCall.NotifyStatusChangeCancel ();
+ User::LeaveIfError (iTransferStatus.Int ());
+ break;
+ }
+ else
+ {
+ if (iFaxStarted == EFalse)
+ iCall.NotifyStatusChangeCancel ();
+ CancelFaxServerSession ();
+ User::Leave (KErrCompletion); // stray event handle
+ }
+ }
+
+ //-- Data transfer phase
+ User::LeaveIfError (iFax.GetProgress (iProgress));
+ while (iProgress.iPhase == EDataTransfer)
+ {
+ iSource->iResolu = iProgress.iResolution;
+ iSource->iCompression = iProgress.iCompression;
+ for (;;)
+ {
+ iFax.Read (iTransferStatus, iDataBuf);
+ User::WaitForRequest (iTransferStatus, iClientCancel);
+ if (iClientCancel != KRequestPending)
+ {
+ iFax.TerminateFaxSession ();
+ User::Leave (KFaxCancelRequested);
+ }
+ User::LeaveIfError (iTransferStatus.Int ());
+
+ // the server has buffered up lines to minimize interaction
+ // iDataBuf 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
+
+ TUint8 *nextLine = CONST_CAST (TUint8 *, iDataBuf.Ptr ());
+ TInt lengthOfLine=0;
+ TInt numberOfLines;
+
+ Mem::Copy (&numberOfLines, nextLine, sizeof (TInt));
+ nextLine += sizeof (TInt);
+
+ while (numberOfLines--)
+ {
+ Mem::Copy (&lengthOfLine, nextLine, sizeof (TInt));
+ if (lengthOfLine == 0)
+ break;
+ nextLine += sizeof (TInt);
+ TPtrC8 currentLine (nextLine, lengthOfLine);
+ iSource->WriteFaxDataL (currentLine);
+ nextLine += lengthOfLine;
+ }
+ if (lengthOfLine == 0)
+ break;
+ }
+ iSource->WritePageParmsL (iProgress.iAnswerback);
+ iFax.WaitForEndOfPage (iTransferStatus);
+ User::WaitForRequest (iTransferStatus, iClientCancel);
+ if (iClientCancel != KRequestPending)
+ {
+ iFax.TerminateFaxSession ();
+ User::Leave (KFaxCancelRequested);
+ }
+ User::LeaveIfError (iTransferStatus.Int ());
+ User::LeaveIfError (iFax.GetProgress (iProgress));
+
+ }
+// iSource->CloseFaxInStore ();
+ if (iProgress.iCompression==EModifiedRead)
+ Convert1dL ();
+ }
+/*********************************************************************/
+
+// sending a fax is rather more complex
+//
+// we need a valid phone number (we don't do polling)
+//
+// we need a valid list of pages to send
+//
+// we need to set the resolution we require to that of the
+// fax we want to send (use the last page)
+//
+
+void CFaxTransfer::FaxTransmitL ()
+ {
+
+
+ __FLOG_FAXCLI(_L8("CFaxTransfer::FaxTransmitL entering"));
+
+ TBool ConversionStatus=FALSE;
+ //TInt err=0;
+ if (iSource->iOurPreferredCompression==Prefer2D)
+ {
+ TRAPD (retcode,Convert2dL());
+ if (retcode==KErrNone)
+ ConversionStatus=TRUE;
+ else
+ {
+ ConversionStatus=FALSE;
+ iSource->iOurPreferredCompression=Prefer1D; // if anything goes wrong during conversion
+ } // try the 1D version.
+ }
+ if ((iSource->iFaxPages == 0) || (iSource->iFaxListEntries == 0))
+ User::Leave (KErrNotFound);
+ iSource->iSavedFaxListEntries = iSource->iFaxListEntries;
+ iSource->iOurFaxEntry.iPageCount = 0;
+ iSource->iInstream.Open (*iSource->iSources);
+ iSource->GetNextPageReadyL ();
+
+ if (iSource->iOurPreferredCompression==Prefer1D)
+ iFaxSessionSettings.iTxPages=iSource->iFaxPages;
+
+ // we pass in to the server the resolution of the last added source page
+
+ iFaxSessionSettings.iTxResolution = (TFaxResolution) iSource->iResolu;
+ if ((iSource->iOurPreferredCompression==Prefer2D) && ConversionStatus==TRUE)
+ iFaxSessionSettings.iTxCompression = (TFaxCompression) EModifiedRead;
+ else
+ iFaxSessionSettings.iTxCompression = (TFaxCompression) iSource->iCompression;
+
+ SetFaxSettingsL(); // pass the settings to the Fax Server
+ SetSharedFileHandlesL();
+
+ if (iMode & KFaxOffHook)
+ iCall.Connect (iTransferStatus);
+ else
+ {
+ if (iPhoneNumber.Length() == 0)
+ User::Leave (KErrCouldNotConnect);
+ iCall.Dial (iTransferStatus, iPhoneNumber);
+ }
+
+ TRequestStatus reqStatus;
+ RCall::TStatus callStatus;
+ iCall.NotifyStatusChange (reqStatus, callStatus);
+
+ for (;;)
+ {
+ User::WaitForAnyRequest ();
+ if (reqStatus != KRequestPending)
+ {
+ if (reqStatus.Int () != KErrNone)
+ // initialisation and comm port errors
+ {
+ CancelFaxServerSession ();
+ User::Leave (reqStatus.Int ());
+ }
+ if (iMode & KFaxOffHook)
+ {
+ if (callStatus != RCall::EStatusConnecting)
+ {
+ iCall.ConnectCancel ();
+ User::Leave (KFaxEtelServerError);
+ }
+ }
+ else if (callStatus != RCall::EStatusDialling)
+ {
+ iCall.DialCancel ();
+ User::Leave (KFaxEtelServerError);
+ }
+ TInt ret = iFax.Open (iCall);
+ if (ret != KErrNone)
+ {
+ CancelFaxServerSession ();
+ User::Leave (ret);
+ }
+ iFaxStarted = ETrue;
+ reqStatus = KRequestPending; // to prevent first scenario being
+ // chosen each time any request comes in
+ }
+ else if (iClientCancel != KRequestPending)
+ {
+ if (iFaxStarted == EFalse)
+ iCall.NotifyStatusChangeCancel ();
+ CancelFaxServerSession ();
+ User::Leave (KFaxCancelRequested);
+ }
+ else if (iTransferStatus != KRequestPending)
+ {
+ if (iFaxStarted == EFalse)
+ iCall.NotifyStatusChangeCancel ();
+ User::LeaveIfError (iTransferStatus.Int ());
+ break;
+ }
+ else
+ {
+ if (iFaxStarted == EFalse)
+ iCall.NotifyStatusChangeCancel ();
+ CancelFaxServerSession ();
+ User::Leave (KErrCompletion); // stray event handle
+ }
+ }
+
+ for (;;)
+ {
+ User::LeaveIfError (iFax.GetProgress (iProgress));
+ TInt thispage = iProgress.iPage;
+ TInt thisline = 1;
+ ASSERT (iSource->iLines);
+
+ if ((iProgress.iCompression) && (iSource->iSavedFaxListEntries>=1))
+ {
+ while (iSource->iCompression == EModifiedHuffman) // loop until we
+ iSource->GetNextPageReadyL (); // find the 2D document
+ }
+
+ //we buffer up lines to minimize client-server interaction
+ //iDataBuf 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
+
+ TUint8 *startData;
+ TUint8 *lineData;
+ TInt numberOfLines;
+ const TUint8 *maxData;
+
+ TUint8 *currentLineData;
+ TInt currentLineLength;
+
+ for (;;)
+ {
+ lineData = startData = CONST_CAST (TUint8 *, iDataBuf.Ptr ());
+ maxData = startData + iDataBuf.MaxLength () - KMaxT4Des - sizeof (TInt);
+
+ iDataBuf.SetMax ();
+ numberOfLines = 0;
+ lineData += sizeof (TInt);
+ for (;;)
+ {
+ if (thisline > iSource->iLines)
+ break;
+ thisline++;
+ numberOfLines++;
+ currentLineData = lineData + sizeof (TInt);
+ *currentLineData = 0x0;
+ TPtr8 currentLine (currentLineData + 1, 0, KMaxT4Des - 1);
+ iSource->ReadFaxData (currentLine);
+ currentLineLength = currentLine.Length () + 1;
+ Mem::Copy (lineData, ¤tLineLength, sizeof (TInt));
+ lineData += sizeof (TInt);
+ lineData += currentLineLength;
+ if (lineData > maxData)
+ break;
+ }
+ Mem::Copy (startData, &numberOfLines, sizeof (TInt));
+ iDataBuf.SetLength (lineData - startData);
+ iFax.Write (iTransferStatus, iDataBuf);
+ User::WaitForRequest (iTransferStatus, iClientCancel);
+ if (iClientCancel != KRequestPending)
+ {
+ iFax.TerminateFaxSession ();
+ User::Leave (KFaxCancelRequested);
+ }
+ User::LeaveIfError (iTransferStatus.Int ());
+ if (thisline > iSource->iLines)
+ break;
+ }
+ iDataBuf.Zero ();
+ iFax.WaitForEndOfPage (iTransferStatus);
+ User::WaitForRequest (iTransferStatus, iClientCancel);
+ if (iClientCancel != KRequestPending)
+ {
+ iFax.TerminateFaxSession ();
+ User::Leave (KFaxCancelRequested);
+ }
+ User::LeaveIfError (iTransferStatus.Int ());
+ User::LeaveIfError (iFax.GetProgress (iProgress));
+ if (iProgress.iPhase != EDataTransfer)
+ break;
+ if (thispage == iProgress.iPage)
+ iSource->PreviousPageFindL ();
+ else
+ iSource->GetNextPageReadyL ();
+ }
+ if ((iProgress.iCompression==EModifiedHuffman) && (iSource->iOurPreferredCompression==Prefer2D))
+ {
+ for (TInt i=0; i<(iSource->iFaxPages/2);i++)
+ iSource->GetNextPageReadyL ();
+ }
+}
+
+void CFaxTransfer::SetFaxSettingsL()
+ {
+ TInt error;
+ RPhone::TStatus phoneStatus;
+
+ error=iPhone.GetStatus(phoneStatus);
+ if (error == KErrNone)
+ {
+ if ((phoneStatus.iModemDetected == RPhone::EDetectedNotPresent) || (phoneStatus.iModemDetected == RPhone::EDetectedUnknown))
+ {
+ TRequestStatus initialiseStatus;
+ iPhone.Initialise(initialiseStatus);
+ User::WaitForAnyRequest();
+ if (iClientCancel != KRequestPending)
+ {
+ iPhone.InitialiseCancel(); // issue initialiseCancel command
+ User::WaitForRequest(initialiseStatus); // wait for it to complete
+ User::Leave(KFaxCancelRequested); // leave with KFaxCancelRequested
+ }
+ User::LeaveIfError(initialiseStatus.Int());
+ }
+ }
+ TInt ret=KErrNone; // so communication with modem has begun...
+ TInt count=0; // we have a loop where we try three times to set fax settings in the
+ // unlikely event that the initialisation sequence has just started
+ // so the phoneStatus gives ModemDetected Present, but the supported fax
+ // classes have not yet been ascertained.
+ do
+ {
+ ret=iCall.SetFaxSettings (iFaxSessionSettings); // retry until init sequence has found out what
+ // the fax classes supported are.
+ if (ret==KErrEtelUnknownModemCapability)
+ User::After(500000);
+ }
+ while (ret==KErrEtelUnknownModemCapability && iClientCancel==KRequestPending && count++<3);
+ if (iClientCancel!=KRequestPending)
+ ret=KFaxCancelRequested;
+ User::LeaveIfError(ret);
+ }
+void CFaxTransfer::SetSharedFileHandlesL()
+ {
+ //Open a file server session and a file handle on the private header file to be shared.
+ RFs sharedFs;
+ RFile sharedHeaderFile;
+
+ User::LeaveIfError(sharedFs.Connect());
+ CleanupClosePushL(sharedFs);
+ //allow it to be shared
+ User::LeaveIfError(sharedFs.ShareProtected());
+
+ //get path
+ TFileName headerFullPath;
+ CFaxHeaderLines::GeneratePathForHeaderFileL(headerFullPath);
+
+ //Open the file in read-only mode
+ User::LeaveIfError(sharedHeaderFile.Open(sharedFs, headerFullPath, EFileRead));
+ CleanupClosePushL(sharedHeaderFile);
+
+ User::LeaveIfError(iCall.AdoptFaxSharedHeaderFile(sharedHeaderFile));
+ CleanupStack::PopAndDestroy();//sharedHeaderFile
+ CleanupStack::PopAndDestroy();//sharedFs
+ }
+
+TInt CFaxTransfer::GetPhoneInfoForTsy(const TDes& aTsyName, RTelServer::TPhoneInfo& aPhoneInfo) const
+//
+// Finds the index of the phone which belongs to TSY named "aTsyName", and retrieves its info.
+//
+ {
+ TInt count=0;
+ iTelServer.EnumeratePhones(count);
+ TName matchTsyName;
+ TInt ret = iTelServer.GetTsyName(0,matchTsyName);
+ if (ret == KErrNone)
+ {
+ TInt i=0;
+ if (count>1)
+ {
+ while (matchTsyName.CompareF(aTsyName)!=KErrNone && i++<count && ret==KErrNone)
+ ret = iTelServer.GetTsyName(i,matchTsyName);
+ }
+ ASSERT(matchTsyName.CompareF(aTsyName)==KErrNone);
+ iTelServer.GetPhoneInfo(i,aPhoneInfo);
+ }
+ return ret;
+ }
+
+/********************************************************************/
+
+EXPORT_C void CFaxTransfer::AddSourceL (const TFileName & aFaxPageStore, TFaxPreferredCompression aPreferredCompression)
+/** Specifies which pages of a fax store file should be sent.
+It can be called more than once to add multiple pages from different files. Typically,
+this function is called twice for each transmission: once to queue the cover sheet,
+and a second time to queue the remainder of the fax.
+The overloaded variants are supplied primarily to help error recovery in cases when
+a fax transmission is either incomplete or when specific pages need to be resent.
+When transmitting a fax, at least one variant of this function must be called before
+CFaxTransfer::Start().
+
+@param aFaxPageStore Name of the fax store file from which to take pages.
+@param aPreferredCompression Preferred compression.
+@capability WriteUserData
+*/
+ {
+ iSource->AddSourceL (aFaxPageStore, 1,aPreferredCompression);
+ }
+
+EXPORT_C void CFaxTransfer::AddSourceL (const TFileName & aFaxPageStore, TInt aStartPage,TFaxPreferredCompression aPreferredCompression)
+/** Specifies which pages of a fax store file should be sent.
+It can be called more than once to add multiple pages from different files.
+Typically, this function is called twice for each transmission: once to queue
+the cover sheet, and a second time to queue the remainder of the fax.
+The overloaded variants are supplied primarily to help error recovery in cases
+when a fax transmission is either incomplete or when specific pages need to be
+resent. When transmitting a fax, at least one variant of this function must be
+called before CFaxTransfer::Start().
+
+@param aFaxPageStore Name of the fax store file from which to take pages.
+@param aStartPage Page in file to start from. If omitted, the file is sent
+from the start.
+@param aPreferredCompression Preferred compression.
+@capability WriteUserData
+*/
+ {
+ iSource->AddSourceL (aFaxPageStore, aStartPage, aPreferredCompression);
+ }
+
+EXPORT_C void CFaxTransfer::AddSourceL (const TFileName & aFaxPageStore, TInt aStartPage, TInt aEndPage, TFaxPreferredCompression aPreferredCompression)
+/**Specifies which pages of a fax store file should be sent.
+It can be called more than once to add multiple pages from different files.
+Typically, this function is called twice for each transmission: once to queue
+the cover sheet, and a second time to queue the remainder of the fax.
+The overloaded variants are supplied primarily to help error recovery in cases
+when a fax transmission is either incomplete or when specific pages need to be
+resent. When transmitting a fax, at least one variant of this function must be
+called before CFaxTransfer::Start().
+
+@param aFaxPageStore Name of the fax store file from which to take pages.
+@param aStartPage Page in file to start from. If omitted, the file is sent from the start.
+@param aEndPage Page in file to stop sending. If omitted, transmission continues to the end.
+@param aPreferredCompression Preferred compression.
+@capability WriteUserData
+*/
+ {
+ iSource->AddSourceL (aFaxPageStore, aStartPage, aEndPage, aPreferredCompression);
+ }
+
+//EXPORT_C void CFaxTransfer::AddSourceL (const TFileName & aFaxPageStore, const TFileName & aFaxPageStore2)
+// {
+// iSource->AddSourceL(aFaxPageStore, aFaxPageStore2);
+// }
+
+EXPORT_C void CFaxTransfer::RemoveAllSources ()
+/** Clears the complete list of pages previously selected for faxing using one
+of the variants of AddSourceL().
+
+Removal of individual items from the list of pages to be fax is not possible.
+
+This function must be used between successive fax transmissions if previously
+sent pages aren't to be sent again.
+@capability WriteUserData
+*/
+ {
+ iSource->RemoveAllSources ();
+ }
+
+/********************************************************************/
+void CFaxTransfer::Convert2dL ()
+ {
+ TInt err=0;
+ TInt k=0;
+ TBuf<64> filename;
+ CWriteFaxFile* writeFaxFile;
+ CReadFaxFile* readFaxFile;
+ TRawScanLine decodedScanLine;
+ //TFaxBufSenderId sd;
+ TFaxBufSenderId senderId;
+
+
+ writeFaxFile = CWriteFaxFile::NewL();
+ CleanupStack::PushL(writeFaxFile);
+ readFaxFile = CReadFaxFile::NewL();
+ CleanupStack::PushL(readFaxFile);
+ iConverting=TRUE;
+
+ TRAP (err,readFaxFile->OpenL(iSource->iOurFaxEntry.iFaxPageStore));
+ if (err!=KErrNone)
+ {
+ iConverting=FALSE;
+ User::Leave(err);
+ }
+
+ readFaxFile->iReadFaxPages->SetPageL(0);
+ TFaxPageInfo info = readFaxFile->iReadFaxPages->CurrentPageInfo();
+ if (info.iCompression != EModifiedHuffman)
+ User::Panic(_L("Not a 1D file"),1);
+
+ //writeFaxFile->OpenL(_L("c:\\blank2D.fax"),64);
+ filename.Copy(iSource->iOurFaxEntry.iFaxPageStore);
+ filename.Append(_L("2d"));
+ // the second push in OpenL doesn't cause a double deletion of writeFaxFile, since it is pushed by using TCleanupItem.
+ // coverity [double_push]
+ writeFaxFile->OpenL(filename,64);
+ //writeFaxFile->OpenL(iSource->iOurFaxEntry.iFaxPageStore,64);
+
+
+ for (k=0; k<iSource->iFaxPages; k++)
+ {
+ readFaxFile->iReadFaxPages->SetPageL(k);
+ TFaxPageInfo info = readFaxFile->iReadFaxPages->CurrentPageInfo();
+ if (info.iCompression != EModifiedHuffman)
+ User::Panic(_L("Not a 1D file"),1);
+ writeFaxFile->iWriteFaxPages->StartPage(info.iResolution, EModifiedRead);
+ for (TInt n = info.iNumScanLines ; n ; n--)
+ {
+ readFaxFile->iReadFaxPages->GetScanLineL(decodedScanLine);
+ writeFaxFile->iWriteFaxPages->AddScanLineL(decodedScanLine);
+ }
+
+ writeFaxFile->iWriteFaxPages->EndPageL(info.iResolution,senderId, EModifiedRead);
+ }// end of for statement
+
+ writeFaxFile->CommitL();
+ writeFaxFile->Close();
+ readFaxFile->Close();
+
+ AddSourceL(filename,Prefer2D);
+ iFaxSessionSettings.iTxPages = (iSource->iFaxPages/2); // sent only the 2d version of the document
+ // which means half the attached pages
+ CleanupStack::PopAndDestroy(2);
+ iConverting=FALSE;
+}
+
+
+
+/***********************************************************************************/
+// This function takes the received 2D file and converts it to 1D
+// The 2D file will be deleted and the 1D version of the file will
+// inherit the name of the received 2D version
+/************************************************************************************/
+void CFaxTransfer::Convert1dL ()
+ {
+ TInt err=0;
+ TInt k=0;
+ TBuf<64> filename;
+ CWriteFaxFile* writeFaxFile;
+ CReadFaxFile* readFaxFile;
+ TRawScanLine decodedScanLine;
+ //TFaxBufSenderId sd;
+ TFaxBufSenderId senderId;
+
+ writeFaxFile = CWriteFaxFile::NewL();
+ CleanupStack::PushL(writeFaxFile);
+ readFaxFile = CReadFaxFile::NewL();
+ CleanupStack::PushL(readFaxFile);
+ iConverting=TRUE;
+
+ //TRAP (err,readFaxFile->OpenL(iSource->iOurFaxEntry.iFaxPageStore));
+ TRAP (err,readFaxFile->OpenL(iReceiveFileName));
+ if (err!=KErrNone)
+ User::Leave(err);
+
+ readFaxFile->iReadFaxPages->SetPageL(0);
+ TFaxPageInfo info = readFaxFile->iReadFaxPages->CurrentPageInfo();
+ //if (info.iCompression != EModifiedHuffman)
+ if (info.iCompression != EModifiedRead)
+ User::Panic(_L("Not a 2D file"),1);
+
+ //filename.Copy(iSource->iOurFaxEntry.iFaxPageStore);
+ filename.Copy(iReceiveFileName);
+ filename.Append(_L("1d"));
+ // the second push in OpenL doesn't cause a double deletion of writeFaxFile, since it is pushed by using TCleanupItem.
+ // coverity [double_push]
+ writeFaxFile->OpenL(filename,64);
+ // writeFaxFile->OpenL(iSource->iOurFaxEntry.iFaxPageStore,64);
+
+
+ TInt iRxPages=readFaxFile->iReadFaxPages->NumPages();
+
+ for (k=0; k<iRxPages; k++)
+ {
+ readFaxFile->iReadFaxPages->SetPageL(k);
+ TFaxPageInfo info = readFaxFile->iReadFaxPages->CurrentPageInfo();
+ //if (info.iCompression != EModifiedHuffman)
+ if (info.iCompression != EModifiedRead)
+ User::Panic(_L("Not a 2D file"),1);
+ //writeFaxFile->iWriteFaxPages->StartPage(info.iResolution, EModifiedRead);
+ writeFaxFile->iWriteFaxPages->StartPage(info.iResolution, EModifiedHuffman);
+ for (TInt n = info.iNumScanLines ; n ; n--)
+ {
+ readFaxFile->iReadFaxPages->GetScanLineL(decodedScanLine);
+ writeFaxFile->iWriteFaxPages->AddScanLineL(decodedScanLine);
+ }
+
+ //writeFaxFile->iWriteFaxPages->EndPageL(info.iResolution,senderId, EModifiedRead);
+ writeFaxFile->iWriteFaxPages->EndPageL(info.iResolution,senderId, EModifiedHuffman);
+ }// end of for statement
+
+ writeFaxFile->CommitL();
+ writeFaxFile->Close();
+ readFaxFile->Close();
+
+ RFs FileServer;
+ err = FileServer.Connect();
+ if (err !=KErrNone)
+ User::Leave(err);
+ User::LeaveIfError(FileServer.Delete(iReceiveFileName));
+
+ User::LeaveIfError(FileServer.Rename(filename,iReceiveFileName));
+
+ FileServer.Close();
+
+ CleanupStack::PopAndDestroy(2);
+ iConverting=FALSE;
+// AddSourceL(filename,Prefer2D);
+// iFaxSessionSettings.iTxPages = (iSource->iFaxPages/2); // sent only the 2d version of the document
+ }
+
+
+/*
+
+CFaxTransfer::StartThread()
+ {
+ TInt state = KErrNone;
+ TInt heapSize = 0x14000;
+ TInt stackSize = 0x14000;
+
+ reinterpret_cast<TAny*>(this); // this points to a CFaxTransfer Object
+ state = iConverterThread.Create ((_L ("FaxConverterThread")), FaxConverterThread, stackSize, heapSize, heapSize, this, EOwnerThread);
+ if (state)
+ {
+ state = KFaxThreadError;
+ }
+ else
+ {
+ //aThreadStat = KRequestPending;
+ //if (iClientCancel != KErrCancel)
+ //iClientCancel = KRequestPending;
+ //iDriverThread.Logon (aThreadStat);
+
+ iConverterThread.SetPriority (EPriorityRealTime);
+ iConverterThread.Resume ();
+ }
+ return state;
+ }
+
+TInt FaxConverterThread (TAny * session)
+ {
+ TInt m;
+ CTrapCleanup *cleanup = CTrapCleanup::New ();
+ CFaxTransfer *faxtransfer =reinterpret_cast<CFaxTransfer *>(session);
+ RSemaphore aSemaphore;
+ TFindSemaphore mysemaphore(_L("FaxCli*"));
+
+ TFullName theName (_L("FaxCliSem"));
+// RSemaphore theSem; // derived from RHandleBase
+
+ if ((mysemaphore.Next(theName))==KErrNone)
+ {
+ aSemaphore.Open(mysemaphore,EOwnerThread);
+ }
+
+
+ TRAP(m,faxtransfer->Convert2dL());
+
+ aSemaphore.Signal();
+ return KErrNone;
+ }
+*/