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

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

传真(Fax)编程

开发平台：

Visual C++

ClassTwoPointZero.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 CClassTwoPointZero is contain the protocol specifics of EIA
  20. // fax modem class 2.0
  21. //
  22. ////////////////////////////////////////////////////////////////////////////////
  24. #include "stdafx.h"
  25. #include "ClassTwoPointZero.h"
  27. #define CLASSTWO_CONNECT "+FCO"
  28. #define CLASSTWO_CONNECT_SIZE 4
  29. #define CLASSTWO_TSI "+FTI"
  30. #define CLASSTWO_TSI_SIZE 4
  31. #define CLASSTWO_DCS "+FCS"
  32. #define CLASSTWO_DCS_SIZE 4
  33. #define CLASSTWO_NSS "+FNS"
  34. #define CLASSTWO_NSS_SIZE 4
  35. #define CLASSTWO_HNGUP "+FHS"
  36. #define CLASSTWO_HNGUP_SIZE 4
  37. #define CLASSTWO_CSI "+FCI"
  38. #define CLASSTWO_CSI_SIZE 4
  39. #define CLASSTWO_DIS "+FIS"
  40. #define CLASSTWO_DIS_SIZE 4
  41. #define CLASSTWO_NSF "+FNF"
  42. #define CLASSTWO_NSF_SIZE 4
  43. #define CLASSTWO_PTS "+FPS"
  44. #define CLASSTWO_PTS_SIZE 4
  45. #define CLASSTWO_ET "+FET"
  46. #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+FKS"
  54. #define CLASSTWO_FK_SIZE 6
  56. #define CLASSTWO_SETID "AT+FLI="%s""
  57. #define CLASSTWO_SETRECV "AT+FCR=%d"
  58. #define CLASSTWO_SETBOR "AT+FBO=0"
  59. #define CLASSTWO_SETPARAMS "AT+FIS=%d,%d,%d,%d,%d,%d,0,%d"
  60. #define CLASSTWO_SENDET "AT+FET=%d"
  61. #define CLASSTWO_SETRPTING "AT+FNR=1,1,1,1"
  64. //////////////////////////////////////////////////////////////////////
  65. // Construction/Destruction
  66. //////////////////////////////////////////////////////////////////////
  68. CClassTwoPointZero::CClassTwoPointZero()
  69. {
  70. m_sEIAClass = "2.0";
  71. m_nScanTime = 0;
  72. }
  74. CClassTwoPointZero::~CClassTwoPointZero()
  75. {
  77. }
  79. void CClassTwoPointZero::OnConnect(void)
  80. {
  81. SetState( STATE_INIT );
  83. m_bGotOK = false;
  85. SendCommand( COMMAND_INIT );
  87. m_nLoopCtr = 0; 
  88. }
  91. bool CClassTwoPointZero::OnDisconnect(void)
  92. {
  93. switch( m_nState )
  94. {
  95. case STATE_INIT:
  96. SignalEvent( EVENT_ERROR );
  97. return true;
  99. case STATE_PHASE_A:
  100. case STATE_PHASE_B:
  101. case STATE_PHASE_C:
  102.   case STATE_PHASE_D:
  103.     case STATE_PHASE_E:
  104. Abort( true );
  105. return false;
  106. }
  108. return true;
  109. }
  111. //////////////////////////////////////////////////////////////////////
  112. // OnWrite
  113. //////////////////////////////////////////////////////////////////////
  114. void CClassTwoPointZero::OnWrite(void)
  115. {
  116. m_dwActivityTimer = GetTickCount();
  118. if( m_nState == STATE_PHASE_C && !m_bReceiving && m_bGotDCS )
  119. {
  120. m_nPageBytes += m_BytesWritten;
  122. int nPercent = 100 * m_nPageBytes / m_FaxFile.GetPageBytes();
  124. if( nPercent > 100 )
  125. nPercent = 100;
  127. SignalEvent( EVENT_PAGE_DATA, nPercent );
  128. }
  129. }
  132. //////////////////////////////////////////////////////////////////////
  133. // OnReadLine
  134. //////////////////////////////////////////////////////////////////////
  135. void CClassTwoPointZero::OnReadLine(void)
  136. {
  137. //char szMsg[256];
  138. //wsprintf( szMsg, "CClassTwoPointZero::OnReadLine: %s %dn", m_szLineBuff, m_nLineBuffPtr );
  139. //OutputDebugString( szMsg );
  141. switch( m_nState )
  142. {
  143. case STATE_IDLE:
  144. PhaseIdle();
  145. break;
  147. case STATE_INIT:
  148. PhaseInit();
  149. break;
  151. case STATE_PHASE_A:
  152. PhaseA();
  153. break;
  155. case STATE_PHASE_B:
  156. PhaseB();
  157. break;
  159. case STATE_PHASE_C:
  160. PhaseC();
  161. break;
  163. case STATE_PHASE_D:
  164. // PhaseD();
  165. break;
  167. case STATE_PHASE_E:
  168. PhaseE();
  169. break;
  171. case STATE_RINGING:
  172. PhaseRinging();
  173. break;
  175. case STATE_DISCONNECT:
  176. PhaseDisconnect();
  177. break;
  178. }
  180. }
  183. //////////////////////////////////////////////////////////////////////
  184. // PhaseInit
  185. //////////////////////////////////////////////////////////////////////
  186. void CClassTwoPointZero::PhaseInit(void)
  187. {
  188. if( stricmp( m_szLineBuff, m_LastCommandString.c_str() ) == 0 )
  189. {
  190. // Echo - ignore
  191. return;
  192. }
  194. if( IsRing() )
  195. {
  196. // RING
  197. m_nRingCount++;
  198. return;
  199. }
  201. switch( m_nLastCommand )
  202. {
  203. case COMMAND_INIT:
  204. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  205. {
  206. m_bGotOK = true;
  207. }
  208. else 
  209. {
  210. if( ++m_nLoopCtr >= 3 )
  211. {
  212. ErrorUnexpectedResponse();
  213. KillTimer( TIMER_COMMAND );
  214. OnDisconnectMsg();
  215. }
  216. }
  217. break;
  219. case COMMAND_SETUP_STRING:
  220. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  221. {
  222. SendCommand( COMMAND_DISABLE_ECHO );
  223. }
  224. else
  225. {
  226. ErrorUnexpectedResponse();
  227. KillTimer( TIMER_COMMAND );
  228. OnDisconnectMsg();
  229. }
  230. break;
  232. case COMMAND_DISABLE_ECHO:
  233. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  234. {
  235. SendCommand( COMMAND_SET_SPKR_VOL );
  236. }
  237. else
  238. {
  239. ErrorUnexpectedResponse();
  240. KillTimer( TIMER_COMMAND );
  241. OnDisconnectMsg();
  242. }
  243. break;
  245. case COMMAND_SET_SPKR_VOL:
  246. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  247. {
  248. SendCommand( COMMAND_SET_SPKR_MODE );
  249. }
  250. else
  251. {
  252. ErrorUnexpectedResponse();
  253. KillTimer( TIMER_COMMAND );
  254. OnDisconnectMsg();
  255. }
  256. break;
  258. case COMMAND_SET_SPKR_MODE:
  259. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  260. {
  261. SendCommand( COMMAND_SET_FCLASS_2_0 );
  262. }
  263. else
  264. {
  265. ErrorUnexpectedResponse();
  266. KillTimer( TIMER_COMMAND );
  267. OnDisconnectMsg();
  268. }
  269. break;
  271. case COMMAND_SET_FCLASS_2_0:
  272. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  273. {
  274. SendCommand( COMMAND_QUERY_CLASS2_0_CAP );
  275. }
  276. else
  277. {
  278. ErrorUnexpectedResponse();
  279. KillTimer( TIMER_COMMAND );
  280. OnDisconnectMsg();
  281. }
  282. break;
  284. case COMMAND_QUERY_CLASS2_0_CAP:
  285. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  286. {
  287. SendCommand( COMMAND_QUERY_SEND_SPEEDS );
  288. }
  289. else if( stricmp( m_szLineBuff, "ERROR" ) == 0 )
  290. {
  291. ErrorUnexpectedResponse();
  292. KillTimer( TIMER_COMMAND );
  293. OnDisconnectMsg();
  294. }
  295. else
  296. {
  297. ProcCapabilities( m_szLineBuff );
  299. VerifyOptions();
  300. }
  301. break;
  303. case COMMAND_QUERY_SEND_SPEEDS:
  304. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  305. {
  306. SendCommand( COMMAND_QUERY_RECEIVE_SPEEDS );
  307. }
  308. else
  309. {
  310. ProcSupportedSpeeds( m_szLineBuff, true );
  311. }
  312. break;
  314. case COMMAND_QUERY_RECEIVE_SPEEDS:
  315. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  316. {
  317. SetLocalID();
  318. }
  319. else
  320. {
  321. ProcSupportedSpeeds( m_szLineBuff, false );
  322. }
  323. break;
  325. case COMMAND_SET_LOCAL_ID:
  326. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  327. {
  328. SetRecv();
  329. }
  330. else
  331. {
  332. ErrorUnexpectedResponse();
  333. KillTimer( TIMER_COMMAND );
  334. OnDisconnectMsg();
  335. }
  336. break;
  338. case COMMAND_SET_RECV:
  339. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  340. {
  341. SetBitOrder();
  342. }
  343. else
  344. {
  345. ErrorUnexpectedResponse();
  346. KillTimer( TIMER_COMMAND );
  347. OnDisconnectMsg();
  348. }
  349. break;
  351. case COMMAND_SET_BIT_ORDER:
  352. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  353. {
  354. SetFlowControl();
  355. }
  356. else
  357. {
  358. ErrorUnexpectedResponse();
  359. KillTimer( TIMER_COMMAND );
  360. OnDisconnectMsg();
  361. }
  362. break;
  364. case COMMAND_SET_FLOW_CONTROL:
  365. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  366. {
  367. SetHDLCReporting();
  368. }
  369. else
  370. {
  371. ErrorUnexpectedResponse();
  372. KillTimer( TIMER_COMMAND );
  373. OnDisconnectMsg();
  374. }
  375. break;
  378. case COMMAND_SET_HDLC_REPORTING:
  379. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  380. {
  381. m_nScanTime = 0;
  382. SetFaxParams( false );
  383. }
  384. else
  385. {
  386. ErrorUnexpectedResponse();
  387. KillTimer( TIMER_COMMAND );
  388. OnDisconnectMsg();
  389. }
  390. break;
  392. case COMMAND_SET_FAX_PARAMS:
  393. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  394. {
  395. SetState( STATE_IDLE );
  396. KillTimer( TIMER_COMMAND );
  397. }
  398. else
  399. {
  400. ErrorUnexpectedResponse();
  401. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_REDUCE_COMPRESSION_BAUD_RATE_OR_DISABLE_ECM).c_str() );
  402. KillTimer( TIMER_COMMAND );
  403. OnDisconnectMsg();
  404. }
  405. break;
  406. }
  407. }
  410. //////////////////////////////////////////////////////////////////////
  411. // PhaseIdle
  412. //////////////////////////////////////////////////////////////////////
  413. void CClassTwoPointZero::PhaseIdle(void)
  414. {
  415. if( IsRing() )
  416. {
  417. m_nRingCount = 1;
  418. SetState( STATE_RINGING );
  420. SignalEvent( EVENT_RING, m_nRingCount );
  421. }
  422. }
  424. //////////////////////////////////////////////////////////////////////
  425. // Phase Ringing
  426. //////////////////////////////////////////////////////////////////////
  427. void CClassTwoPointZero::PhaseRinging(void)
  428. {
  429. if( IsRing() )
  430. {
  431. m_nRingCount++;
  433. SignalEvent( EVENT_RING, m_nRingCount );
  435. /*
  436. if( OkToAnswer() )
  437. {
  438. m_bReceiving = true;
  439. m_bSuccessful = false;
  440. SendCommand( COMMAND_ANSWER );
  441. SetState( STATE_PHASE_B, STATE_RECEIVING );
  442. }
  443. */
  444. }
  445. else if( strnicmp( m_szLineBuff, CLASSTWO_CONNECT, CLASSTWO_CONNECT_SIZE ) == 0 )
  446. {
  447. EnableSoftFlowControl( false );
  448. m_FaxFile.SetSendEncoding( m_nSendEncoding );
  449. m_bReceiving = true;
  450. m_bSuccessful = false;
  451. SignalEvent( EVENT_START_RECV );
  452. SetState( STATE_PHASE_B, STATE_RECEIVING );
  453. }
  454. else
  455. {
  456. SignalEvent( EVENT_CALLERID );
  457. }
  458. }
  461. //////////////////////////////////////////////////////////////////////
  462. // Phase A - call setup
  463. //////////////////////////////////////////////////////////////////////
  464. void CClassTwoPointZero::PhaseA(void)
  465. {
  466. switch( m_nPhaseState )
  467. {
  468. case STATE_SET_PARAMS:
  469. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  470. {
  471. SetLocalID();
  472. m_nPhaseState = STATE_SET_CSID;
  473. }
  474. else
  475. {
  476. // Error setting fax params
  477. m_sLastError.assign( (char*)LoadString(GEN_ERROR_SETTING_FAX_PARAMETERS).c_str()  );
  478. // SignalEvent( EVENT_ERROR );
  479. Terminate();
  480. PhaseDisconnect();
  481. }
  482. break;
  484. case STATE_SET_CSID:
  485. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  486. {
  487. if( m_bReceiving )
  488. {
  489. SendCommand( COMMAND_ANSWER );
  490. SetState( STATE_PHASE_B, STATE_RECEIVING );
  491. }
  492. else
  493. {
  494. SendCommand( COMMAND_DIAL );
  495. m_nPhaseState = STATE_DIALING;
  496. }
  497. }
  498. else
  499. {
  500. // Error setting ID
  501. m_sLastError.assign( (char*)LoadString(GEN_ERROR_SETTING_ID).c_str()  );
  502. // SignalEvent( EVENT_ERROR );
  503. Terminate();
  504. PhaseDisconnect();
  505. }
  506. break;
  508. case STATE_DIALING:
  509. if( strnicmp( m_szLineBuff, CLASSTWO_CONNECT, CLASSTWO_CONNECT_SIZE ) == 0 )
  510. {
  511. m_nLoopCtr = 0;
  512. SetState( STATE_PHASE_B, STATE_SENDING );
  513. SignalEvent( EVENT_START_SEND );
  514. }
  515. else if( strnicmp( m_szLineBuff, CLASSTWO_HNGUP, CLASSTWO_HNGUP_SIZE ) == 0 )
  516. {
  517. OnFHNG();
  518. }
  519. else
  520. {
  521. ErrorConnectResponse();
  522. Terminate();
  523. PhaseDisconnect();
  524. }
  525. break;
  526. }
  527. }
  530. //////////////////////////////////////////////////////////////////////
  531. // Phase B - negotiation and training
  532. //////////////////////////////////////////////////////////////////////
  533. void CClassTwoPointZero::PhaseB(void)
  534. {
  535. switch( m_nPhaseState )
  536. {
  537. case STATE_RECEIVING:
  538. if( strnicmp( m_szLineBuff, "OK", 2 ) == 0 )
  539. {
  540. m_bGotEOP = false;
  541. m_bGotMPS = false;
  542. m_bGotEOM = false;
  544. // On to phase C
  545. DoWrite( CLASSTWO_DR, CLASSTWO_DR_SIZE, true );
  546. SetState( STATE_PHASE_C );
  547. m_FaxFile.WriteFileHeader();
  548. SignalEvent( EVENT_START_TRAINING );
  549. } 
  550. else if( strnicmp( m_szLineBuff, CLASSTWO_CONNECT, CLASSTWO_CONNECT_SIZE ) == 0 )
  551. {
  552. SignalEvent( EVENT_START_RECV );
  553. }
  554. else if( strnicmp( m_szLineBuff, CLASSTWO_TSI, CLASSTWO_TSI_SIZE ) == 0 )
  555. {
  556. OnCSI();
  557. }
  558. else if( strnicmp( m_szLineBuff, CLASSTWO_DCS, CLASSTWO_DCS_SIZE ) == 0 )
  559. {
  560. OnDCS();
  561. }
  562. else if( strnicmp( m_szLineBuff, CLASSTWO_NSS, CLASSTWO_NSS_SIZE ) == 0 )
  563. {
  564. OnNSS();
  565. }
  566. else if( strnicmp( m_szLineBuff, CLASSTWO_HNGUP, CLASSTWO_HNGUP_SIZE ) == 0 )
  567. {
  568. OnFHNG();
  569. }
  570. break;
  572. case STATE_SENDING:
  573. if( strnicmp( m_szLineBuff, "OK", 2 ) == 0 )
  574. {
  575. // Check DIS and re-set parameters if necessar
  576. if( m_bGotDIS && m_bResendFaxParams )
  577. {
  578. SetFaxParams( true );
  579. m_nPhaseState = STATE_RESET_PARAMS;
  580. }
  581. else
  582. {
  583. // On to Phase C
  584. DoWrite( CLASSTWO_DT, CLASSTWO_DT_SIZE, true );
  585. SetState( STATE_PHASE_C );
  586. m_bGotDCS = false;
  587. SignalEvent( EVENT_START_TRAINING );
  588. m_bLastPageGood = false;
  589. }
  590. } 
  591. else if( strnicmp( m_szLineBuff, CLASSTWO_CSI, CLASSTWO_CSI_SIZE ) == 0 )
  592. {
  593. OnCSI();
  594. }
  595. else if( strnicmp( m_szLineBuff, CLASSTWO_DIS, CLASSTWO_DIS_SIZE ) == 0 )
  596. {
  597. OnDIS();
  598. }
  599. else if( strnicmp( m_szLineBuff, CLASSTWO_NSF, CLASSTWO_NSF_SIZE ) == 0 )
  600. {
  601. OnNSF();
  602. }
  603. else if( strnicmp( m_szLineBuff, CLASSTWO_HNGUP, CLASSTWO_HNGUP_SIZE ) == 0 )
  604. {
  605. OnFHNG();
  606. }
  607. break;
  609. case STATE_RESET_PARAMS:
  610. if( strnicmp( m_szLineBuff, "OK", 2 ) == 0 )
  611. {
  612. // On to Phase C
  613. DoWrite( CLASSTWO_DT, CLASSTWO_DT_SIZE, true );
  614. SetState( STATE_PHASE_C );
  615. m_bGotDCS = false;
  616. KillTimer( TIMER_COMMAND );
  617. SignalEvent( EVENT_START_TRAINING );
  618. m_bLastPageGood = false;
  619. }
  620. else
  621. {
  622. ErrorUnexpectedResponse();
  623. KillTimer( TIMER_COMMAND );
  624. Terminate();
  625. SetState( STATE_IDLE );
  626. }
  627. break;
  629. }
  630. }
  633. //////////////////////////////////////////////////////////////////////
  634. // Phase C - transmit/receive data
  635. //////////////////////////////////////////////////////////////////////
  636. void CClassTwoPointZero::PhaseC(void)
  637. {
  638. if( m_bReceiving )
  639. {
  640. if( strnicmp( m_szLineBuff, "CONNECT", 7 ) == 0 )
  641. {
  642. char dc2 = DC2;
  643. DoWrite( &dc2, 1, false );
  644. InitHDLC();
  645. //EnableSoftFlowControl( false );
  646. m_bFirstFrame = true;
  648. SignalEvent( EVENT_START_PAGE );
  649. }
  650. else if( stricmp( m_szLineBuff, "OK" ) == 0 )
  651. {
  652. m_nLoopCtr = 0;
  653. m_bLastPageGood = m_FaxFile.WriteIFD();
  655. //EnableSoftFlowControl( true );
  657. if( m_bGotEOP || (!m_bGotEOP && !m_bGotEOM && !m_bGotMPS ))
  658. {
  659. SetState( STATE_PHASE_E, STATE_WAIT_FOR_OK );
  660. }
  662. DoWrite( CLASSTWO_DR, CLASSTWO_DR_SIZE, true );
  664. m_bGotEOP = false;
  665. m_bGotMPS = false;
  666. m_bGotEOM = false;
  667. }
  668. else if( strnicmp( m_szLineBuff, CLASSTWO_PTS, CLASSTWO_PTS_SIZE ) == 0 )
  669. {
  670. OnFPTS();
  671. }
  672. else if( strnicmp( m_szLineBuff, CLASSTWO_ET, CLASSTWO_ET_SIZE ) == 0 )
  673. {
  674. OnFET();
  675. }
  676. else if( strnicmp( m_szLineBuff, CLASSTWO_HNGUP, CLASSTWO_HNGUP_SIZE ) == 0 )
  677. {
  678. OnFHNG();
  679. }
  680. }
  681. else
  682. {
  683. if( strnicmp( m_szLineBuff, "CONNECT", 7 ) == 0 )
  684. {
  685. if( !m_bGotDCS )
  686. {
  687. char can = CAN;
  688. DoWrite( &can, 1, false );
  689. m_sLastError.assign( (char*)LoadString(GEN_ERROR_DCS_NOT_RECEIVED).c_str() );
  690. // SignalEvent( EVENT_ERROR );
  691. Terminate();
  692. SetState( STATE_PHASE_E, STATE_WAIT_FOR_OK );
  693. }
  694. else
  695. {
  696. char xon = XON;
  697. DoWrite( &xon, 1, false );
  698. m_nPageBytes = 0;
  699. DoWrite( m_FaxFile.GetPageData(), m_FaxFile.GetPageBytes(), false );
  701. SignalEvent( EVENT_START_PAGE );
  703. SetMaxPageRetriesTimer();
  704. }
  705. }
  706. else if( stricmp( m_szLineBuff, "OK" ) == 0 )
  707. {
  708. if( true /*m_bLastPageGood*/ )
  709. {
  710. if( m_FaxFile.MorePages() )
  711. {
  712. DoWrite( CLASSTWO_DT, CLASSTWO_DT_SIZE, true );
  713. SetState( STATE_PHASE_C );
  715. if( m_FaxFile.ReadNextHeader() == false )
  716. {
  717. m_sLastError.assign( (char*)LoadString(GEN_ERROR_READING_TIFF_FILE).c_str() );
  718. // SignalEvent( EVENT_ERROR );
  719. Terminate();
  720. SetState( STATE_PHASE_E, STATE_WAIT_FOR_OK );
  721. }
  722. else
  723. {
  724. if( m_FaxFile.ReadPage( false, 0, m_wMinLineChars, true ) == false )
  725. {
  726. m_sLastError.assign( (char*)LoadString(GEN_ERROR_READING_TIFF_FILE).c_str() );
  727. // SignalEvent( EVENT_ERROR );
  728. Terminate();
  729. SetState( STATE_PHASE_E, STATE_WAIT_FOR_OK );
  730. }
  731. }
  732. }
  733. else
  734. {
  735. m_FaxFile.IncrementPageCount();
  736. m_bSuccessful = true;
  737. //DoWrite( CLASSTWO_FK, CLASSTWO_FK_SIZE, true );
  738. SetState( STATE_PHASE_E, STATE_WAIT_FOR_OK );
  739. KillTimer( TIMER_MAXPAGERETRIES );
  740. }
  741. }
  742. else
  743. {
  744. DoWrite( CLASSTWO_DT, CLASSTWO_DT_SIZE, true );
  745. SetState( STATE_PHASE_C );
  746. }
  747. m_bLastPageGood = false;
  748. }
  749. else if( strnicmp( m_szLineBuff, CLASSTWO_DCS, CLASSTWO_DCS_SIZE ) == 0 )
  750. {
  751. OnDCS();
  752. }
  753. else if( strnicmp( m_szLineBuff, CLASSTWO_HNGUP, CLASSTWO_HNGUP_SIZE ) == 0 )
  754. {
  755. OnFHNG();
  756. }
  757. }
  758. }
  761. //////////////////////////////////////////////////////////////////////
  762. // Phase D - post-page messages
  763. //////////////////////////////////////////////////////////////////////
  764. /*
  765. void CClassTwoPointZero::PhaseD(void)
  766. {
  767. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  768. {
  769. /*
  770. m_nLoopCtr = 0;
  771. m_FaxFile.WriteIFD();
  773. EnableSoftFlowControl( true );
  775. if( m_bGotEOP || (!m_bGotEOP && !m_bGotEOM && !m_bGotMPS ))
  776. {
  777. SetState( STATE_PHASE_E, STATE_WAIT_FOR_OK );
  778. }
  780. DoWrite( CLASSTWO_DR, CLASSTWO_DR_SIZE, true );
  782. m_bGotEOP = false;
  783. m_bGotMPS = false;
  784. m_bGotEOM = false;
  785. */ /*
  787. if( m_FaxFile.MorePages() )
  788. {
  789. DoWrite( CLASSTWO_DT, CLASSTWO_DT_SIZE, true );
  790. SetState( STATE_PHASE_C );
  792. if( m_FaxFile.ReadNextHeader() )
  793. {
  794. m_FaxFile.ReadPage( false, 0, 0, true );
  795. }
  796. }
  797. else
  798. {
  799. m_FaxFile.IncrementPageCount();
  800. m_bSuccessful = true;
  801. DoWrite( CLASSTWO_FK, CLASSTWO_FK_SIZE, true );
  802. SetState( STATE_PHASE_E, STATE_WAIT_FOR_FK_RESP );
  803. }
  804. }
  805. else if( strnicmp( m_szLineBuff, CLASSTWO_PTS, CLASSTWO_PTS_SIZE ) == 0 )
  806. {
  807. OnFPTS();
  808. }
  809. else if( strnicmp( m_szLineBuff, CLASSTWO_HNGUP, CLASSTWO_HNGUP_SIZE ) == 0 )
  810. {
  811. OnFHNG();
  812. }
  813. }
  814. */
  816. //////////////////////////////////////////////////////////////////////
  817. // Phase E - Disconnect
  818. //////////////////////////////////////////////////////////////////////
  819. void CClassTwoPointZero::PhaseE(void)
  820. {
  821. switch( m_nPhaseState )
  822. {
  823. case STATE_WAIT_FOR_OK:
  824. if( strnicmp( m_szLineBuff, "OK", 2 ) == 0 )
  825. {
  826. DoWrite( CLASSTWO_FK, CLASSTWO_FK_SIZE, true );
  827. m_nPhaseState = STATE_WAIT_FOR_FK_RESP;
  828. }
  829. else if( strnicmp( m_szLineBuff, CLASSTWO_HNGUP, CLASSTWO_HNGUP_SIZE ) == 0 )
  830. {
  831. OnFHNG();
  832. }
  833. break;
  835. case STATE_WAIT_FOR_FK_RESP:
  836. Terminate();
  837. if( strnicmp( m_szLineBuff, "NO CARRIER", 2 ) == 0 )
  838. {
  839. PhaseDisconnect();
  840. }
  841. else
  842. {
  843. DoHangup();
  844. }
  845. break;
  846. }
  847. }
  850. //////////////////////////////////////////////////////////////////////
  851. // OnSendFaxMsg
  852. //////////////////////////////////////////////////////////////////////
  853. void CClassTwoPointZero::OnSendFaxMsg(MSG* pMsg)
  854. {
  855. CModem::OnSendFaxMsg( pMsg );
  857. if( !m_bConnected )
  858. {
  859. // Error!
  860. return;
  861. }
  863. if( m_nState != STATE_IDLE )
  864. {
  865. // Error!
  866. return;
  867. }
  869. m_FaxFile.SetSendEncoding( m_nSendEncoding );
  871. int nRet = m_FaxFile.ReadFirstHeader();
  873. if( nRet == 1 )
  874. {
  875. //OutputDebugString( "Error reading first headern" );
  876. m_sLastError.assign( (char*)LoadString(GEN_ERROR_READING_TIFF_FILE).c_str() );
  877. // SignalEvent( EVENT_ERROR );
  878. SignalEvent( EVENT_TERMINATE );
  879. SignalEvent( EVENT_IDLE );
  880. return;
  881. }
  882. else if( nRet == 2 )
  883. {
  884. //OutputDebugString( "Error reading first headern" );
  885. m_sLastError.assign( (char*)LoadString(GEN_ERROR_INCOMPAT_TIFF_FILE).c_str() );
  886. // SignalEvent( EVENT_ERROR );
  887. SignalEvent( EVENT_TERMINATE );
  888. SignalEvent( EVENT_IDLE );
  889. return;
  890. }
  892. m_bReceiving = false;
  893. m_bHDLCMode = false;
  894. m_bSuccessful = false;
  896. SetState( STATE_PHASE_A, STATE_SET_PARAMS );
  898. EnableSoftFlowControl( true );
  900. m_nScanTime = 0;
  902. m_DISParams.p.BitRate = m_nSendBaud;
  903. m_DISParams.p.PageLength = 2;
  905. SetFaxParams( true );
  906. }
  909. void CClassTwoPointZero::OnRecvFaxMsg(MSG* pMsg)
  910. {
  911. CModem::OnRecvFaxMsg( pMsg );
  913. if( m_nState == STATE_IDLE || m_nState == STATE_RINGING )
  914. {
  915. EnableSoftFlowControl( false );
  917. m_FaxFile.Clear();
  919. m_FaxFile.SetSendEncoding( m_nSendEncoding );
  921. m_bReceiving = true;
  922. m_bSuccessful = false;
  924. SetState( STATE_PHASE_A, STATE_SET_CSID );
  925. SetLocalID();
  926. }
  927. }
  930. //////////////////////////////////////////////////////////////////////
  931. // Handle wait timeout - do periodic processing
  932. //////////////////////////////////////////////////////////////////////
  933. bool CClassTwoPointZero::OnWaitTimeout( void )
  934. {
  935. CModem::OnWaitTimeout();
  936. /*
  937. if( m_nState == STATE_INIT )
  938. {
  939. DWORD dwElapsed = GetTickCount() - m_nLastCommandTickCount;
  941. // In case the modem doesn't respond with an OK
  942. if( dwElapsed > 1000 )
  943. {
  944. if( m_nLastCommand == COMMAND_QUERY_SEND_SPEEDS )
  945. {
  946. SendCommand( COMMAND_QUERY_RECEIVE_SPEEDS );
  947. }
  948. else if( m_nLastCommand == COMMAND_QUERY_RECEIVE_SPEEDS )
  949. {
  950. SetState( STATE_IDLE );
  951. }
  952. }
  954. if( dwElapsed > 4000 )
  955. {
  956. char szMsg[256];
  957. wsprintf( szMsg, "Timeout: %d ms waiting for responsen", dwElapsed );
  958. //OutputDebugString( szMsg );
  960. OnDisconnectMsg();
  961. }
  962. }
  963. */
  964. return false;
  965. }
  968. void CClassTwoPointZero::SetState( int nNewState, int nNewPhaseState )
  969. {
  970. m_nState = nNewState;
  971. m_nPhaseState = nNewPhaseState;
  973. if( nNewState == STATE_IDLE )
  974. {
  975. SignalEvent( EVENT_IDLE );
  976. }
  977. }
  980. void CClassTwoPointZero::Abort( bool bUserCancelled )
  981. {
  982. char endofframe[2] = { DLE, ETX };
  983. char byteCancel = CAN;
  986. if( bUserCancelled ) 
  987. {
  988. m_sLastError.assign( (char*)LoadString(GEN_FAX_CANCELLED).c_str() );
  989. }
  991. Terminate();
  993. switch( m_nState )
  994. {
  995. case STATE_PHASE_A:
  996. switch( m_nPhaseState )
  997. {
  998. case STATE_SET_PARAMS:
  999. case STATE_SET_CSID:
  1000. SetState( STATE_PHASE_E, STATE_WAIT_FOR_FK_RESP );
  1001. break;
  1003. case STATE_DIALING:
  1004. DoWrite( &byteCancel, 1, false );
  1005. SetState( STATE_PHASE_E, STATE_WAIT_FOR_FK_RESP );
  1006. break;
  1007. }
  1008. break;
  1010. case STATE_PHASE_B:
  1011. SetState( STATE_PHASE_E, STATE_WAIT_FOR_OK );
  1012. break;
  1014. case STATE_PHASE_C:
  1015. if ( m_bReceiving )
  1016. {
  1017. DoWrite( &byteCancel, 1, false );
  1018. SetState( STATE_PHASE_E, STATE_WAIT_FOR_OK );
  1019. m_bHDLCMode = false;
  1020. }
  1021. else
  1022. {
  1023. DoWrite( endofframe, 2, false );
  1024. SetState( STATE_PHASE_E, STATE_WAIT_FOR_OK );
  1025. }
  1026. break;
  1028.     //case STATE_PHASE_E:
  1029. // break;
  1030. }
  1031. }
  1035. void CClassTwoPointZero::SetLocalID( void )
  1036. {
  1037. char szCmdBuff[256];
  1039. wsprintf( szCmdBuff, CLASSTWO_SETID, m_sLocalCSID.c_str() );
  1041. SendCommand( COMMAND_SET_LOCAL_ID, szCmdBuff );
  1042. }
  1045. void CClassTwoPointZero::SetRecv(void)
  1046. {
  1047. char szCmdBuff[256];
  1049. wsprintf( szCmdBuff, CLASSTWO_SETRECV, m_bEnableReceive ? 1 : 0 );
  1052. SendCommand( COMMAND_SET_RECV, szCmdBuff );
  1053. }
  1055. void CClassTwoPointZero::SetBitOrder(void)
  1056. {
  1057. SendCommand( COMMAND_SET_BIT_ORDER, CLASSTWO_SETBOR );
  1058. }
  1060. void CClassTwoPointZero::SetFlowControl(void)
  1061. {
  1062. SendCommand( COMMAND_SET_FLOW_CONTROL );
  1063. }
  1067. void CClassTwoPointZero::SetHDLCReporting(void)
  1068. {
  1069. SendCommand( COMMAND_SET_HDLC_REPORTING, CLASSTWO_SETRPTING );
  1070. }
  1072. void CClassTwoPointZero::SetFaxParams( bool bSending )
  1073. {
  1074. char szCmdBuff[256];
  1076. m_DCSParams.p.VertRes = m_bFineSupported ? 1 : 0;
  1077. m_DCSParams.p.BitRate = m_nRecvBaud;
  1078. m_DCSParams.p.PageWidth = 0;
  1079. m_DCSParams.p.PageLength = m_bUnlimitedSupported ? 2 : 0;
  1080. m_DCSParams.p.DataFormat = m_FaxFile.GetSendEncoding();
  1081. m_DCSParams.p.ECM = m_bECMSupported ? 1 : 0;
  1083. // TODO: Check if ECM enabled for modem and maximum bit rate
  1085. if( bSending )
  1086. {
  1087. if( m_DISParams.p.BitRate > m_nSendBaud )
  1088. {
  1089. m_DCSParams.p.BitRate = m_nSendBaud;
  1090. }
  1091. else
  1092. {
  1093. m_DCSParams.p.BitRate = m_DISParams.p.BitRate;
  1094. }
  1096. if( m_FaxFile.IsHiRes() == false )
  1097. {
  1098. m_DCSParams.p.VertRes = 0;
  1099. }
  1100. if( m_DISParams.p.PageLength == 0 )
  1101. {
  1102. m_DCSParams.p.PageLength = 0;
  1103. }
  1104. }
  1106. wsprintf( szCmdBuff, CLASSTWO_SETPARAMS,
  1107.       m_DCSParams.p.VertRes, // resolution
  1108.   m_DCSParams.p.BitRate, // bit rate
  1109.   m_DCSParams.p.PageWidth, // page width
  1110.   m_DCSParams.p.PageLength, // page length
  1111.   m_DCSParams.p.DataFormat, // format
  1112.   m_DCSParams.p.ECM, // error checking
  1113.   m_nScanTime );
  1115. SendCommand( COMMAND_SET_FAX_PARAMS, szCmdBuff );
  1116. }
  1119. void CClassTwoPointZero::OnDIS(void)
  1120. {
  1121. //OutputDebugString( "OnDISn" );
  1123. ParseFaxParams( 8, m_DISParams.n );
  1125. m_bGotDIS = true;
  1126. m_bResendFaxParams = false;
  1128. m_nScanTime = m_DISParams.p.ScanTime;
  1130. if( m_DISParams.p.ScanTime > 0 )
  1131. {
  1132. m_bResendFaxParams = true;
  1133. }
  1135. /*
  1136. if(    (m_DISParams.p.DataFormat != FAXAPI_ENC_CCITT_1D)
  1137. && (m_DISParams.p.DataFormat != m_nSendEncoding ) )
  1138. {
  1139. //
  1140. //OutputDebugString( "Need to re-set fax parameters!n" );
  1141. m_bResendFaxParams = true;
  1143. m_FaxFile.SetSendEncoding( FAXAPI_ENC_CCITT_1D );
  1144. }
  1145. */
  1147. SignalEvent( EVENT_RECV_DIS );
  1148. }
  1150. void CClassTwoPointZero::OnDCS(void)
  1151. {
  1152. //OutputDebugString( "OnDCSn" );
  1154. m_bGotDCS = true;
  1156. ParseFaxParams( 8, m_DCSParams.n );
  1158. if( m_bReceiving )
  1159. {
  1160. m_FaxFile.SetImageRes( m_DCSParams.p.VertRes != 0 );
  1162. switch( m_DCSParams.p.PageWidth )
  1163. {
  1164. case 1:
  1165. m_FaxFile.SetImageWidth( 2048 );
  1166. break;
  1168. case 2:
  1169. m_FaxFile.SetImageWidth( 2432 );
  1170. break;
  1172. case 3:
  1173. m_FaxFile.SetImageWidth( 1216 );
  1174. break;
  1176. case 4:
  1177. m_FaxFile.SetImageWidth( 864 );
  1178. break;
  1180. default:
  1181. m_FaxFile.SetImageWidth( 1728 );
  1182. break;
  1183. }
  1186. switch( m_DCSParams.p.DataFormat )
  1187. {
  1188. case 1: // 2D modified Read
  1189. m_FaxFile.SetImageCompression( 3 );
  1190. m_FaxFile.SetT4Options( 0x01 );
  1191. break;
  1193. case 2: // 2D uncompressed
  1194. m_FaxFile.SetImageCompression( 3 );
  1195. m_FaxFile.SetT4Options( 0 );
  1196. break;
  1198. case 3: // T.6
  1199. m_FaxFile.SetImageCompression( 4 );
  1200. m_FaxFile.SetT4Options( 0 );
  1201. break;
  1203. default: // 0 = 1D modified huffman
  1204. m_FaxFile.SetImageCompression( 3 );
  1205. m_FaxFile.SetT4Options( 0 );
  1206. break;
  1207. }
  1209. m_FaxFile.SetImageLength( 0 );
  1210. SignalEvent( EVENT_RECV_DCS );
  1211. }
  1212. else
  1213. {
  1214. // TODO: What if we get multiple DCS (e.g. training failed)
  1215. int nBaud = Cls2FaxParamBitRates[m_DCSParams.p.BitRate];
  1216. int nScanTimeMs = (m_DCSParams.p.VertRes == 0) ? 
  1217.   Cls2ScanTimes_normal[ m_DCSParams.p.ScanTime ] :
  1218.               Cls2ScanTimes_fine[ m_DCSParams.p.ScanTime ];
  1219. m_wMinLineChars = ((nBaud/8) * nScanTimeMs)/1000;
  1221. m_FaxFile.SelectEncoding( m_DCSParams.p.DataFormat );
  1222. SignalEvent( EVENT_SENT_DCS );
  1224. if( m_FaxFile.ReadPage( false, 0, m_wMinLineChars, true ) == false )
  1225. {
  1226. m_sLastError.assign( (char*)LoadString(GEN_ERROR_READING_TIFF_FILE).c_str() );
  1227. // SignalEvent( EVENT_ERROR );
  1228. Terminate();
  1229. SetState( STATE_PHASE_E, STATE_WAIT_FOR_OK );
  1230. }
  1231. }
  1232. }
  1234. void CClassTwoPointZero::OnCSI(void)
  1235. {
  1236. char szID[21];
  1237. int i = 0;
  1238. bool bNoQuotes = false;
  1240. m_sRemoteCSID = "";
  1242. //OutputDebugString( "OnCSIn" );
  1244. char* p = m_szLineBuff + 5; // skip +FTSI
  1246. if ( *p == ':' ) // skip the colon
  1247. {
  1248. p++;
  1249. }
  1251. while (*p && *p != '"' ) // skip white space before first quote
  1252. {
  1253. p++;
  1254. }
  1256. if( *p == 0 )
  1257. {
  1258. bNoQuotes = true;
  1260. // Uh-oh! no quotes found, back up and try w/o quotes
  1261. p = m_szLineBuff + 5;
  1263. if ( *p == ':' ) // skip the colon
  1264. {
  1265. p++;
  1266. }
  1268. while (*p && *p == ' ' ) // skip white space
  1269. {
  1270. p++;
  1271. }
  1273. return;
  1274. }
  1275. else
  1276. {
  1277. p++; // skip first quote
  1278. }
  1280. while( *p && (*p != '"') && (i < 20) )
  1281. {
  1282. szID[i] = *p;
  1283. p++;
  1284. i++;
  1285. }
  1287. szID[i] = 0;
  1289. m_sRemoteCSID.assign( szID );
  1291. SignalEvent( EVENT_GOT_REMOTEID );
  1292. }
  1294. void CClassTwoPointZero::OnNSF(void)
  1295. {
  1296. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_NSF).c_str() );
  1297. }
  1299. void CClassTwoPointZero::OnNSS(void)
  1300. {
  1301. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_NSS).c_str() );
  1302. }
  1304. // Page Status Report
  1305. void CClassTwoPointZero::OnFPTS(void)
  1306. {
  1307. int n[2];
  1309. //OutputDebugString( "OnFPTSn" );
  1311. int nParams = ParseFaxParams( 2, n );
  1313. if( nParams > 0 )
  1314. {
  1315. switch( n[0] )
  1316. {
  1317. case 1:
  1318. if( m_bReceiving )
  1319. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_SENT_MCF).c_str() );
  1320. else
  1321. {
  1322. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_MCF).c_str() );
  1323. m_bLastPageGood = true;
  1324. }
  1325. break;
  1326. case 2:
  1327. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_RTN).c_str() );
  1328. m_bLastPageGood = false;
  1329. break;
  1330. case 3:
  1331. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_RTP).c_str() );
  1332. m_bLastPageGood = true;
  1333. break;
  1334. case 4:
  1335. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_PIN).c_str() );
  1336. m_bLastPageGood = true;
  1337. break;
  1338. case 5:
  1339. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_PIP).c_str() );
  1340. m_bLastPageGood = true;
  1341. break;
  1342. }
  1343. }
  1345. //if( nParams > 1 )
  1346. //{
  1347. // m_FaxFile.SetImageLength( n[1] );
  1348. //}
  1349. }
  1352. void CClassTwoPointZero::OnFET(void)
  1353. {
  1354. int n;
  1356. //OutputDebugString( "OnFETn" );
  1358. ParseFaxParams( 1, &n );
  1360. switch( n )
  1361. {
  1362. case 0:
  1363. OnMPS();
  1364. break;
  1366. case 1:
  1367. OnEOM();
  1368. break;
  1370. case 2:
  1371. OnEOP();
  1372. break;
  1373. }
  1374. }
  1377. void CClassTwoPointZero::OnEOP(void)
  1378. {
  1379. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_EOP).c_str() );
  1380. m_bGotEOP = true;
  1381. }
  1383. void CClassTwoPointZero::OnEOM(void)
  1384. {
  1385. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_EOM).c_str() );
  1386. m_bGotEOM = true;
  1387. }
  1389. void CClassTwoPointZero::OnMPS(void)
  1390. {
  1391. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_MPS).c_str() );
  1392. m_bGotMPS = true;
  1393. }
  1396. void CClassTwoPointZero::OnFHNG( void )
  1397. {
  1398. int n;
  1400. //TODO: These are hexadecimal codes!
  1402. //OutputDebugString( "OnFHNGn" );
  1404. n = ParseFHSCode();
  1406. //char szCode[32];
  1407. //wsprintf( szCode, "==> %Xn", n );
  1408. //OutputDebugString( szCode );
  1410. switch( n )
  1411. {
  1412. case 0x00:
  1413. m_bSuccessful = true;
  1414. if( !m_bReceiving )
  1415. {
  1416. m_FaxFile.IncrementPageCount();
  1417. }
  1418. break;
  1420. case 0x01:
  1421. m_sLastError.assign( (char*)LoadString(GEN_CALL_ANSWERED_WO_FAX_HANDSHAKE).c_str() );
  1422. break;
  1424. case 0x02:
  1425. m_sLastError.assign( (char*)LoadString(GEN_CALL_ABORTED_BY_USER).c_str() );
  1426. break;
  1428. case 0x03:
  1429. m_sLastError.assign( (char*)LoadString(GEN_NO_LOOP_CURRENT).c_str() );
  1430. break;
  1432. case 0x04:
  1433. m_sLastError.assign( (char*)LoadString(GEN_RINGBACK_DETECTED_BUT_NO_ANSWER).c_str() );
  1434. break;
  1436. case 0x05:
  1437. m_sLastError.assign( (char*)LoadString(GEN_RINGBACK_DETECTED_CALL_ANSWERED_BUT_NO_CED_TONE).c_str() );
  1438. break;
  1440. case 0x10:
  1441. m_sLastError.assign( (char*)LoadString(GEN_UNSPECIFIED_PHASE_A_ERROR).c_str() );
  1442. break;
  1444. case 0x11:
  1445. m_sLastError.assign( (char*)LoadString(GEN_NO_ANSWER_OR_NO_DIS).c_str() );
  1446. break;
  1448. case 0x20:
  1449. m_sLastError.assign( (char*)LoadString(GEN_UNSPECIFIED_PHASE_B_TRANSMIT_ERROR).c_str() );
  1450. break;
  1452. case 0x21:
  1453. m_sLastError.assign( (char*)LoadString(GEN_REMOTE_CANNOT_RECEIVE_OR_SEND).c_str() );
  1454. break;
  1456. case 0x22:
  1457. m_sLastError.assign( (char*)LoadString(GEN_PHASE_B_TRANSMIT_COMMAND_FRAME_ERROR).c_str() );
  1458. break;
  1460. case 0x23:
  1461. m_sLastError.assign( (char*)LoadString(GEN_PHASE_B_TRANSMIT_INVALID_COMMAND_RECEIVED).c_str() );
  1462. break;
  1464. case 0x24:
  1465. m_sLastError.assign( (char*)LoadString(GEN_PHASE_B_TRANSMIT_RESPONSE_FRAME_ERROR).c_str() );
  1466. break;
  1468. case 0x25:
  1469. m_sLastError.assign( (char*)LoadString(GEN_DCS_SENT_THREE_TIMES_WITHOUT_RESPONSE).c_str() );
  1470. break;
  1472. case 0x26:
  1473. m_sLastError.assign( (char*)LoadString(GEN_DISDTC_RECEIVED_3_TIMES_DCS_NOT_RECOGNISED).c_str() );
  1474. break;
  1476. case 0x27:
  1477. m_sLastError.assign( (char*)LoadString(GEN_FAILURE_TO_TRAIN_AT_2400_BPS).c_str() );
  1478. break;
  1480. case 0x28:
  1481. m_sLastError.assign( (char*)LoadString(GEN_PHASE_B_TRANSMIT_INVALID_RESPONSE_RECEIVED).c_str() );
  1482. break;
  1484. case 0x40:
  1485. m_sLastError.assign( (char*)LoadString(GEN_UNSPECIFIED_PHASE_C_TRANSMIT_ERROR).c_str() );
  1486. break;
  1488. case 0x41:
  1489. m_sLastError.assign( (char*)LoadString(GEN_UNSPECIFIED_IMAGE_FORMAT).c_str() );
  1490. break;
  1492. case 0x42:
  1493. m_sLastError.assign( (char*)LoadString(GEN_IMAGE_CONVERSION_ERROR).c_str() );
  1494. break;
  1496. case 0x43:
  1497. m_sLastError.assign( (char*)LoadString(GEN_DTE_TO_DCE_DATA_UNDERFLOW).c_str() );
  1498. break;
  1500. case 0x44:
  1501. m_sLastError.assign( (char*)LoadString(GEN_UNRECOGNIZED_DLE_COMMAND).c_str() );
  1502. break;
  1504. case 0x45:
  1505. m_sLastError.assign( (char*)LoadString(GEN_WRONG_LINE_LENGTH).c_str() );
  1506. break;
  1508. case 0x46:
  1509. m_sLastError.assign( (char*)LoadString(GEN_WRONG_PAGE_LENGTH).c_str() );
  1510. break;
  1512. case 0x47:
  1513. m_sLastError.assign( (char*)LoadString(GEN_WRONG_COMPRESSION_CODE).c_str() );
  1514. break;
  1516. case 0x50:
  1517. m_sLastError.assign( (char*)LoadString(GEN_UNSPECIFIED_PHASE_D_TRANSMIT_ERROR).c_str() );
  1518. break;
  1520. case 0x51:
  1521. m_sLastError.assign( (char*)LoadString(GEN_PHASE_D_TRANSMIT_RESPONSE_FRAME_ERROR).c_str() );
  1522. break;
  1524. case 0x52:
  1525. m_sLastError.assign( (char*)LoadString(GEN_NO_RESPONSE_TO_MPS_REPEATED_3_TIMES).c_str() );
  1526. break;
  1528. case 0x53:
  1529. m_sLastError.assign( (char*)LoadString(GEN_INVALID_RESPONSE_TO_MPS).c_str() );
  1530. break;
  1532. case 0x54:
  1533. m_sLastError.assign( (char*)LoadString(GEN_NO_RESPONSE_TO_EOP_REPEATED_3_TIMES).c_str() );
  1534. break;
  1536. case 0x55:
  1537. m_sLastError.assign( (char*)LoadString(GEN_INVALID_RESPONSE_TO_EOP).c_str() );
  1538. break;
  1540. case 0x56:
  1541. m_sLastError.assign( (char*)LoadString(GEN_NO_RESPONSE_TO_EOM_REPEATED_3_TIMES).c_str() );
  1542. break;
  1544. case 0x57:
  1545. m_sLastError.assign( (char*)LoadString(GEN_INVALID_RESPONSE_TO_EOM).c_str() );
  1546. break;
  1548. case 0x58:
  1549. m_sLastError.assign( (char*)LoadString(GEN_UNABLE_TO_CONTINUE_AFTER_PIN_OR_PIP).c_str() );
  1550. break;
  1552. case 0x70:
  1553. m_sLastError.assign( (char*)LoadString(GEN_UNSPECIFIED_PHASE_B_RECEIVE_ERROR).c_str() );
  1554. break;
  1556. case 0x71:
  1557. m_sLastError.assign( (char*)LoadString(GEN_PHASE_B_RECEIVE_RESPONSE_FRAME_ERROR).c_str() );
  1558. break;
  1560. case 0x72:
  1561. m_sLastError.assign( (char*)LoadString(GEN_PHASE_B_RECEIVE_COMMAND_FRAME_ERROR).c_str() );
  1562. break;
  1564. case 0x73:
  1565. m_sLastError.assign( (char*)LoadString(GEN_T30_T2_TIMEOUT).c_str() );
  1566. break;
  1568. case 0x74:
  1569. m_sLastError.assign( (char*)LoadString(GEN_FAILURE_TO_RESUME_PHASE_B_AFTER_EOM).c_str() );
  1570. break;
  1572. case 0x90:
  1573. m_sLastError.assign( (char*)LoadString(GEN_UNSPECIFIED_PHASE_C_RECEIVE_ERROR).c_str() );
  1574. break;
  1576. case 0x91:
  1577. m_sLastError.assign( (char*)LoadString(GEN_MISSING_EOL_AFTER_5_SEC).c_str() );
  1578. break;
  1580. case 0x92:
  1581. m_sLastError.assign( (char*)LoadString(GEN_CRC_OR_FRAME_ERROR_IN_ECM_MODE).c_str() );
  1582. break;
  1584. case 0x93:
  1585. m_sLastError.assign( (char*)LoadString(GEN_MODEM_RECEIVE_BUFFER_OVERFLOWED).c_str() );
  1586. break;
  1588. case 0xA0:
  1589. m_sLastError.assign( (char*)LoadString(GEN_UNSPECIFIED_PHASE_D_RECEIVE_ERROR).c_str() );
  1590. break;
  1592. case 0xA1:
  1593. m_sLastError.assign( (char*)LoadString(GEN_PHASE_D_RECEIVE_RESPONSE_FRAME_ERROR).c_str() );
  1594. break;
  1596. case 0xA2:
  1597. m_sLastError.assign( (char*)LoadString(GEN_PHASE_D_RECEIVE_COMMAND_FRAME_ERROR).c_str() );
  1598. break;
  1600. case 0xA3:
  1601. m_sLastError.assign( (char*)LoadString(GEN_UNABLE_TO_CONTINUE_AFTER_PIN_OR_PIP).c_str() );
  1602. break;
  1604. default:
  1605. m_sLastError.assign( (char*)LoadString(GEN_UNSPECIFIED_ERROR).c_str() );
  1606. break;
  1607. }
  1610. SetState( STATE_PHASE_E, m_bReceiving ? STATE_WAIT_FOR_OK : STATE_WAIT_FOR_FK_RESP );
  1611. }
  1613. void CClassTwoPointZero::OnHDLCFrame(void)
  1614. {
  1615. //OutputDebugString( "OnHDLCFramen" );
  1617. if( m_nHDLCBuffPtr == 0 )
  1618. {
  1619. //OutputDebugString( "Empty HDLC Framen" );
  1620. return;
  1621. }
  1623. if( m_nState == STATE_PHASE_C && m_bReceiving )
  1624. {
  1625. m_FaxFile.WriteBuffer( m_szHDLCBuff, m_nHDLCBuffPtr );
  1626. }
  1627. }
  1629. void CClassTwoPointZero::OnPartialHDLCFrame(void)
  1630. {
  1631. //OutputDebugString( "OnPartialHDLCFramen" );
  1633. if( m_nState == STATE_PHASE_C && m_bReceiving )
  1634. {
  1635. if( m_bFirstFrame )
  1636. {
  1637. m_bFirstFrame = false;
  1639. if( m_szHDLCBuff[0] == XON )
  1640. {
  1641. //OutputDebugString( "Skipping XONn" );
  1642. m_FaxFile.WriteBuffer( m_szHDLCBuff+1, m_nHDLCBuffPtr-1 );
  1643. }
  1644. else
  1645. {
  1646. m_FaxFile.WriteBuffer( m_szHDLCBuff, m_nHDLCBuffPtr );
  1647. }
  1648. }
  1649. else
  1650. {
  1651. m_FaxFile.WriteBuffer( m_szHDLCBuff, m_nHDLCBuffPtr );
  1652. }
  1653. }
  1654. else
  1655. {
  1656. //OutputDebugString( "HDLC buffer overflow!n" );
  1657. }
  1658. }
  1661. int CClassTwoPointZero::ParseFHSCode(void)
  1662. {
  1663. char szNumBuff[21];
  1664. int j;
  1665. int nCode = 0xA0;
  1667. char* p = m_szLineBuff + 5; // Skip +XXXX
  1669. if ( *p == ':' ) // skip the colon
  1670. {
  1671. p++;
  1672. }
  1674. // advance to first digit
  1675. while( *p && (IsHexDigit(*p) == false) && (*p != ',') )
  1676. {
  1677. p++;
  1678. }
  1680. // check for end of string
  1681. if( *p == '' )
  1682. {
  1683. return 0xA0;
  1684. }
  1686. j = 0;
  1688. // advance to next comma
  1689. while( *p && IsHexDigit(*p) && (j < 20) )
  1690. {
  1691. szNumBuff[j++] = *p++;
  1692. }
  1694. szNumBuff[j] = '';
  1696. sscanf( szNumBuff, "%X", &nCode );
  1698. return nCode;
  1699. }
  1702. void CClassTwoPointZero::OnTimer( UINT nID )
  1703. {
  1704. //OutputDebugString( "CClassTwoPointZero::OnTimern" );
  1706. if( nID == TIMER_COMMAND )
  1707. {
  1708. switch( m_nLastCommand )
  1709. {
  1710. case COMMAND_QUERY_SEND_SPEEDS:
  1711. SendCommand( COMMAND_QUERY_RECEIVE_SPEEDS );
  1712. break;
  1714. case COMMAND_QUERY_RECEIVE_SPEEDS:
  1715. SetLocalID();
  1716. break;
  1718. case COMMAND_HANGUP:
  1719. SetState( STATE_INIT );
  1720. SendCommand( COMMAND_INIT );
  1721. m_nLoopCtr = 0; 
  1722. break;
  1724. default:
  1725. if( m_bGotOK )
  1726. {
  1727. m_nLoopCtr = 0;
  1728. KillTimer( TIMER_COMMAND );
  1729. SendCommand( COMMAND_SETUP_STRING );
  1730. }
  1731. else
  1732. {
  1733. if( ++m_nLoopCtr >= 3 )
  1734. {
  1735. KillTimer( TIMER_COMMAND );
  1736. m_sLastError.assign( (char*)LoadString(GEN_NO_RESPONSE_FROM_MODEM).c_str() );
  1737. // SignalEvent( EVENT_ERROR );
  1738. OnDisconnectMsg();
  1739. }
  1740. else
  1741. {
  1742. SendCommand( m_nLastCommand, (char*) m_LastCommandString.c_str() );
  1743. }
  1744. }
  1745. break;
  1746. }
  1747. }
  1748. }
  1751. void CClassTwoPointZero::OnAbortFaxMsg(void)
  1752. {
  1753. Abort( true );
  1754. }
  1757. void CClassTwoPointZero::VerifyOptions(void)
  1758. {
  1759. bool bModemFine = m_ParamMatrix[0][1] ? true : false;
  1760. bool bModemUnlimited = m_ParamMatrix[3][2] ? true : false;
  1761. int nModemCompression = m_ParamMatrix[4][3] ? 3 : (m_ParamMatrix[4][1] ? 1 : 0 );
  1762. bool bModemECM = m_ParamMatrix[5][1]  ? true : false;
  1764. if( nModemCompression < m_nSendEncoding )
  1765. {
  1766. char szMsg[FAXAPI_MODEMMSG_INFOLEN];
  1768. wsprintf( szMsg,(char*)LoadString(GEN_FORMAT_UNSUPPORTED_IN_CLASS_20).c_str(), 
  1769.  (m_nSendEncoding==3) ? "2D Group 4" : (m_nSendEncoding == 1 ? "2D Group 3" : "1D Group 3" ),
  1770.  (nModemCompression==3) ? "2D Group 4" : (nModemCompression == 1 ? "2D Group 3" : "1D Group 3" ) );
  1772. SetSendEncoding( nModemCompression );
  1774. SignalEventString( EVENT_INFO, szMsg );
  1775. }
  1777. if( !bModemECM && m_bECMSupported )
  1778. {
  1779. SetSendECM( false );
  1780. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_ECM_UNSUPPORTED_IN_CLASS_2).c_str() );
  1781. }
  1783. SetSendFine( bModemFine );
  1785. SetSendUnlimited( bModemUnlimited );
  1786. }
  1789. void CClassTwoPointZero::CheckTimeouts( DWORD dwInActive )
  1790. {
  1791. switch( m_nState )
  1792. {
  1793. case STATE_PHASE_A:
  1794. if( dwInActive > 90000 )
  1795. {
  1796. m_sLastError.assign( (char*)LoadString(GEN_TIMEOUT_CONNECTING_TO_REMOTE_FAX).c_str() );
  1797. //SignalEvent( EVENT_ERROR );
  1798. Abort( false );
  1799. m_dwActivityTimer = GetTickCount();
  1800. }
  1801. break;
  1803. case STATE_PHASE_E:
  1804. if( dwInActive > 5000 )
  1805. {
  1806. Terminate();
  1807. DoHangup();
  1808. m_dwActivityTimer = GetTickCount();
  1809. }
  1810. break;
  1812. case STATE_DISCONNECT:
  1813. if( dwInActive > 1000 )
  1814. {
  1815. PhaseDisconnect();
  1816. }
  1817. break;
  1819. default:
  1820. if( m_nState > STATE_IDLE && m_nState != STATE_RINGING )
  1821. {
  1822. int nInActive = GetTickCount() - m_dwActivityTimer;
  1824. if( nInActive > 60000 )
  1825. {
  1826. m_sLastError.assign( (char*)LoadString(GEN_TIMEOUT_IN_SENDRECEIVE).c_str() );
  1827. //SignalEvent( EVENT_ERROR );
  1829. Abort( false );
  1830. m_dwActivityTimer = GetTickCount();
  1831. }
  1832. }
  1833. break;
  1834. }
  1835. }