SetState( STATE_PHASE_E, STATE_SEND_DCN );
					}
					else
					{
						//  decrement speed and retrain
						DecrementSpeed();
						SendHDLCFrame();
						m_nPhaseState = STATE_SEND_DCS;
						m_bGotConnect = false;
					}
				}
			}
			else if( m_bRecvHDLCError )
			{
				if( ++m_nLoopCtr >= 3 )
				{
					m_sLastError.assign( (char*)LoadString(GEN_SENT_DCS_3_TIMES_WITHOUT_RESPONSE).c_str() );
//					SignalEvent( EVENT_ERROR );
					SendHDLCFrame();
					SetState( STATE_PHASE_E, STATE_SEND_DCN );
				}
				else
				{
					SendHDLCFrame();
					m_nPhaseState = STATE_SEND_DCS;
					m_bGotConnect = false;
				}
			}
			else
			{
				RecvHDLCFrame();
			}	
		}
		else if( stricmp( m_szLineBuff, "CONNECT" ) == 0 )
		{
			m_bGotConnect = true;
			// get ready for another HDLC frame
			InitHDLC();
			KillTimer( TIMER_HDLC_RECV );
		}
		else if ( m_szLineBuff[0] == DLE && m_szLineBuff[1] == ETX )
		{
			m_bRecvHDLCError = true;
		}
		else 
		{
			if( ++m_nLoopCtr >= 3 )
			{
				m_sLastError.assign( (char*)LoadString(GEN_SENT_DCS_3_TIMES_WITHOUT_RESPONSE).c_str() );
//				SignalEvent( EVENT_ERROR );
				SendHDLCFrame();
				SetState( STATE_PHASE_E, STATE_SEND_DCN );
			}
			else
			{
				SendHDLCFrame();
				m_nPhaseState = STATE_SEND_DCS;
				m_bGotConnect = false;
			}		
		}
		break;

	case STATE_SEND_SILENCE_BEFORE_DATA:
		//if( stricmp( m_szLineBuff, "OK" ) != 0 )
		//{
		//	OutputDebugString( "Error sending silence\n" );
		//}
		SendShortTraining();
		// change state
		SetState( STATE_PHASE_C );	
		break;


	// begin receiving states

	case STATE_SEND_CSI:
		if( strnicmp( m_szLineBuff, "CONNECT", 7 ) == 0 )
		{
			SendID(CSI);
			m_nPhaseState = STATE_SEND_DIS;	
		}
		else if ( m_szLineBuff[0] == DLE && m_szLineBuff[1] == ETX )
		{
			// ignore
		}
		else
		{
			if( ++m_nLoopCtr >= 3 )
			{
				m_sLastError.assign( (char*)LoadString(GEN_ERROR_SENDING_CSI).c_str() );
//				SignalEvent( EVENT_ERROR );
				SendHDLCFrame();
				SetState( STATE_PHASE_E, STATE_SEND_DCN );
			}
			else
			{
				SendHDLCFrame();
			}
		}
		break;

	case STATE_SEND_DIS:
		if( stricmp( m_szLineBuff, "CONNECT" ) == 0 )
		{
			//OutputDebugString( "Sending DIS\n" );
			SendDIS();
			m_bFinalHDLCFrame = false;
			m_bGotDCS = false;
			m_bGotCRP = false;
			m_nPhaseState = STATE_DIS_SENT;
			EnableSoftFlowControl( false );
		}
		else if ( m_szLineBuff[0] == DLE && m_szLineBuff[1] == ETX )
		{
			// ignore
		}
		else 
		{
			if( ++m_nLoopCtr >= 3 )
			{
				m_sLastError.assign( (char*)LoadString(GEN_ERROR_SENDING_DIS).c_str() );
//				SignalEvent( EVENT_ERROR );
				SendHDLCFrame();
				SetState( STATE_PHASE_E, STATE_SEND_DCN );
			}
			else
			{
				SendHDLCFrame();
				m_nPhaseState = STATE_SEND_CSI;
			}
		}
		break;

	case STATE_DIS_SENT:
		//OutputDebugString( "Waiting for DCS\n" );
		RecvHDLCFrame();
		m_nPhaseState = STATE_WAIT_FOR_DCS;
		m_bGotConnect = false;
		break;

	case STATE_WAIT_FOR_DCS:
		if( stricmp( m_szLineBuff, "OK" ) == 0 )
		{
			if( m_bGotDCN )
			{
				m_sLastError.assign( (char*)LoadString(GEN_UNEXPECTED_DCN_RECEIVED).c_str() );
				Terminate();
				DoHangup();
			}
			else if( m_bFinalHDLCFrame )
			{
				if( m_bGotDCS )
				{
					m_dwTrainingStart = GetTickCount();
					SetTimer( TIMER_TRAINING, 4000 );
					m_nPhaseState = STATE_RECEIVE_TRAINING_DATA;
					RecvLongTraining();
					SignalEvent( EVENT_START_TRAINING );
				}
				else if( m_bGotCRP )
				{
					SendHDLCFrame();
					m_nPhaseState = STATE_SEND_CSI;
				}
				else
				{	
					if( ++m_nLoopCtr >= 3 )
					{
						m_sLastError.assign( (char*)LoadString(GEN_SENT_DIS_3_TIMES_WITHOUT_RESPONSE).c_str() );
//						SignalEvent( EVENT_ERROR );
						SendHDLCFrame();
						SetState( STATE_PHASE_E, STATE_SEND_DCN );
					}
					else
					{
						m_nPhaseState = STATE_SEND_CSI;
						SendHDLCFrame();
					}
				}
			}
			else if( m_bRecvHDLCError )
			{
				if( ++m_nLoopCtr >= 3 )
				{
					m_sLastError.assign( (char*)LoadString(GEN_SENT_DIS_3_TIMES_WITHOUT_RESPONSE).c_str() );
//					SignalEvent( EVENT_ERROR );
					SendHDLCFrame();
					SetState( STATE_PHASE_E, STATE_SEND_DCN );
				}
				else
				{
					m_nPhaseState = STATE_SEND_CSI;
					SendHDLCFrame();
				}
			}
			else
			{
				// ask for another
				//OutputDebugString( "Waiting for DCS\n" );
				RecvHDLCFrame();
			}
		}
		else if( stricmp( m_szLineBuff, "CONNECT" ) == 0 )
		{
			// get ready for another HDLC frame
			m_bGotConnect = true;
			InitHDLC();
			KillTimer( TIMER_HDLC_RECV );
		}
		else if ( m_szLineBuff[0] == DLE && m_szLineBuff[1] == ETX )
		{
			m_bRecvHDLCError = true;
		}
		else 
		{
			if( ++m_nLoopCtr >= 3 )
			{
				m_sLastError.assign( (char*)LoadString(GEN_SENT_DIS_3_TIMES_WITHOUT_RESPONSE).c_str() );
//				SignalEvent( EVENT_ERROR );
				SendHDLCFrame();
				SetState( STATE_PHASE_E, STATE_SEND_DCN );
			}
			else
			{
				m_nPhaseState = STATE_SEND_CSI;
				SendHDLCFrame();
			}
		}
		break;

	case STATE_RECEIVE_TRAINING_DATA:
		if( stricmp( m_szLineBuff, "CONNECT" ) == 0 )
		{
			KillTimer( TIMER_TRAINING );
			InitHDLC();
			m_nPhaseState = STATE_RECEIVE_TRAINING;
			m_nCorrect = 0;
		}
		else 
		{
			// Wait 1.5 seconds so that the transmitter gets our FTT
			int nTimeLeft = (1500 - (GetTickCount() - m_dwTrainingStart));
			if( nTimeLeft > 0 )
			{
				// try the receive command again
				RecvLongTraining();
			}
			else
			{
				KillTimer( TIMER_TRAINING );
				SendHDLCFrame();
				m_nPhaseState = STATE_SEND_CFR;
			}
		}
		break;

	case STATE_RECEIVE_TRAINING:
		if( stricmp( m_szLineBuff, "OK" ) == 0 ||
			stricmp( m_szLineBuff, "NO CARRIER" ) == 0 )
		{
			// send CFR
			SendHDLCFrame();
			m_nPhaseState = STATE_SEND_CFR;
		}
		else 
		{
			// Wait 1.5 seconds so that the transmitter gets our FTT
			int nDelay = (1500 - (GetTickCount() - m_dwTrainingStart));
			if( nDelay > 0 )
			{
				Sleep( nDelay );
			}

			//OutputDebugString( "Error receiving training data\n" );
			// send CFR
			SendHDLCFrame();
			m_nPhaseState = STATE_SEND_CFR;
		}
		break;

	case STATE_SEND_CFR:
		if( stricmp( m_szLineBuff, "CONNECT" ) == 0 )
		{
			// send CFR
			if( m_nCorrect > 70 )
			{
				SendCFR();
				m_nPhaseState = STATE_SEND_RECV_DATA;
				SignalEventString( EVENT_INFO, (char*)LoadString(GEN_SENT_CFR).c_str() );
			}
			else
			{
				SendFTT();
				m_bFinalHDLCFrame = false;
				m_bRecvHDLCError = false;
				m_nPhaseState = STATE_SENT_FTT;
				EnableSoftFlowControl( false );
				SignalEventString( EVENT_INFO, (char*)LoadString(GEN_SENT_FTT).c_str() );
			}
		}
		else 
		{
			if( ++m_nLoopCtr >= 3 )
			{
				m_sLastError.assign( (char*)LoadString(GEN_SENT_DIS_3_TIMES_WITHOUT_RESPONSE).c_str() );
//				SignalEvent( EVENT_ERROR );
				SendHDLCFrame();
				SetState( STATE_PHASE_E, STATE_SEND_DCN );
			}
			else
			{
				m_nPhaseState = STATE_SEND_CSI;
				SendHDLCFrame();
			}
		}
		break;

	case STATE_SEND_RECV_DATA:
		if( stricmp( m_szLineBuff, "OK" ) == 0 )
		{
			//OutputDebugString( "Going to phase C\n" );
			RecvShortTraining();
			SetState( STATE_PHASE_C );
			m_FaxFile.WriteFileHeader();
			m_nPPRCtr = 0;
		}
		else 
		{
			if( ++m_nLoopCtr >= 3 )
			{
				m_sLastError.assign( (char*)LoadString(GEN_SENT_DIS_3_TIMES_WITHOUT_RESPONSE).c_str() );
//				SignalEvent( EVENT_ERROR );
				SendHDLCFrame();
				SetState( STATE_PHASE_E, STATE_SEND_DCN );
			}
			else
			{
				m_nPhaseState = STATE_SEND_CSI;
				SendHDLCFrame();
			}
		}
		break;


	case STATE_SENT_FTT:
		RecvHDLCFrame();
		m_nPhaseState = STATE_SENT_FTT_WAIT_FOR_DCS;
		break;

	case STATE_SENT_FTT_WAIT_FOR_DCS:
		if( stricmp( m_szLineBuff, "OK" ) == 0 )
		{
			if( m_bGotDCN )
			{
				m_sLastError.assign( (char*)LoadString(GEN_UNEXPECTED_DCN_RECEIVED).c_str() );
				Terminate();
				DoHangup();
			}
			else if( m_bFinalHDLCFrame )
			{
				if( m_bGotDCS )
				{
					m_nLoopCtr = 0;
					SetTimer( TIMER_TRAINING, 4000 );
					m_nPhaseState = STATE_RECEIVE_TRAINING_DATA;
					RecvLongTraining();
					SignalEvent( EVENT_START_TRAINING );
				}
				else if( m_bGotCRP )
				{
					SendHDLCFrame();
					m_nPhaseState = STATE_SEND_CFR;
				}
				else
				{	
					if( ++m_nLoopCtr >= 3 )
					{
						m_sLastError.assign( (char*)LoadString(GEN_SENT_FTT_3_TIMES_WITHOUT_RESPONSE).c_str() );
//						SignalEvent( EVENT_ERROR );
						SendHDLCFrame();
						SetState( STATE_PHASE_E, STATE_SEND_DCN );
					}
					else
					{
						m_nPhaseState = STATE_SEND_CFR;
						SendHDLCFrame();
					}
				}
			}
			else if( m_bRecvHDLCError )
			{
				if( ++m_nLoopCtr >= 3 )
				{
					m_sLastError.assign( (char*)LoadString(GEN_SENT_FTT_3_TIMES_WITHOUT_RESPONSE).c_str() );
//					SignalEvent( EVENT_ERROR );
					SendHDLCFrame();
					SetState( STATE_PHASE_E, STATE_SEND_DCN );
				}
				else
				{
					m_nPhaseState = STATE_SEND_CFR;
					SendHDLCFrame();
				}
			}
			else
			{
				// ask for another
				//OutputDebugString( "Waiting for DCS\n" );
				RecvHDLCFrame();
			}
		}
		else if( stricmp( m_szLineBuff, "CONNECT" ) == 0 )
		{
			// get ready for another HDLC frame
			m_bGotConnect = true;
			InitHDLC();
			KillTimer( TIMER_HDLC_RECV );
		}
		else if ( m_szLineBuff[0] == DLE && m_szLineBuff[1] == ETX )
		{
			m_bRecvHDLCError = true;
		}
		else 
		{
			if( ++m_nLoopCtr >= 3 )
			{
				m_sLastError.assign( (char*)LoadString(GEN_SENT_FTT_3_TIMES_WITHOUT_RESPONSE).c_str() );
//				SignalEvent( EVENT_ERROR );
				SendHDLCFrame();
				SetState( STATE_PHASE_E, STATE_SEND_DCN );
			}
			else
			{
				m_nPhaseState = STATE_SEND_CFR;
				SendHDLCFrame();
			}
		}
		break;

	}
}

//////////////////////////////////////////////////////////////////////
// Phase C - transmit/receive data
//////////////////////////////////////////////////////////////////////
void CClassOne::PhaseC(void)
{
	if( stricmp( m_szLineBuff, "CONNECT" ) == 0 )
	{
		if( m_bReceiving )
		{
			InitHDLC();
		}
		else
		{
			m_nPageBytes = 0;
			DoWrite( m_FaxFile.GetPageData(), m_FaxFile.GetPageBytes(), false );

			SetMaxPageRetriesTimer();
		}

		SignalEvent( EVENT_START_PAGE );
	}
	else if( stricmp( m_szLineBuff, "+FCERROR" ) == 0 )
	{
		if( m_bReceiving )
		{
			RecvShortTraining();
		}
		else
		{
			SendShortTraining();
		}
	}
	else /*if( stricmp( m_szLineBuff, "OK" ) == 0 ||
		     stricmp( m_szLineBuff, "NO CARRIER" ) == 0) */
	{
		m_nLoopCtr = 0;

		if( m_bReceiving )
		{
			if( !m_bECM )
			{
				m_bLastPageGood = m_FaxFile.WriteIFD();
			}

			m_bGotEOP = false;
			m_bGotMPS = false;
			m_bGotEOM = false;
			m_bFinalHDLCFrame = false;
			RecvHDLCFrame();

			m_dwEOPWaitStart = GetTickCount();

			SetState( STATE_PHASE_D, STATE_WAIT_FOR_EOP );
		}
		else
		{
			// Send 75ms of silence
			SendFormattedCommand( "FTS", 8 );
			SetState( STATE_PHASE_D, STATE_SEND_SILENCE_BEFORE_PAGE_FINISHED );
		}
	}
}

//////////////////////////////////////////////////////////////////////
// Phase D - end of page
//////////////////////////////////////////////////////////////////////
void CClassOne::PhaseD(void)
{
	switch( m_nPhaseState )
	{

	// begin sending states

	case STATE_SEND_SILENCE_BEFORE_PAGE_FINISHED:
		//if( stricmp( m_szLineBuff, "OK" ) != 0 )
		//{
		//	OutputDebugString( "Error sending silence\n" );
		//}
		SendHDLCFrame();
		m_nPhaseState = STATE_SEND_PAGE_FINISHED;
		break;

	case STATE_SEND_PAGE_FINISHED:
		if( stricmp( m_szLineBuff, "CONNECT" ) == 0 )
		{
			SendEOP();
			m_nPhaseState = STATE_PAGE_FINISHED_SENT;
			m_bGotPPR = false;
			m_bFinalHDLCFrame = false;
			m_bGotMCF = false;
			m_bGotRNR = false;
			m_bGotCRP = false;
			m_bGotRTP = false;
			m_bGotRTN = false;
			m_dwRNRStart = 0;
		}
		else 
		{
			if( ++m_nLoopCtr >= 3 )
			{
				m_sLastError.assign( (char*)LoadString(GEN_SENT_PPS_3_TIMES_WITHOUT_RESPONSE).c_str() );
//				SignalEvent( EVENT_ERROR );
				SendHDLCFrame();
				SetState( STATE_PHASE_E, STATE_SEND_DCN );
			}
			else
			{
				//OutputDebugString( "Error sending EOP\n" );
				SendHDLCFrame();
			}
		}
		break;


	case STATE_PAGE_FINISHED_SENT:
		m_nPhaseState = STATE_WAIT_FOR_MCF;
		EnableSoftFlowControl( false );
		RecvHDLCFrame();
		break;

	case STATE_WAIT_FOR_MCF:
		if( stricmp( m_szLineBuff, "OK" ) == 0 )
		{
			if( m_bGotDCN )
			{
				m_sLastError.assign( (char*)LoadString(GEN_UNEXPECTED_DCN_RECEIVED).c_str() );
				Terminate();
				DoHangup();
			}
			else if( m_bFinalHDLCFrame && (m_bGotMCF || m_bGotPPR) )
			{
				EnableSoftFlowControl( true );

				if( m_FaxFile.MorePages() == false && m_bGotPPR == false && m_FaxFile.GetPartialPage() == false )
				{
					m_FaxFile.IncrementPageCount();
					m_bSuccessful = true;
					SendHDLCFrame();
					SetState( STATE_PHASE_E, STATE_SEND_DCN );
					KillTimer( TIMER_MAXPAGERETRIES );
				}
				else
				{
					if( m_bGotPPR )
					{
						if( m_nPPRCtr > 3 )
						{