开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 传真(Fax)编程 > 查看源码
ClassTwo.cpp
资源名称：faxengine-1.0.3.zip　[点击查看]
上传用户：glass0516
上传日期：2010-01-11
资源大小：104k
文件大小：37k
源码类别：

传真(Fax)编程

开发平台：

Visual C++

ClassTwo.cpp：源码内容
  1. /*****************************************************************************
  2. * RelayFax Open Source Project
  3. * Copyright 1996-2004 Alt-N Technologies, Ltd.
  4. * All rights reserved.
  5. *
  6. * Redistribution and use in source and binary forms, with or without
  7. * modification, are permitted only as authorized by the RelayFax Open 
  8. * Source License.  A copy of this license is available in file LICENSE 
  9. * in the top-level directory of the distribution.
  10. *
  11. * RelayFax is a registered trademark of Alt-N Technologies, Ltd.
  12. *
  13. * Individual files and/or contributed packages may be copyright by
  14. * other parties and subject to additional restrictions.
  15. *****************************************************************************/
  17. ////////////////////////////////////////////////////////////////////////////////
  18. //
  19. // The purpose of CClassTwo is contain the protocol specifics of EIA
  20. // fax modem class 2
  21. //
  22. ////////////////////////////////////////////////////////////////////////////////
  24. #include "stdafx.h"
  25. #include "ClassTwo.h"
  28. #define CLASSTWO_CONNECT "+FCON"
  29. #define CLASSTWO_CONNECT_SIZE 5
  30. #define CLASSTWO_TSI "+FTSI"
  31. #define CLASSTWO_TSI_SIZE 5
  32. #define CLASSTWO_DCS "+FDCS"
  33. #define CLASSTWO_DCS_SIZE 5
  34. #define CLASSTWO_NSS " +FNSS"
  35. #define CLASSTWO_NSS_SIZE 5
  36. #define CLASSTWO_HNGUP "+FHNG"
  37. #define CLASSTWO_HNGUP_SIZE 5
  38. #define CLASSTWO_CSI "+FCSI"
  39. #define CLASSTWO_CSI_SIZE 5
  40. #define CLASSTWO_DIS "+FDIS"
  41. #define CLASSTWO_DIS_SIZE 5
  42. #define CLASSTWO_NSF "+FNSF"
  43. #define CLASSTWO_NSF_SIZE 5
  44. #define CLASSTWO_PTS "+FPTS"
  45. #define CLASSTWO_PTS_SIZE 5
  46. #define CLASSTWO_ET "+FET"
  47. #define CLASSTWO_ET_SIZE 4
  49. #define CLASSTWO_DR "AT+FDR"
  50. #define CLASSTWO_DR_SIZE 6
  51. #define CLASSTWO_DT "AT+FDT"
  52. #define CLASSTWO_DT_SIZE 6
  53. #define CLASSTWO_FK "AT+FK"
  54. #define CLASSTWO_FK_SIZE 5
  56. #define CLASSTWO_SETID "AT+FLID="%s""
  57. #define CLASSTWO_SETRECV "AT+FCR=%d"
  58. #define CLASSTWO_SETBOR "AT+FBOR=0"
  59. #define CLASSTWO_SETPARAMS "AT+FDIS=%d,%d,%d,%d,%d,%d,0,%d"
  60. #define CLASSTWO_SENDET "AT+FET=%d"
  62. //////////////////////////////////////////////////////////////////////
  63. // Construction/Destruction
  64. //////////////////////////////////////////////////////////////////////
  66. CClassTwo::CClassTwo()
  67. {
  68. m_sEIAClass = "2";
  69. m_nScanTime = 0;
  70. }
  72. CClassTwo::~CClassTwo()
  73. {
  75. }
  77. void CClassTwo::OnConnect(void)
  78. {
  79. SetState( STATE_INIT );
  81. m_bGotOK = false;
  83. SendCommand( COMMAND_INIT );
  85. m_nLoopCtr = 0; 
  86. }
  89. bool CClassTwo::OnDisconnect(void)
  90. {
  91. switch( m_nState )
  92. {
  93. case STATE_INIT:
  94. SignalEvent( EVENT_ERROR );
  95. return true;
  97. case STATE_PHASE_A:
  98. case STATE_PHASE_B:
  99. case STATE_PHASE_C:
  100.   case STATE_PHASE_D:
  101.     case STATE_PHASE_E:
  102. Abort( true );
  103. return false;
  104. }
  106. return true;
  107. }
  109. //////////////////////////////////////////////////////////////////////
  110. // OnWrite
  111. //////////////////////////////////////////////////////////////////////
  112. void CClassTwo::OnWrite(void)
  113. {
  114. m_dwActivityTimer = GetTickCount();
  116. if( m_nState == STATE_PHASE_C && !m_bReceiving  && m_bGotDCS )
  117. {
  118. m_nPageBytes += m_BytesWritten;
  120. int nPercent = 100 * m_nPageBytes / m_FaxFile.GetPageBytes();
  122. if( nPercent > 100 )
  123. nPercent = 100;
  125. SignalEvent( EVENT_PAGE_DATA, nPercent );
  126. }
  127. }
  130. //////////////////////////////////////////////////////////////////////
  131. // OnReadLine
  132. //////////////////////////////////////////////////////////////////////
  133. void CClassTwo::OnReadLine(void)
  134. {
  135. //char szMsg[256];
  136. //wsprintf( szMsg, "CClassTwo::OnReadLine: %s %dn", m_szLineBuff, m_nLineBuffPtr );
  137. //OutputDebugString( szMsg );
  139. switch( m_nState )
  140. {
  141. case STATE_IDLE:
  142. PhaseIdle();
  143. break;
  145. case STATE_INIT:
  146. PhaseInit();
  147. break;
  149. case STATE_PHASE_A:
  150. PhaseA();
  151. break;
  153. case STATE_PHASE_B:
  154. PhaseB();
  155. break;
  157. case STATE_PHASE_C:
  158. PhaseC();
  159. break;
  161. case STATE_PHASE_D:
  162. PhaseD();
  163. break;
  165. case STATE_PHASE_E:
  166. PhaseE();
  167. break;
  169. case STATE_RINGING:
  170. PhaseRinging();
  171. break;
  173. case STATE_DISCONNECT:
  174. PhaseDisconnect();
  175. break;
  176. }
  178. }
  181. //////////////////////////////////////////////////////////////////////
  182. // PhaseInit
  183. //////////////////////////////////////////////////////////////////////
  184. void CClassTwo::PhaseInit(void)
  185. {
  186. if( stricmp( m_szLineBuff, m_LastCommandString.c_str() ) == 0 )
  187. {
  188. // Echo - ignore
  189. return;
  190. }
  192. if( IsRing() )
  193. {
  194. // RING
  195. m_nRingCount++;
  196. return;
  197. }
  199. switch( m_nLastCommand )
  200. {
  201. case COMMAND_INIT:
  202. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  203. {
  204. m_bGotOK = true;
  205. }
  206. else 
  207. {
  208. if( ++m_nLoopCtr >= 3 )
  209. {
  210. ErrorUnexpectedResponse();
  211. KillTimer( TIMER_COMMAND );
  212. OnDisconnectMsg();
  213. }
  214. }
  215. break;
  217. case COMMAND_SETUP_STRING:
  218. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  219. {
  220. SendCommand( COMMAND_DISABLE_ECHO );
  221. }
  222. else
  223. {
  224. ErrorUnexpectedResponse();
  225. KillTimer( TIMER_COMMAND );
  226. OnDisconnectMsg();
  227. }
  228. break;
  230. case COMMAND_DISABLE_ECHO:
  231. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  232. {
  233. SendCommand( COMMAND_SET_SPKR_VOL );
  234. }
  235. else
  236. {
  237. ErrorUnexpectedResponse();
  238. KillTimer( TIMER_COMMAND );
  239. OnDisconnectMsg();
  240. }
  241. break;
  243. case COMMAND_SET_SPKR_VOL:
  244. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  245. {
  246. SendCommand( COMMAND_SET_SPKR_MODE );
  247. }
  248. else
  249. {
  250. ErrorUnexpectedResponse();
  251. KillTimer( TIMER_COMMAND );
  252. OnDisconnectMsg();
  253. }
  254. break;
  256. case COMMAND_SET_SPKR_MODE:
  257. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  258. {
  259. SendCommand( COMMAND_SET_FCLASS_2 );
  260. }
  261. else
  262. {
  263. ErrorUnexpectedResponse();
  264. KillTimer( TIMER_COMMAND );
  265. OnDisconnectMsg();
  266. }
  267. break;
  269. case COMMAND_SET_FCLASS_2:
  270. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  271. {
  272. SendCommand( COMMAND_QUERY_CLASS2_CAP );
  273. }
  274. else
  275. {
  276. ErrorUnexpectedResponse();
  277. KillTimer( TIMER_COMMAND );
  278. OnDisconnectMsg();
  279. }
  280. break;
  282. case COMMAND_QUERY_CLASS2_CAP:
  283. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  284. {
  285. SendCommand( COMMAND_QUERY_SEND_SPEEDS );
  286. }
  287. else if( stricmp( m_szLineBuff, "ERROR" ) == 0 )
  288. {
  289. ErrorUnexpectedResponse();
  290. KillTimer( TIMER_COMMAND );
  291. OnDisconnectMsg();
  292. }
  293. else
  294. {
  295. ProcCapabilities( m_szLineBuff );
  297. VerifyOptions();
  298. }
  299. break;
  301. case COMMAND_QUERY_SEND_SPEEDS:
  302. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  303. {
  304. SendCommand( COMMAND_QUERY_RECEIVE_SPEEDS );
  305. }
  306. else
  307. {
  308. ProcSupportedSpeeds( m_szLineBuff, true );
  309. }
  310. break;
  312. case COMMAND_QUERY_RECEIVE_SPEEDS:
  313. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  314. {
  315. SetLocalID();
  316. }
  317. else
  318. {
  319. ProcSupportedSpeeds( m_szLineBuff, false );
  320. }
  321. break;
  323. case COMMAND_SET_LOCAL_ID:
  324. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  325. {
  326. SetRecv();
  327. }
  328. else
  329. {
  330. ErrorUnexpectedResponse();
  331. KillTimer( TIMER_COMMAND );
  332. OnDisconnectMsg();
  333. }
  334. break;
  336. case COMMAND_SET_RECV:
  337. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  338. {
  339. SetBitOrder();
  340. }
  341. else
  342. {
  343. ErrorUnexpectedResponse();
  344. KillTimer( TIMER_COMMAND );
  345. OnDisconnectMsg();
  346. }
  347. break;
  349. case COMMAND_SET_BIT_ORDER:
  350. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  351. {
  352. m_nScanTime = 0;
  353. SetFaxParams( false );
  354. }
  355. else
  356. {
  357. ErrorUnexpectedResponse();
  358. KillTimer( TIMER_COMMAND );
  359. OnDisconnectMsg();
  360. }
  361. break;
  363. case COMMAND_SET_FAX_PARAMS:
  364. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  365. {
  366. SetState( STATE_IDLE );
  367. KillTimer( TIMER_COMMAND );
  368. }
  369. else
  370. {
  371. ErrorUnexpectedResponse();
  372. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_REDUCE_COMPRESSION_BAUD_RATE_OR_DISABLE_ECM).c_str() );
  373. KillTimer( TIMER_COMMAND );
  374. OnDisconnectMsg();
  375. }
  376. break;
  377. }
  379. }
  382. //////////////////////////////////////////////////////////////////////
  383. // PhaseIdle
  384. //////////////////////////////////////////////////////////////////////
  385. void CClassTwo::PhaseIdle(void)
  386. {
  387. if( IsRing() )
  388. {
  389. m_nRingCount = 1;
  390. SetState( STATE_RINGING );
  392. SignalEvent( EVENT_RING, m_nRingCount );
  393. }
  394. }
  396. //////////////////////////////////////////////////////////////////////
  397. // Phase Ringing
  398. //////////////////////////////////////////////////////////////////////
  399. void CClassTwo::PhaseRinging(void)
  400. {
  401. if( IsRing() )
  402. {
  403. m_nRingCount++;
  405. SignalEvent( EVENT_RING, m_nRingCount );
  407. /*
  408. if( OkToAnswer() )
  409. {
  410. m_bReceiving = true;
  411. m_bSuccessful = false;
  412. SendCommand( COMMAND_ANSWER );
  413. SetState( STATE_PHASE_B, STATE_RECEIVING );
  414. }
  415. */
  416. }
  417. else if( strnicmp( m_szLineBuff, CLASSTWO_CONNECT, CLASSTWO_CONNECT_SIZE ) == 0 )
  418. {
  419. EnableSoftFlowControl( false );
  420. m_FaxFile.SetSendEncoding( m_nSendEncoding );
  421. m_bReceiving = true;
  422. m_bSuccessful = false;
  423. SignalEvent( EVENT_START_RECV );
  424. SetState( STATE_PHASE_B, STATE_RECEIVING );
  425. }
  426. else
  427. {
  428. SignalEvent( EVENT_CALLERID );
  429. }
  430. }
  433. //////////////////////////////////////////////////////////////////////
  434. // Phase A - call setup
  435. //////////////////////////////////////////////////////////////////////
  436. void CClassTwo::PhaseA(void)
  437. {
  438. switch( m_nPhaseState )
  439. {
  440. case STATE_SET_PARAMS:
  441. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  442. {
  443. SetLocalID();
  444. m_nPhaseState = STATE_SET_CSID;
  445. }
  446. else
  447. {
  448. // Error setting fax params
  449. m_sLastError.assign( (char*)LoadString(GEN_ERROR_SETTING_FAX_PARAMETERS).c_str() );
  450. //SignalEvent( EVENT_ERROR );
  451. Terminate();
  452. PhaseDisconnect();
  453. }
  454. break;
  456. case STATE_SET_CSID:
  457. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  458. {
  459. if( m_bReceiving )
  460. {
  461. SendCommand( COMMAND_ANSWER );
  462. SetState( STATE_PHASE_B, STATE_RECEIVING );
  463. }
  464. else
  465. {
  466. SendCommand( COMMAND_DIAL );
  467. m_nPhaseState = STATE_DIALING;
  468. }
  469. }
  470. else
  471. {
  472. // Error setting ID
  473. m_sLastError.assign( (char*)LoadString(GEN_ERROR_SETTING_ID).c_str() );
  474. //SignalEvent( EVENT_ERROR );
  475. Terminate();
  476. PhaseDisconnect();
  477. }
  478. break;
  480. case STATE_DIALING:
  481. if( strnicmp( m_szLineBuff, CLASSTWO_CONNECT, CLASSTWO_CONNECT_SIZE ) == 0 )
  482. {
  483. m_nLoopCtr = 0;
  484. SetState( STATE_PHASE_B, STATE_SENDING );
  485. m_bGotDIS = false;
  486. SignalEvent( EVENT_START_SEND );
  487. }
  488. else if( strnicmp( m_szLineBuff, CLASSTWO_HNGUP, CLASSTWO_HNGUP_SIZE ) == 0 )
  489. {
  490. OnFHNG();
  491. }
  492. else
  493. {
  494. ErrorConnectResponse();
  495. Terminate();
  496. PhaseDisconnect();
  497. }
  498. break;
  500. }
  501. }
  504. //////////////////////////////////////////////////////////////////////
  505. // Phase B - negotiation and training
  506. //////////////////////////////////////////////////////////////////////
  507. void CClassTwo::PhaseB(void)
  508. {
  509. switch( m_nPhaseState )
  510. {
  511. case STATE_RECEIVING:
  512. if( strnicmp( m_szLineBuff, "OK", 2 ) == 0 )
  513. {
  514. m_bGotEOP = false;
  515. m_bGotMPS = false;
  516. m_bGotEOM = false;
  518. // On to phase C
  519. DoWrite( CLASSTWO_DR, CLASSTWO_DR_SIZE, true );
  520. SetState( STATE_PHASE_C );
  521. m_FaxFile.WriteFileHeader();
  522. SignalEvent( EVENT_START_TRAINING );
  523. } 
  524. else if( strnicmp( m_szLineBuff, CLASSTWO_CONNECT, CLASSTWO_CONNECT_SIZE ) == 0 )
  525. {
  526. SignalEvent( EVENT_START_RECV );
  527. }
  528. else if( strnicmp( m_szLineBuff, CLASSTWO_TSI, CLASSTWO_TSI_SIZE ) == 0 )
  529. {
  530. OnCSI();
  531. }
  532. else if( strnicmp( m_szLineBuff, CLASSTWO_DCS, CLASSTWO_DCS_SIZE ) == 0 )
  533. {
  534. OnDCS();
  535. }
  536. else if( strnicmp( m_szLineBuff, CLASSTWO_NSS, CLASSTWO_NSS_SIZE ) == 0 )
  537. {
  538. OnNSS();
  539. }
  540. else if( strnicmp( m_szLineBuff, CLASSTWO_HNGUP, CLASSTWO_HNGUP_SIZE ) == 0 )
  541. {
  542. OnFHNG();
  543. }
  544. break;
  546. case STATE_SENDING:
  547. if( strnicmp( m_szLineBuff, "OK", 2 ) == 0 )
  548. {
  549. // Check DIS and re-set parameters if necessar
  550. if( m_bGotDIS && m_bResendFaxParams )
  551. {
  552. SetFaxParams( true );
  553. m_nPhaseState = STATE_RESET_PARAMS;
  554. }
  555. else
  556. {
  557. // On to Phase C
  558. DoWrite( CLASSTWO_DT, CLASSTWO_DT_SIZE, true );
  559. SetState( STATE_PHASE_C );
  560. m_bGotDCS = false;
  561. SignalEvent( EVENT_START_TRAINING );
  562. m_bLastPageGood = false;
  563. }
  564. } 
  565. else if( strnicmp( m_szLineBuff, CLASSTWO_CSI, CLASSTWO_CSI_SIZE ) == 0 )
  566. {
  567. OnCSI();
  568. }
  569. else if( strnicmp( m_szLineBuff, CLASSTWO_DIS, CLASSTWO_DIS_SIZE ) == 0 )
  570. {
  571. OnDIS();
  572. }
  573. else if( strnicmp( m_szLineBuff, CLASSTWO_NSF, CLASSTWO_NSF_SIZE ) == 0 )
  574. {
  575. OnNSF();
  576. }
  577. else if( strnicmp( m_szLineBuff, CLASSTWO_HNGUP, CLASSTWO_HNGUP_SIZE ) == 0 )
  578. {
  579. OnFHNG();
  580. }
  581. break;
  583. case STATE_RESET_PARAMS:
  584. if( strnicmp( m_szLineBuff, "OK", 2 ) == 0 )
  585. {
  586. // On to Phase C
  587. DoWrite( CLASSTWO_DT, CLASSTWO_DT_SIZE, true );
  588. SetState( STATE_PHASE_C );
  589. m_bGotDCS = false;
  590. KillTimer( TIMER_COMMAND );
  591. SignalEvent( EVENT_START_TRAINING );
  592. m_bLastPageGood = false;
  593. }
  594. else
  595. {
  596. ErrorUnexpectedResponse();
  597. KillTimer( TIMER_COMMAND );
  598. Terminate();
  599. PhaseDisconnect();
  600. }
  601. break;
  602. }
  603. }
  606. //////////////////////////////////////////////////////////////////////
  607. // Phase C - transmit/receive data
  608. //////////////////////////////////////////////////////////////////////
  609. void CClassTwo::PhaseC(void)
  610. {
  611. if( m_bReceiving )
  612. {
  613. if( strnicmp( m_szLineBuff, "CONNECT", 7 ) == 0 )
  614. {
  615. if( !m_bGotDCS )
  616. {
  617. char can = CAN;
  618. DoWrite( &can, 1, false );
  619. m_sLastError.assign( (char*)LoadString(GEN_ERROR_DCS_NOT_RECEIVED).c_str() );
  620. //SignalEvent( EVENT_ERROR );
  621. Terminate();
  622. SetState( STATE_PHASE_E, STATE_WAIT_FOR_OK );
  623. }
  624. else
  625. {
  626. char dc2 = DC2;
  627. DoWrite( &dc2, 1, false );
  628. InitHDLC();
  629. //EnableSoftFlowControl( false );
  630. m_bFirstFrame = true;
  632. SignalEvent( EVENT_START_PAGE );
  633. }
  634. }
  635. else if( stricmp( m_szLineBuff, "OK" ) == 0 )
  636. {
  637. m_nLoopCtr = 0;
  638. m_bLastPageGood = m_FaxFile.WriteIFD();
  640. //EnableSoftFlowControl( true );
  642. if( m_bGotEOP || (!m_bGotEOP && !m_bGotEOM && !m_bGotMPS ))
  643. {
  644. SetState( STATE_PHASE_E, STATE_WAIT_FOR_OK );
  645. }
  647. DoWrite( CLASSTWO_DR, CLASSTWO_DR_SIZE, true );
  649. m_bGotEOP = false;
  650. m_bGotMPS = false;
  651. m_bGotEOM = false;
  652. }
  653. else if( strnicmp( m_szLineBuff, CLASSTWO_PTS, CLASSTWO_PTS_SIZE ) == 0 )
  654. {
  655. OnFPTS();
  656. }
  657. else if( strnicmp( m_szLineBuff, CLASSTWO_ET, CLASSTWO_ET_SIZE ) == 0 )
  658. {
  659. OnFET();
  660. }
  661. else if( strnicmp( m_szLineBuff, CLASSTWO_HNGUP, CLASSTWO_HNGUP_SIZE ) == 0 )
  662. {
  663. OnFHNG();
  664. }
  665. }
  666. else
  667. {
  668. if( strnicmp( m_szLineBuff, "CONNECT", 7 ) == 0 )
  669. {
  670. char xon = XON;
  671. DoWrite( &xon, 1, false );
  673. m_nPageBytes = 0;
  674. DoWrite( m_FaxFile.GetPageData(), m_FaxFile.GetPageBytes(), false );
  676. SignalEvent( EVENT_START_PAGE );
  678. SetMaxPageRetriesTimer();
  679. }
  680. else if( stricmp( m_szLineBuff, "OK" ) == 0 )
  681. {
  682. char szCmdBuff[64];
  683. wsprintf( szCmdBuff, CLASSTWO_SENDET, m_FaxFile.MorePages() ? 0 : 2 );
  684. // on to phase D
  685. DoWrite( szCmdBuff, strlen(szCmdBuff), true );
  686. SetState( STATE_PHASE_D );
  687. }
  688. else if( strnicmp( m_szLineBuff, CLASSTWO_DCS, CLASSTWO_DCS_SIZE ) == 0 )
  689. {
  690. OnDCS();
  691. }
  692. else if( strnicmp( m_szLineBuff, CLASSTWO_HNGUP, CLASSTWO_HNGUP_SIZE ) == 0 )
  693. {
  694. OnFHNG();
  695. }
  696. }
  697. }
  700. //////////////////////////////////////////////////////////////////////
  701. // Phase D - post-page messages
  702. //////////////////////////////////////////////////////////////////////
  703. void CClassTwo::PhaseD(void)
  704. {
  705. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  706. {
  707. if( m_bLastPageGood )
  708. {
  709. if( m_FaxFile.MorePages() )
  710. {
  711. DoWrite( CLASSTWO_DT, CLASSTWO_DT_SIZE, true );
  712. SetState( STATE_PHASE_C );
  714. if( m_FaxFile.ReadNextHeader() == false )
  715. {
  716. m_sLastError.assign( (char*)LoadString(GEN_ERROR_READING_TIFF_FILE).c_str() );
  717. //SignalEvent( EVENT_ERROR );
  718. Terminate();
  719. SetState( STATE_PHASE_E, STATE_WAIT_FOR_OK );
  720. }
  721. else
  722. {
  723. if( m_FaxFile.ReadPage( false, 0, m_wMinLineChars, false, true ) == false )
  724. {
  725. m_sLastError.assign( (char*)LoadString(GEN_ERROR_READING_TIFF_FILE).c_str() );
  726. //SignalEvent( EVENT_ERROR );
  727. Terminate();
  728. SetState( STATE_PHASE_E, STATE_WAIT_FOR_OK );
  729. }
  730. }
  731. }
  732. else
  733. {
  734. m_FaxFile.IncrementPageCount();
  735. m_bSuccessful = true;
  736. DoWrite( CLASSTWO_FK, CLASSTWO_FK_SIZE, true );
  737. SetState( STATE_PHASE_E, STATE_WAIT_FOR_FK_RESP );
  738. KillTimer( TIMER_MAXPAGERETRIES );
  739. }
  740. }
  741. else
  742. {
  743. DoWrite( CLASSTWO_DT, CLASSTWO_DT_SIZE, true );
  744. SetState( STATE_PHASE_C );
  745. }
  747. m_bLastPageGood = false;
  748. }
  749. else if( strnicmp( m_szLineBuff, CLASSTWO_PTS, CLASSTWO_PTS_SIZE ) == 0 )
  750. {
  751. OnFPTS();
  752. }
  753. else if( strnicmp( m_szLineBuff, CLASSTWO_HNGUP, CLASSTWO_HNGUP_SIZE ) == 0 )
  754. {
  755. OnFHNG();
  756. }
  757. }
  759. //////////////////////////////////////////////////////////////////////
  760. // Phase E - Disconnect
  761. //////////////////////////////////////////////////////////////////////
  762. void CClassTwo::PhaseE(void)
  763. {
  764. switch( m_nPhaseState )
  765. {
  766. case STATE_WAIT_FOR_OK:
  767. if( strnicmp( m_szLineBuff, "OK", 2 ) == 0 )
  768. {
  769. DoWrite( CLASSTWO_FK, CLASSTWO_FK_SIZE, true );
  770. m_nPhaseState = STATE_WAIT_FOR_FK_RESP;
  771. }
  772. else if( strnicmp( m_szLineBuff, CLASSTWO_HNGUP, CLASSTWO_HNGUP_SIZE ) == 0 )
  773. {
  774. OnFHNG();
  775. }
  776. break;
  778. case STATE_WAIT_FOR_FK_RESP:
  779. Terminate();
  780. if( strnicmp( m_szLineBuff, "NO CARRIER", 2 ) == 0 )
  781. {
  782. PhaseDisconnect();
  783. }
  784. else
  785. {
  786. DoHangup();
  787. }
  788. break;
  789. }
  790. }
  793. //////////////////////////////////////////////////////////////////////
  794. // OnSendFaxMsg
  795. //////////////////////////////////////////////////////////////////////
  796. void CClassTwo::OnSendFaxMsg(MSG* pMsg)
  797. {
  798. CModem::OnSendFaxMsg( pMsg );
  800. if( !m_bConnected )
  801. {
  802. // Error!
  803. return;
  804. }
  806. if( m_nState != STATE_IDLE )
  807. {
  808. // Error!
  809. return;
  810. }
  812. m_FaxFile.SetSendEncoding( m_nSendEncoding );
  814. int nRet = m_FaxFile.ReadFirstHeader();
  816. if( nRet == 1 )
  817. {
  818. //OutputDebugString( "Error reading first headern" );
  819. m_sLastError.assign( (char*)LoadString(GEN_ERROR_READING_TIFF_FILE).c_str() );
  820. //SignalEvent( EVENT_ERROR );
  821. SignalEvent( EVENT_TERMINATE );
  822. SignalEvent( EVENT_IDLE );
  823. return;
  824. }
  825. else if( nRet == 2 )
  826. {
  827. //OutputDebugString( "Error reading first headern" );
  828. m_sLastError.assign( (char*)LoadString(GEN_ERROR_INCOMPAT_TIFF_FILE).c_str() );
  829. //SignalEvent( EVENT_ERROR );
  830. SignalEvent( EVENT_TERMINATE );
  831. SignalEvent( EVENT_IDLE );
  832. return;
  833. }
  835. m_bReceiving = false;
  836. m_bHDLCMode = false;
  837. m_bSuccessful = false;
  838. SetState( STATE_PHASE_A, STATE_SET_PARAMS );
  840. EnableSoftFlowControl( true );
  842. m_nScanTime = 0;
  844. m_DISParams.p.BitRate = m_nSendBaud;
  845. m_DISParams.p.PageLength = 2;
  847. SetFaxParams( true );
  848. }
  851. void CClassTwo::OnRecvFaxMsg(MSG* pMsg)
  852. {
  853. CModem::OnRecvFaxMsg( pMsg );
  855. if( m_nState == STATE_IDLE || m_nState == STATE_RINGING )
  856. {
  857. EnableSoftFlowControl( false );
  859. m_FaxFile.Clear();
  861. m_FaxFile.SetSendEncoding( m_nSendEncoding );
  863. m_bReceiving = true;
  864. m_bSuccessful = false;
  866. SetState( STATE_PHASE_A, STATE_SET_CSID );
  867. SetLocalID();
  868. }
  869. }
  872. //////////////////////////////////////////////////////////////////////
  873. // Handle wait timeout - do periodic processing
  874. //////////////////////////////////////////////////////////////////////
  875. bool CClassTwo::OnWaitTimeout( void )
  876. {
  877. CModem::OnWaitTimeout();
  878. /*
  879. if( m_nState == STATE_INIT )
  880. {
  881. DWORD dwElapsed = GetTickCount() - m_nLastCommandTickCount;
  883. // In case the modem doesn't respond with an OK
  884. if( dwElapsed > 1000 )
  885. {
  886. if( m_nLastCommand == COMMAND_QUERY_SEND_SPEEDS )
  887. {
  888. SendCommand( COMMAND_QUERY_RECEIVE_SPEEDS );
  889. }
  890. else if( m_nLastCommand == COMMAND_QUERY_RECEIVE_SPEEDS )
  891. {
  892. SetState( STATE_IDLE );
  893. }
  894. }
  896. if( dwElapsed > 4000 )
  897. {
  898. char szMsg[256];
  899. wsprintf( szMsg, "Timeout: %d ms waiting for responsen", dwElapsed );
  900. //OutputDebugString( szMsg );
  902. OnDisconnectMsg();
  903. }
  904. }
  905. */
  906. return false;
  907. }
  910. void CClassTwo::SetState( int nNewState, int nNewPhaseState )
  911. {
  912. /*
  913. bool bSignalIt = false;
  915. if( m_nState != nNewState )
  916. {
  917. bSignalIt = true;
  918. }
  919. */
  921. m_nState = nNewState;
  922. m_nPhaseState = nNewPhaseState;
  924. if( nNewState == STATE_IDLE )
  925. {
  926. SignalEvent( EVENT_IDLE );
  927. }
  928. }
  931. void CClassTwo::Abort( bool bUserCancelled )
  932. {
  933. char endofframe[2] = { DLE, ETX };
  934. char byteCancel = CAN;
  936. if( bUserCancelled ) 
  937. {
  938. m_sLastError.assign(  (char*)LoadString(GEN_FAX_CANCELLED).c_str() );
  939. }
  941. Terminate();
  943. switch( m_nState )
  944. {
  945. case STATE_PHASE_A:
  946. switch( m_nPhaseState )
  947. {
  948. case STATE_SET_PARAMS:
  949. case STATE_SET_CSID:
  950. SetState( STATE_PHASE_E, STATE_WAIT_FOR_FK_RESP );
  951. break;
  953. case STATE_DIALING:
  954. DoWrite( &byteCancel, 1, false );
  955. SetState( STATE_PHASE_E, STATE_WAIT_FOR_FK_RESP );
  956. break;
  957. }
  958. break;
  960. case STATE_PHASE_B:
  961. SetState( STATE_PHASE_E, STATE_WAIT_FOR_OK );
  962. break;
  964. case STATE_PHASE_C:
  965. if ( m_bReceiving )
  966. {
  967. DoWrite( &byteCancel, 1, false );
  968. SetState( STATE_PHASE_E, STATE_WAIT_FOR_OK );
  969. m_bHDLCMode = false;
  970. }
  971. else
  972. {
  973. DoWrite( endofframe, 2, false );
  974. SetState( STATE_PHASE_E, STATE_WAIT_FOR_OK );
  975. }
  976. break;
  978.   case STATE_PHASE_D:
  979. SetState( STATE_PHASE_E, STATE_WAIT_FOR_OK );
  980. break;
  982.     //case STATE_PHASE_E:
  983. // break;
  984. }
  985. }
  989. void CClassTwo::SetLocalID( void )
  990. {
  991. char szCmdBuff[256];
  993. wsprintf( szCmdBuff, CLASSTWO_SETID, m_sLocalCSID.c_str() );
  995. SendCommand( COMMAND_SET_LOCAL_ID, szCmdBuff );
  996. }
  999. void CClassTwo::SetRecv(void)
  1000. {
  1001. char szCmdBuff[256];
  1003. wsprintf( szCmdBuff, CLASSTWO_SETRECV, m_bEnableReceive ? 1 : 0 );
  1006. SendCommand( COMMAND_SET_RECV, szCmdBuff );
  1007. }
  1009. void CClassTwo::SetBitOrder(void)
  1010. {
  1011. SendCommand( COMMAND_SET_BIT_ORDER, CLASSTWO_SETBOR );
  1012. }
  1015. void CClassTwo::SetFaxParams( bool bSending )
  1016. {
  1017. char szCmdBuff[256];
  1019. m_DCSParams.p.VertRes = m_bFineSupported ? 1 : 0;
  1020. m_DCSParams.p.BitRate = m_nRecvBaud;
  1021. m_DCSParams.p.PageWidth = 0;
  1022. m_DCSParams.p.PageLength = m_bUnlimitedSupported ? 2 : 0;
  1023. m_DCSParams.p.DataFormat = m_FaxFile.GetSendEncoding();
  1024. m_DCSParams.p.ECM = m_bECMSupported ? 2 : 0;
  1026. // TODO: Check if ECM enabled for modem and maximum bit rate
  1028. if( bSending )
  1029. {
  1030. if( m_DISParams.p.BitRate > m_nSendBaud )
  1031. {
  1032. m_DCSParams.p.BitRate = m_nSendBaud;
  1033. }
  1034. else
  1035. {
  1036. m_DCSParams.p.BitRate = m_DISParams.p.BitRate;
  1037. }
  1039. if( m_FaxFile.IsHiRes() == false )
  1040. {
  1041. m_DCSParams.p.VertRes = 0;
  1042. }
  1043. if( m_DISParams.p.PageLength == 0 )
  1044. {
  1045. m_DCSParams.p.PageLength = 0;
  1046. }
  1047. }
  1049. wsprintf( szCmdBuff, CLASSTWO_SETPARAMS,
  1050.       m_DCSParams.p.VertRes, // resolution
  1051.   m_DCSParams.p.BitRate, // bit rate
  1052.   m_DCSParams.p.PageWidth, // page width
  1053.   m_DCSParams.p.PageLength, // page length
  1054.   m_DCSParams.p.DataFormat, // format
  1055.   m_DCSParams.p.ECM,  // error checking
  1056.   m_nScanTime );
  1058. SendCommand( COMMAND_SET_FAX_PARAMS, szCmdBuff );
  1059. }
  1062. void CClassTwo::OnDIS(void)
  1063. {
  1064. ParseFaxParams( 8, m_DISParams.n );
  1066. m_bGotDIS = true;
  1067. m_bResendFaxParams = false;
  1069. m_nScanTime = m_DISParams.p.ScanTime;
  1071. if( m_DISParams.p.ScanTime > 0 )
  1072. {
  1073. m_bResendFaxParams = true;
  1074. }
  1076. /*
  1077. if(    (m_DISParams.p.DataFormat != FAXAPI_ENC_CCITT_1D)
  1078. && (m_DISParams.p.DataFormat < m_nSendEncoding ) )
  1079. {
  1080. //
  1081. //OutputDebugString( "Need to re-set fax parameters!n" );
  1082. m_bResendFaxParams = true;
  1084. m_FaxFile.SetSendEncoding( FAXAPI_ENC_CCITT_1D );
  1085. }
  1086. // else if( m_DISParams.p.BitRate > 0 )
  1087. // {
  1088. // m_bResendFaxParams = true;
  1089. // }
  1090. */
  1092. SignalEvent( EVENT_RECV_DIS );
  1093. }
  1095. void CClassTwo::OnDCS(void)
  1096. {
  1097. m_bGotDCS = true;
  1099. ParseFaxParams( 8, m_DCSParams.n );
  1101. if( m_bReceiving )
  1102. {
  1103. m_FaxFile.SetImageRes( m_DCSParams.p.VertRes != 0 );
  1105. switch( m_DCSParams.p.PageWidth )
  1106. {
  1107. case 1:
  1108. m_FaxFile.SetImageWidth( 2048 );
  1109. break;
  1111. case 2:
  1112. m_FaxFile.SetImageWidth( 2432 );
  1113. break;
  1115. case 3:
  1116. m_FaxFile.SetImageWidth( 1216 );
  1117. break;
  1119. case 4:
  1120. m_FaxFile.SetImageWidth( 864 );
  1121. break;
  1123. default:
  1124. m_FaxFile.SetImageWidth( 1728 );
  1125. break;
  1126. }
  1128. switch( m_DCSParams.p.DataFormat )
  1129. {
  1130. case FAXAPI_ENC_CCITT_2D: // 2D modified Read
  1131. m_FaxFile.SetImageCompression( 3 );
  1132. m_FaxFile.SetT4Options( 0x01 );
  1133. break;
  1135. case FAXAPI_ENC_CCITT_UNC: // 2D uncompressed
  1136. m_FaxFile.SetImageCompression( 3 );
  1137. m_FaxFile.SetT4Options( 0 );
  1138. break;
  1140. case FAXAPI_ENC_CCITT_T6: // T.6
  1141. m_FaxFile.SetImageCompression( 4 );
  1142. m_FaxFile.SetT4Options( 0 );
  1143. break;
  1145. default: // CFaxFile::CCITT_1D = 1D modified huffman
  1146. m_FaxFile.SetImageCompression( 3 );
  1147. m_FaxFile.SetT4Options( 0 );
  1148. break;
  1149. }
  1151. SignalEvent( EVENT_RECV_DCS );
  1152. m_FaxFile.SetImageLength( 0 );
  1153. }
  1154. else
  1155. {
  1156. // TODO: What if we get multiple DCS (e.g. training failed)
  1157. int nBaud = Cls2FaxParamBitRates[m_DCSParams.p.BitRate];
  1158. int nScanTimeMs = (m_DCSParams.p.VertRes == 0) ? 
  1159.   Cls2ScanTimes_normal[ m_DCSParams.p.ScanTime ] :
  1160.               Cls2ScanTimes_fine[ m_DCSParams.p.ScanTime ];
  1161. m_wMinLineChars = ((nBaud/8) * nScanTimeMs)/1000;
  1163. m_FaxFile.SelectEncoding( m_DCSParams.p.DataFormat );
  1165. SignalEvent( EVENT_SENT_DCS );
  1167. if( m_FaxFile.ReadPage( false, 0, m_wMinLineChars, false, true ) == false )
  1168. {
  1169. m_sLastError.assign( (char*)LoadString(GEN_ERROR_READING_TIFF_FILE).c_str() );
  1170. //SignalEvent( EVENT_ERROR );
  1171. Terminate();
  1172. SetState( STATE_PHASE_E, STATE_WAIT_FOR_OK );
  1173. }
  1174. }
  1177. }
  1179. void CClassTwo::OnCSI(void)
  1180. {
  1181. char szID[21];
  1182. int i = 0;
  1183. bool bNoQuotes = false;
  1185. m_sRemoteCSID = "";
  1187. //OutputDebugString( "OnCSIn" );
  1189. char* p = m_szLineBuff + 5; // skip +FTSI
  1191. if ( *p == ':' ) // skip the colon
  1192. {
  1193. p++;
  1194. }
  1196. while (*p && *p != '"' ) // skip white space before first quote
  1197. {
  1198. p++;
  1199. }
  1201. if( *p == 0 )
  1202. {
  1203. bNoQuotes = true;
  1205. // Uh-oh! no quotes found, back up and try w/o quotes
  1206. p = m_szLineBuff + 5;
  1208. if ( *p == ':' ) // skip the colon
  1209. {
  1210. p++;
  1211. }
  1213. while (*p && *p == ' ' ) // skip white space
  1214. {
  1215. p++;
  1216. }
  1218. return;
  1219. }
  1220. else
  1221. {
  1222. p++; // skip first quote
  1223. }
  1225. while( *p && (*p != '"') && (i < 20) )
  1226. {
  1227. szID[i] = *p;
  1228. p++;
  1229. i++;
  1230. }
  1232. szID[i] = 0;
  1234. m_sRemoteCSID.assign( szID );
  1236. SignalEvent( EVENT_GOT_REMOTEID );
  1237. }
  1239. void CClassTwo::OnNSF(void)
  1240. {
  1241. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_NSF).c_str() );
  1242. }
  1244. void CClassTwo::OnNSS(void)
  1245. {
  1246. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_NSS).c_str() );
  1247. }
  1249. // Page Status Report
  1250. void CClassTwo::OnFPTS(void)
  1251. {
  1252. int n[2];
  1254. // OutputDebugString( "OnFPTSn" );
  1256. int nParams = ParseFaxParams( 2, n );
  1258. if( nParams > 0 )
  1259. {
  1260. switch( n[0] )
  1261. {
  1262. case 1:
  1263. if( m_bReceiving )
  1264. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_SENT_MCF).c_str() );
  1265. else
  1266. {
  1267. m_bLastPageGood = true;
  1268. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_MCF).c_str() );
  1269. }
  1270. break;
  1271. case 2:
  1272. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_RTN).c_str() );
  1273. m_bLastPageGood = false;
  1274. break;
  1275. case 3:
  1276. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_RTP).c_str() );
  1277. m_bLastPageGood = true;
  1278. break;
  1279. case 4:
  1280. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_PIN).c_str() );
  1281. m_bLastPageGood = true;
  1282. break;
  1283. case 5:
  1284. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_PIP).c_str() );
  1285. m_bLastPageGood = true;
  1286. break;
  1287. }
  1288. }
  1290. //if( nParams > 1 )
  1291. //{
  1292. // m_FaxFile.SetImageLength( n[1] );
  1293. //}
  1294. }
  1297. void CClassTwo::OnFET(void)
  1298. {
  1299. int n;
  1301. //OutputDebugString( "OnFETn" );
  1303. ParseFaxParams( 1, &n );
  1305. switch( n )
  1306. {
  1307. case 0:
  1308. OnMPS();
  1309. break;
  1311. case 1:
  1312. OnEOM();
  1313. break;
  1315. case 2:
  1316. OnEOP();
  1317. break;
  1318. }
  1319. }
  1322. void CClassTwo::OnEOP(void)
  1323. {
  1324. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_EOP).c_str() );
  1325. m_bGotEOP = true;
  1326. }
  1328. void CClassTwo::OnEOM(void)
  1329. {
  1330. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_EOM).c_str() );
  1331. m_bGotEOM = true;
  1332. }
  1334. void CClassTwo::OnMPS(void)
  1335. {
  1336. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_MPS).c_str() );
  1337. m_bGotMPS = true;
  1338. }
  1341. void CClassTwo::OnFHNG( void )
  1342. {
  1343. int n;
  1345. //OutputDebugString( "OnFHNGn" );
  1347. ParseFaxParams( 1, &n );
  1349. // char szCode[32];
  1350. // wsprintf( szCode, "==> %dn", n );
  1351. // OutputDebugString( szCode );
  1353. switch( n )
  1354. {
  1355. case 0:
  1356. m_bSuccessful = true;
  1357. if( !m_bReceiving )
  1358. {
  1359. m_FaxFile.IncrementPageCount();
  1360. }
  1361. break;
  1363. case 1:
  1364. m_sLastError.assign( (char*)LoadString(GEN_CALL_ANSWERED_WO_FAX_HANDSHAKE).c_str() );
  1365. break;
  1367. case 2:
  1368. m_sLastError.assign( (char*)LoadString(GEN_CALL_ABORTED_BY_USER).c_str() );
  1369. break;
  1371. case 3:
  1372. m_sLastError.assign( (char*)LoadString(GEN_NO_LOOP_CURRENT).c_str() );
  1373. break;
  1375. case 10:
  1376. m_sLastError.assign( (char*)LoadString(GEN_UNSPECIFIED_PHASE_A_ERROR).c_str() );
  1377. break;
  1379. case 11:
  1380. m_sLastError.assign( (char*)LoadString(GEN_NO_ANSWER_OR_NO_DIS).c_str() );
  1381. break;
  1383. case 20:
  1384. m_sLastError.assign( (char*)LoadString(GEN_UNSPECIFIED_PHASE_B_TRANSMIT_ERROR).c_str() );
  1385. break;
  1387. case 21:
  1388. m_sLastError.assign( (char*)LoadString(GEN_REMOTE_CANNOT_RECEIVE_OR_SEND).c_str() );
  1389. break;
  1391. case 22:
  1392. m_sLastError.assign( (char*)LoadString(GEN_PHASE_B_TRANSMIT_COMMAND_FRAME_ERROR).c_str() );
  1393. break;
  1395. case 23:
  1396. m_sLastError.assign( (char*)LoadString(GEN_PHASE_B_TRANSMIT_INVALID_COMMAND_RECEIVED).c_str() );
  1397. break;
  1399. case 24:
  1400. m_sLastError.assign( (char*)LoadString(GEN_PHASE_B_TRANSMIT_RESPONSE_FRAME_ERROR).c_str() );
  1401. break;
  1403. case 25:
  1404. m_sLastError.assign( (char*)LoadString(GEN_DCS_SENT_THREE_TIMES_WITHOUT_RESPONSE).c_str() );
  1405. break;
  1407. case 26:
  1408. m_sLastError.assign( (char*)LoadString(GEN_DISDTC_RECEIVED_3_TIMES_DCS_NOT_RECOGNISED).c_str() );
  1409. break;
  1411. case 27:
  1412. m_sLastError.assign( (char*)LoadString(GEN_FAILURE_TO_TRAIN_AT_2400_BPS).c_str() );
  1413. break;
  1415. case 28:
  1416. m_sLastError.assign( (char*)LoadString(GEN_PHASE_B_TRANSMIT_INVALID_RESPONSE_RECEIVED).c_str() );
  1417. break;
  1419. case 40:
  1420. m_sLastError.assign( (char*)LoadString(GEN_UNSPECIFIED_PHASE_C_TRANSMIT_ERROR).c_str() );
  1421. break;
  1423. case 43:
  1424. m_sLastError.assign( (char*)LoadString(GEN_DTE_TO_DCE_DATA_UNDERFLOW).c_str() );
  1425. break;
  1427. case 50:
  1428. m_sLastError.assign( (char*)LoadString(GEN_UNSPECIFIED_PHASE_D_TRANSMIT_ERROR).c_str() );
  1429. break;
  1431. case 51:
  1432. m_sLastError.assign( (char*)LoadString(GEN_PHASE_D_TRANSMIT_RESPONSE_FRAME_ERROR).c_str() );
  1433. break;
  1435. case 52:
  1436. m_sLastError.assign( (char*)LoadString(GEN_NO_RESPONSE_TO_MPS_REPEATED_3_TIMES).c_str() );
  1437. break;
  1439. case 53:
  1440. m_sLastError.assign( (char*)LoadString(GEN_INVALID_RESPONSE_TO_MPS).c_str() );
  1441. break;
  1443. case 54:
  1444. m_sLastError.assign( (char*)LoadString(GEN_NO_RESPONSE_TO_EOP_REPEATED_3_TIMES).c_str() );
  1445. break;
  1447. case 55:
  1448. m_sLastError.assign( (char*)LoadString(GEN_INVALID_RESPONSE_TO_EOP).c_str() );
  1449. break;
  1451. case 56:
  1452. m_sLastError.assign( (char*)LoadString(GEN_NO_RESPONSE_TO_EOM_REPEATED_3_TIMES).c_str() );
  1453. break;
  1455. case 57:
  1456. m_sLastError.assign( (char*)LoadString(GEN_INVALID_RESPONSE_TO_EOM).c_str() );
  1457. break;
  1459. case 58:
  1460. m_sLastError.assign( (char*)LoadString(GEN_UNABLE_TO_CONTINUE_AFTER_PIN_OR_PIP).c_str() );
  1461. break;
  1463. case 70:
  1464. m_sLastError.assign( (char*)LoadString(GEN_UNSPECIFIED_PHASE_B_RECEIVE_ERROR).c_str() );
  1465. break;
  1467. case 71:
  1468. m_sLastError.assign( (char*)LoadString(GEN_PHASE_B_RECEIVE_RESPONSE_FRAME_ERROR).c_str() );
  1469. break;
  1471. case 72:
  1472. m_sLastError.assign( (char*)LoadString(GEN_PHASE_B_RECEIVE_COMMAND_FRAME_ERROR).c_str() );
  1473. break;
  1475. case 73:
  1476. m_sLastError.assign( (char*)LoadString(GEN_T30_T2_TIMEOUT).c_str() );
  1477. break;
  1479. case 74:
  1480. m_sLastError.assign( (char*)LoadString(GEN_FAILURE_TO_RESUME_PHASE_B_AFTER_EOM).c_str() );
  1481. break;
  1483. case 90:
  1484. m_sLastError.assign( (char*)LoadString(GEN_UNSPECIFIED_PHASE_C_RECEIVE_ERROR).c_str() );
  1485. break;
  1487. case 91:
  1488. m_sLastError.assign( (char*)LoadString(GEN_MISSING_EOL_AFTER_5_SEC).c_str() );
  1489. break;
  1491. case 93:
  1492. m_sLastError.assign( (char*)LoadString(GEN_MODEM_RECEIVE_BUFFER_OVERFLOWED).c_str() );
  1493. break;
  1495. case 94:
  1496. m_sLastError.assign( (char*)LoadString(GEN_CRC_OR_FRAME_ERROR_IN_ECM_MODE).c_str() );
  1497. break;
  1499. case 100:
  1500. m_sLastError.assign( (char*)LoadString(GEN_UNSPECIFIED_PHASE_D_RECEIVE_ERROR).c_str() );
  1501. break;
  1503. case 101:
  1504. m_sLastError.assign( (char*)LoadString(GEN_PHASE_D_RECEIVE_RESPONSE_FRAME_ERROR).c_str() );
  1505. break;
  1507. case 102:
  1508. m_sLastError.assign( (char*)LoadString(GEN_PHASE_D_RECEIVE_COMMAND_FRAME_ERROR).c_str() );
  1509. break;
  1511. case 103:
  1512. m_sLastError.assign( (char*)LoadString(GEN_UNABLE_TO_CONTINUE_AFTER_PIN_OR_PIP).c_str() );
  1513. break;
  1515. default:
  1516. m_sLastError.assign( (char*)LoadString(GEN_UNSPECIFIED_ERROR).c_str() );
  1517. break;
  1518. }
  1521. SetState( STATE_PHASE_E, STATE_WAIT_FOR_FK_RESP );
  1522. }
  1524. void CClassTwo::OnHDLCFrame(void)
  1525. {
  1526. //OutputDebugString( "OnHDLCFramen" );
  1528. if( m_nHDLCBuffPtr == 0 )
  1529. {
  1530. //OutputDebugString( "Empty HDLC Framen" );
  1531. return;
  1532. }
  1534. if( m_nState == STATE_PHASE_C && m_bReceiving )
  1535. {
  1536. m_FaxFile.WriteBuffer( m_szHDLCBuff, m_nHDLCBuffPtr, false );
  1537. }
  1538. }
  1540. void CClassTwo::OnPartialHDLCFrame(void)
  1541. {
  1542. //OutputDebugString( "OnPartialHDLCFramen" );
  1544. if( m_nState == STATE_PHASE_C && m_bReceiving )
  1545. {
  1546. if( m_bFirstFrame )
  1547. {
  1548. m_bFirstFrame = false;
  1550. if( m_szHDLCBuff[0] == XON )
  1551. {
  1552. //OutputDebugString( "Skipping XONn" );
  1553. m_FaxFile.WriteBuffer( m_szHDLCBuff+1, m_nHDLCBuffPtr-1, false );
  1554. }
  1555. else
  1556. {
  1557. m_FaxFile.WriteBuffer( m_szHDLCBuff, m_nHDLCBuffPtr, false );
  1558. }
  1559. }
  1560. else
  1561. {
  1562. m_FaxFile.WriteBuffer( m_szHDLCBuff, m_nHDLCBuffPtr, false );
  1563. }
  1564. }
  1565. else
  1566. {
  1567. //OutputDebugString( "HDLC buffer overflow!n" );
  1568. }
  1569. }
  1571. /*
  1572. int CClassTwo::ParseFaxParams( int nMaxParams )
  1573. {
  1574. char szNumBuff[21];
  1575. int* pParams = (int*)&m_Params;
  1576. int j;
  1577. int i;
  1579. ZeroMemory( &m_Params, sizeof(m_Params) );
  1581. char* p = m_szLineBuff + 5; // Skip +XXXX
  1583. if ( *p == ':' ) // skip the colon
  1584. {
  1585. p++;
  1586. }
  1588. // advance to first digit
  1589. while( *p && (*p < '0') && (*p > '9') && (*p != ',') )
  1590. {
  1591. p++;
  1592. }
  1594. for( i = 0; i < nMaxParams; i++ )
  1595. {
  1596. // check for end of string
  1597. if( *p == '' )
  1598. {
  1599. return i;
  1600. }
  1602. j = 0;
  1604. // advance to next comma
  1605. while( *p && (*p >='0') && (*p <= '9') && (j < 20) )
  1606. {
  1607. szNumBuff[j++] = *p++;
  1608. }
  1610. szNumBuff[j] = '';
  1612. pParams[i] = atoi( szNumBuff );
  1614. if( *p ) // advance past comma
  1615. p++;
  1616. }
  1618. return i;
  1619. }
  1620. */
  1622. void CClassTwo::OnTimer( UINT nID )
  1623. {
  1624. //OutputDebugString( "CClassTwo::OnTimern" );
  1626. if( nID == TIMER_COMMAND )
  1627. {
  1628. switch( m_nLastCommand )
  1629. {
  1630. case COMMAND_QUERY_SEND_SPEEDS:
  1631. SendCommand( COMMAND_QUERY_RECEIVE_SPEEDS );
  1632. break;
  1634. case COMMAND_QUERY_RECEIVE_SPEEDS:
  1635. SetLocalID();
  1636. break;
  1638. case COMMAND_HANGUP:
  1639. SetState( STATE_INIT );
  1640. SendCommand( COMMAND_INIT );
  1641. m_nLoopCtr = 0; 
  1642. break;
  1644. default:
  1645. if( m_bGotOK )
  1646. {
  1647. m_nLoopCtr = 0;
  1648. KillTimer( TIMER_COMMAND );
  1649. SendCommand( COMMAND_SETUP_STRING );
  1650. }
  1651. else
  1652. {
  1653. if( ++m_nLoopCtr >= 3 )
  1654. {
  1655. KillTimer( TIMER_COMMAND );
  1656. m_sLastError.assign( (char*)LoadString(GEN_NO_RESPONSE_FROM_MODEM).c_str() );
  1657. OnDisconnectMsg();
  1658. }
  1659. else
  1660. {
  1661. SendCommand( m_nLastCommand, (char*) m_LastCommandString.c_str() );
  1662. }
  1663. }
  1664. break;
  1665. }
  1666. }
  1667. }
  1671. void CClassTwo::OnAbortFaxMsg(void)
  1672. {
  1673. Abort( true );
  1674. }
  1676. void CClassTwo::VerifyOptions(void)
  1677. {
  1678. bool bModemFine = m_ParamMatrix[0][1] ? true : false;
  1679. bool bModemUnlimited = m_ParamMatrix[3][2] ? true : false;
  1680. int nModemCompression = m_ParamMatrix[4][3] ? 3 : (m_ParamMatrix[4][1] ? 1 : 0 );
  1681. bool bModemECM = m_ParamMatrix[5][2]  ? true : false;
  1683. if( nModemCompression < m_nSendEncoding )
  1684. {
  1685. char szMsg[FAXAPI_MODEMMSG_INFOLEN];
  1687. wsprintf( szMsg,(char*)LoadString(GEN_FORMAT_UNSUPPORTED_IN_CLASS_2).c_str(), 
  1688.  (m_nSendEncoding==3) ? "2D Group 4" : (m_nSendEncoding == 1 ? "2D Group 3" : "1D Group 3" ),
  1689.  (nModemCompression==3) ? "2D Group 4" : (nModemCompression == 1 ? "2D Group 3" : "1D Group 3" ) );
  1691. SetSendEncoding( nModemCompression );
  1693. SignalEventString( EVENT_INFO, szMsg );
  1694. }
  1696. if( !bModemECM && m_bECMSupported )
  1697. {
  1698. SetSendECM( false );
  1699. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_ECM_UNSUPPORTED_IN_CLASS_2).c_str() );
  1700. }
  1702. SetSendFine( bModemFine );
  1704. SetSendUnlimited( bModemUnlimited );
  1705. }
  1708. void CClassTwo::CheckTimeouts( DWORD dwInActive )
  1709. {
  1710. switch( m_nState )
  1711. {
  1712. case STATE_PHASE_A:
  1713. if( dwInActive > 90000 )
  1714. {
  1715. m_sLastError.assign( (char*)LoadString(GEN_TIMEOUT_CONNECTING_TO_REMOTE_FAX).c_str()  );
  1716. //SignalEvent( EVENT_ERROR );
  1717. Abort( false );
  1718. m_dwActivityTimer = GetTickCount();
  1719. }
  1720. break;
  1722. case STATE_PHASE_E:
  1723. if( dwInActive > 5000 )
  1724. {
  1725. Terminate();
  1726. PhaseDisconnect();
  1727. }
  1728. break;
  1730. case STATE_DISCONNECT:
  1731. if( dwInActive > 1000 )
  1732. {
  1733. PhaseDisconnect();
  1734. }
  1735. break;
  1737. default:
  1738. if( m_nState > STATE_IDLE && m_nState != STATE_RINGING )
  1739. {
  1740. int nInActive = GetTickCount() - m_dwActivityTimer;
  1742. if( nInActive > 60000 )
  1743. {
  1744. m_sLastError.assign(  (char*)LoadString(GEN_TIMEOUT_IN_SENDRECEIVE).c_str() );
  1745. //SignalEvent( EVENT_ERROR );
  1747. Abort( false );
  1748. m_dwActivityTimer = GetTickCount();
  1749. }
  1750. }
  1751. break;
  1752. }
  1753. }