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

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

传真(Fax)编程

开发平台：

Visual C++

Modem.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 CModem build the message loop of an independent thread
  20. // into CCommPort and handle communication with other threads.
  21. //
  22. ////////////////////////////////////////////////////////////////////////////////
  24. #include "stdafx.h"
  25. #include "Modem.h"
  28. char* CModem::s_CommonCmds[COMMAND_COUNT] =
  29. {
  30. "", // COMMAND_NONE, 
  31. "ATZ", // COMMAND_INIT, 
  32. "AT&F&C1&D2S7=55S0=0", // COMMAND_SETUP_STRING
  33. "ATE0", // COMMAND_DISABLE_ECHO, 
  34. "ATL%d", // COMMAND_SET_SPKR_VOL, 
  35. "ATM%d", // COMMAND_SET_SPKR_MODE, 
  36. "AT+FCLASS=1", // COMMAND_SET_FCLASS_1
  37. "AT+FCLASS=1.0", // COMMAND_SET_FCLASS_1_0
  38. "AT+FCLASS=2", // COMMAND_SET_FCLASS_2
  39. "AT+FCLASS=2.0", // COMMAND_SET_FCLASS_2_0
  40. "AT+FCLASS=2.1", // COMMAND_SET_FCLASS_2_1
  41. "AT+FTM=?", // COMMAND_QUERY_SEND_SPEEDS,
  42. "AT+FRM=?", // COMMAND_QUERY_RECEIVE_SPEEDS,
  43. "", // COMMAND_SET_LOCAL_ID,
  44. "", // COMMAND_SET_RECV
  45. "", // COMMAND_SET_BIT_ORDER
  46. "AT+FLO=%d", // COMMAND_SET_FLOW_CONTROL
  47. "", // COMMAND_SET_HDLC_REPORTING
  48. "", // COMMAND_SET_FAX_PARAMS
  49. "ATDT%s", // COMMAND_DIAL
  50. "ATH0", // COMMAND_HANGUP
  51. "ATA", // COMMAND_ANSWER
  52. "AT+FCLASS=?", // COMMAND_QUERY_FCLASS
  53. "ATI0", // COMMAND_QUERY_PRODUCT_CODE
  54. "ATI3", // COMMAND_QUERY_MANUFACTURER
  55. "AT+FDCC=?", // COMMAND_QUERY_CLASS2_CAP
  56. "AT+FMFR?", // COMMAND_QUERY_CLASS2_MANUFACT
  57. "AT+FMDL?", // COMMAND_QUERY_CLASS2_MODEL
  58. "AT+FCC=?", // COMMAND_QUERY_CLASS2_0_CAP
  59. "AT+FMI?", // COMMAND_QUERY_CLASS2_0_MANUFACT
  60. "AT+FMM?", // COMMAND_QUERY_CLASS2_0_MODEL
  61. };
  64. //MODEM_EVENT_HANDLER_FUNC CModem::s_ModemEventHandlerFunc = NULL;
  66. //////////////////////////////////////////////////////////////////////
  67. // Construction/Destruction
  68. //////////////////////////////////////////////////////////////////////
  69. CModem::CModem()
  70. {
  71. m_bConnected = false;
  72. m_sInitString.assign( s_CommonCmds[COMMAND_SETUP_STRING] );
  73. m_nSpkrVol = 0;
  74. m_nSpkrMode = 0;
  75. m_nState = STATE_NONE;
  76. m_nLastCommand = COMMAND_NONE;
  77. m_nRingCount = 0;
  78. m_nAnswerOnRing = 2;
  79. m_bReceiving = false;
  80. m_nWaitTimeout = 1000;
  81. m_bEnableReceive = true;
  82. InitHDLC();
  83. m_bHDLCMode = false;
  84. m_bGotOK = false;
  85. m_bECMSupported = true;
  86. m_nSendEncoding = FAXAPI_ENC_CCITT_T6;
  87. ZeroMemory( m_ParamMatrix, sizeof(m_ParamMatrix) );
  88. m_nSendBaud = FAXAPI_BAUD_14400;
  89. m_nRecvBaud = FAXAPI_BAUD_14400;
  90. m_nMaxSendBaud = FAXAPI_BAUD_33600;
  91. m_nMaxRecvBaud = FAXAPI_BAUD_33600;
  92. m_bPulseDialing = false;
  93. m_FaxThreadID = 0;
  94. m_nMaxPageRetries = 0; // no limit
  95. m_nMaxPageRetriesPageNo = -1;
  96. m_bTerminated = false;
  97. m_bLastPageGood = false;
  98. }
  100. CModem::~CModem()
  101. {
  102. }
  104. //////////////////////////////////////////////////////////////////////
  105. // Initialize - start the modem thread
  106. //////////////////////////////////////////////////////////////////////
  107. void CModem::Initialize( HANDLE hStop, DWORD faxThreadID )
  108. {
  109. m_FaxThreadID = faxThreadID;
  110. AddEvent( hStop );
  111. AddEvent( m_ReadOverlapped.hEvent );
  112. AddEvent( m_WriteOverlapped.hEvent );
  113. AddEvent( m_CommEventOverlapped.hEvent );
  115. StartThread();
  116. }
  119. //////////////////////////////////////////////////////////////////////
  120. // SetPort
  121. //////////////////////////////////////////////////////////////////////
  122. void CModem::SetPort( char* szPort )
  123. {
  124. m_sPort = szPort;
  125. }
  127. //////////////////////////////////////////////////////////////////////
  128. // Disconnect - send a message to initiate the disconnect
  129. //////////////////////////////////////////////////////////////////////
  130. void CModem::Disconnect(void)
  131. {
  132. PostMsg( WM_MODEM_DISCONNECT, 0, 0 );
  133. }
  135. //////////////////////////////////////////////////////////////////////
  136. // Disconnect - send a message to initiate the disconnect
  137. //////////////////////////////////////////////////////////////////////
  138. void CModem::RecvFax( char* szFaxFile )
  139. {
  140. InternalModemMsg* pMsg = new InternalModemMsg;
  142. strcpy( pMsg->szFile, szFaxFile );
  143. // m_FaxFile.SetFileName( szFaxFile );
  145. PostMsg( WM_MODEM_RECVFAX, (WPARAM)pMsg, 0 );
  146. }
  148. //////////////////////////////////////////////////////////////////////
  149. // SetInitString
  150. //////////////////////////////////////////////////////////////////////
  151. void CModem::SetInitString( LPCSTR szString )
  152. {
  153. m_sInitString.assign( szString );
  154. }
  157. //////////////////////////////////////////////////////////////////////
  158. // SetInitString
  159. //////////////////////////////////////////////////////////////////////
  160. void CModem::ChangeCSID( LPCSTR szString )
  161. {
  162. InternalModemMsg* pMsg = new InternalModemMsg;
  164. strcpy( pMsg->szNumber, szString );
  166. PostMsg( WM_MODEM_SETID, (WPARAM)pMsg, 0 );
  167. }
  169. //////////////////////////////////////////////////////////////////////
  170. // SetInitString
  171. //////////////////////////////////////////////////////////////////////
  172. void CModem::SetCSID( LPCSTR szString )
  173. {
  174. char szID[21];
  175. int nLen = 0;
  177. while( *szString && nLen < 20 )
  178. {
  179. if( *szString > 31 && *szString < 127 && *szString != 34 )
  180. {
  181. szID[nLen++] = toupper(*szString);
  182. }
  183. szString++;
  184. }
  185. szID[nLen] = 0;
  187. m_sLocalCSID.assign( szID );
  188. }
  190. //////////////////////////////////////////////////////////////////////
  191. // Connect - send a message to initiate the disconnect
  192. //////////////////////////////////////////////////////////////////////
  193. void CModem::SetSpkrParams( int nSpkrVol, int nSpkrMode )
  194. {
  195. m_nSpkrVol = nSpkrVol;
  196. m_nSpkrMode = nSpkrMode;
  197. }
  200. bool CModem::SendFax( char* szNumberToDial, char* szFaxFile )
  201. {
  202. InternalModemMsg* pMsg = new InternalModemMsg;
  204. strcpy( pMsg->szNumber, szNumberToDial );
  205. strcpy( pMsg->szFile, szFaxFile );
  207. // m_sNumberToDial.assign( szNumberToDial );
  208. // m_FaxFile.SetFileName( szFaxFile );
  210. PostMsg( WM_MODEM_SENDFAX, (WPARAM)pMsg, 0 );
  212. return true;
  213. }
  217. //////////////////////////////////////////////////////////////////////
  218. // OnStartup
  219. //////////////////////////////////////////////////////////////////////
  220. bool CModem::OnStartup( void )
  221. {
  222. m_sThreadName.assign( "Modem Thread" );
  224. if( CThread::OnStartup() )
  225. {
  226. InitWindow();
  228. PostMsg( WM_MODEM_CONNECT, 0, 0 );
  230. return true;
  231. }
  233. return false;
  234. }
  237. //////////////////////////////////////////////////////////////////////
  238. // OnShutdown - called before thread exits
  239. //////////////////////////////////////////////////////////////////////
  240. void CModem::OnShutdown( void )
  241. {
  242. CThread::OnShutdown();
  244. ShutdownWindow();
  246. if( m_bConnected )
  247. {
  248. DisconnectPort();
  249. m_nState = STATE_NONE;
  250. m_bConnected = false;
  251. }
  252. }
  255. //////////////////////////////////////////////////////////////////////
  256. // Handle message - return true if WM_QUIT received
  257. //////////////////////////////////////////////////////////////////////
  258. bool CModem::OnMsg( MSG* pMsg )
  259. {
  260. if( CThread::OnMsg( pMsg ) )
  261. return true;
  263. m_dwActivityTimer = GetTickCount();
  265. switch( pMsg->message )
  266. {
  267. case WM_MODEM_CONNECT:
  268. OnConnectMsg();
  269. break;
  271. case WM_MODEM_DISCONNECT:
  272. OnDisconnectMsg();
  273. break;
  275. case WM_MODEM_SENDFAX:
  276. OnSendFaxMsg( pMsg );
  277. break;
  279. case WM_MODEM_RECVFAX:
  280. OnRecvFaxMsg( pMsg );
  281. break;
  283. case WM_MODEM_ABORTFAX:
  284. OnAbortFaxMsg();
  285. break;
  287. case WM_MODEM_CLEARRINGCNT:
  288. m_nRingCount = 0;
  289. m_nState = STATE_IDLE;
  290. break;
  292. case WM_MODEM_SETID:
  293. {
  294. InternalModemMsg* pModemMsg = (InternalModemMsg*) pMsg->wParam;
  296. if( pModemMsg)
  297. {
  298. SetCSID( pModemMsg->szNumber );
  299. }
  300. delete pModemMsg;
  301. }
  302. break;
  303. }
  305. return false;
  306. }
  309. //////////////////////////////////////////////////////////////////////
  310. // Handle event - return true if cancel event set
  311. //////////////////////////////////////////////////////////////////////
  312. bool CModem::OnEvent( int nIndex )
  313. {
  315. switch( nIndex )
  316. {
  317. case 0:
  318. // Cancel event
  319. OnDisconnectMsg();
  320. return true;
  322. case 1:
  323. // Read event
  324. ReadEventSignalled();
  325. return false;
  327. case 2:
  328. // Write event
  329. WriteEventSignalled();
  330. return false;
  332. case 3:
  333. // WaitComm event
  334. WaitCommEventSignalled();
  335. return false;
  337. case 4:
  338. // Disconnect Event
  339. return true;
  340. }
  342. return false;
  343. }
  347. //////////////////////////////////////////////////////////////////////
  348. // OnConnectMsg
  349. //////////////////////////////////////////////////////////////////////
  350. void CModem::OnConnectMsg(void)
  351. {
  352. if( !m_bConnected )
  353. {
  354. m_nRingCount = 0;
  355. m_bConnected = ConnectPort( m_sLastError );
  357. if( !m_bConnected )
  358. {
  359. SignalEvent( EVENT_ERROR );
  360. m_nState = STATE_NONE;
  361. SignalEvent( EVENT_DISCONNECT );
  362. ExitAndDelete();
  363. }
  364. }
  365. }
  367. //////////////////////////////////////////////////////////////////////
  368. // OnDisconnectMsg
  369. //////////////////////////////////////////////////////////////////////
  370. void CModem::OnDisconnectMsg(void)
  371. {
  372. if( m_bConnected )
  373. {
  374. if( OnDisconnect() )
  375. {
  376. DisconnectPort();
  377. m_nState = STATE_NONE;
  378. SignalEvent( EVENT_DISCONNECT );
  379. m_bConnected = false;
  380. ExitAndDelete();
  381. }
  382. }
  383. }
  386. //////////////////////////////////////////////////////////////////////
  387. // OnSendFaxMsg
  388. //////////////////////////////////////////////////////////////////////
  389. void CModem::OnSendFaxMsg( MSG* pMsg )
  390. {
  391. InternalModemMsg* pModemMsg = (InternalModemMsg*) pMsg->wParam;
  393. if( pModemMsg == NULL)
  394. return;
  396. m_sNumberToDial.assign( pModemMsg->szNumber );
  397. m_FaxFile.SetFileName( pModemMsg->szFile );
  399. delete pModemMsg;
  401. m_nMaxPageRetriesPageNo = -1;
  402. }
  404. void CModem::OnRecvFaxMsg( MSG* pMsg )
  405. {
  406. InternalModemMsg* pModemMsg = (InternalModemMsg*) pMsg->wParam;
  408. if( pModemMsg == NULL)
  409. return;
  411. m_FaxFile.SetFileName( pModemMsg->szFile );
  413. delete pModemMsg;
  414. }
  417. void CModem::OnAbortFaxMsg(void)
  418. {
  420. }
  422. //////////////////////////////////////////////////////////////////////
  423. // SendCommand
  424. //////////////////////////////////////////////////////////////////////
  425. void CModem::SendCommand( int nCommand, char* szCmdString )
  426. {
  427. char szWorkBuffer[256];
  428. char* szCmd = NULL;
  431. if( szCmdString )
  432. {
  433. szCmd = szCmdString;
  434. }
  435. else if( nCommand == COMMAND_SETUP_STRING )
  436. {
  437. szCmd = (char*)m_sInitString.c_str();
  438. }
  439. else 
  440. {
  441. switch( nCommand )
  442. {
  443. case COMMAND_SET_SPKR_VOL:
  444. wsprintf( szWorkBuffer, s_CommonCmds[nCommand], m_nSpkrVol );
  445. szCmd = szWorkBuffer;
  446. break;
  448. case COMMAND_SET_SPKR_MODE:
  449. wsprintf( szWorkBuffer, s_CommonCmds[nCommand], m_nSpkrMode );
  450. szCmd = szWorkBuffer;
  451. break;
  453. case COMMAND_DIAL:
  454. if( m_bPulseDialing )
  455. {
  456. wsprintf( szWorkBuffer, "ATDP%s", m_sNumberToDial.c_str() );
  457. }
  458. else
  459. {
  460. wsprintf( szWorkBuffer, "ATDT%s", m_sNumberToDial.c_str() );
  461. }
  462. szCmd = szWorkBuffer;
  463. break;
  465. case COMMAND_SET_FLOW_CONTROL:
  466. wsprintf( szWorkBuffer, s_CommonCmds[nCommand], m_bCTSFlowControl ? 2 : 1 );
  467. szCmd = szWorkBuffer;
  468. break;
  470. default:
  471. if( nCommand >= 0 && nCommand < COMMAND_COUNT )
  472. {
  473. szCmd = s_CommonCmds[nCommand];
  474. }
  475. break;
  476. }
  477. }
  479. if( szCmd )
  480. {
  481. m_nLastCommand = nCommand;
  482. m_LastCommandString.assign( szCmd );
  484. m_bGotOK = false;
  485. KillTimer( TIMER_COMMAND );
  486. if( (nCommand != COMMAND_DIAL) && (nCommand != COMMAND_ANSWER) )
  487. {
  488. SetTimer( TIMER_COMMAND, 2000 );
  489. }
  491. // m_nLastCommandTickCount = GetTickCount();
  493. DoWrite( szCmd, strlen(szCmd), true );
  495. //wsprintf( szWorkBuffer, "Sent Command: %sn", m_LastCommandString.c_str() );
  496. //OutputDebugString( szWorkBuffer );
  497. }
  498. }
  500. //////////////////////////////////////////////////////////////////////
  501. // SignalEvent
  502. //////////////////////////////////////////////////////////////////////
  503. void CModem::SignalEvent( int nEvent, char info )
  504. {
  505. FaxApiModemMsg* pMsg = new FaxApiModemMsg;
  507. memset( pMsg, 0, sizeof(FaxApiModemMsg) );
  509. pMsg->m_cbSize = sizeof(FaxApiModemMsg);
  511. switch( nEvent )
  512. {
  513. case EVENT_ERROR:
  514. strncpy( pMsg->sz, m_sLastError.c_str(), FAXAPI_MODEMMSG_INFOLEN );
  515. pMsg->sz[FAXAPI_MODEMMSG_INFOLEN-1] = '';
  516. break;
  518. case EVENT_RECV_DIS:
  519. case EVENT_SENT_DIS:
  520. memcpy( &pMsg->p, &m_DISParams.p, sizeof(FaxApiParameters) );
  521. break;
  523. case EVENT_RECV_DCS:
  524. case EVENT_SENT_DCS:
  525. memcpy( &pMsg->p, &m_DCSParams.p, sizeof(FaxApiParameters) );
  526. break;
  528. case EVENT_GOT_REMOTEID:
  529. strcpy( pMsg->sz, m_sRemoteCSID.c_str() );
  530. trimws( pMsg->sz );
  531. break;
  533. case EVENT_START_PAGE:
  534. pMsg->t.nPages = GetPageCount();
  535. break;
  537. case EVENT_TERMINATE:
  538. strncpy( pMsg->sz, m_sLastError.c_str(), FAXAPI_MODEMMSG_INFOLEN );
  539. pMsg->sz[FAXAPI_MODEMMSG_INFOLEN-1] = '';
  540. pMsg->t.nPages = GetPageCount();
  541. pMsg->t.nSuccessful = (m_bSuccessful && GetPageCount() > 0 ) ? 1 : 0;
  542. break;
  544. case EVENT_CALLERID:
  545. strncpy( pMsg->sz, m_szLineBuff, FAXAPI_MODEMMSG_INFOLEN );
  546. pMsg->szID[FAXAPI_MODEMMSG_INFOLEN-1] = '';
  547. break;
  549. default:
  550. pMsg->sz[0] = info;
  551. break;
  552. }
  554. SendModemMessage( nEvent, pMsg );
  555. }
  558. void CModem::SignalEventString( int nEvent, LPCSTR szMsg )
  559. {
  560. FaxApiModemMsg* pMsg = new FaxApiModemMsg;
  562. memset( pMsg, 0, sizeof(FaxApiModemMsg) );
  564. pMsg->m_cbSize = sizeof(FaxApiModemMsg);
  566. strncpy( pMsg->sz, szMsg, FAXAPI_MODEMMSG_INFOLEN );
  567. pMsg->sz[FAXAPI_MODEMMSG_INFOLEN-1] = '';
  569. SendModemMessage( nEvent, pMsg );
  570. }
  572. void CModem::SendModemMessage( int nEvent, FaxApiModemMsg* pMsg )
  573. {
  574. strcpy( pMsg->szID, m_sPort.c_str() );
  575. PostThreadMessage( m_FaxThreadID, WM_MODEM_MESSAGE, (WPARAM)pMsg, nEvent );
  576. }
  578. //////////////////////////////////////////////////////////////////////
  579. // ErrorUnexpectedResponse
  580. //////////////////////////////////////////////////////////////////////
  581. void CModem::ErrorUnexpectedResponse( void )
  582. {
  583. char szMsg[512];
  584. wsprintf( szMsg, (char*)LoadString(GEN_RECEIVED_IN_RESPONSE_TO).c_str(), m_szLineBuff, m_LastCommandString.c_str() );
  585. m_sLastError.assign( szMsg );
  586. SignalEvent( EVENT_ERROR );
  587. }
  589. //////////////////////////////////////////////////////////////////////
  590. // ErrorConnectResponse
  591. //////////////////////////////////////////////////////////////////////
  592. void CModem::ErrorConnectResponse( void )
  593. {
  594. // For now, use the return string as the error description
  595. m_sLastError.assign( m_szLineBuff );
  596. SignalEvent( EVENT_ERROR );
  597. }
  600. void CModem::ProcSupportedSpeeds( LPSTR lpSpeeds, bool bSend )
  601. {
  602. LPSTR lpTok;
  603. int val;
  605. char szDefSpeeds[64];
  607. if( stricmp( m_szLineBuff, "ERROR" ) == 0 )
  608. {
  609. strcpy( szDefSpeeds, "3,24,48,72,73,74,96,97,98,121,122,145,146" );
  610. lpSpeeds = szDefSpeeds;
  611. }
  614. bool* bSupported = (bSend) ? &m_bSendSupported[0] : &m_bRecvSupported[0];
  616. ZeroMemory( bSupported, sizeof(bool) * MAX_CLS1SPEEDS );
  618. lpTok = strtok( lpSpeeds, ",");
  620. while( lpTok ) {
  621. val = atoi( lpTok );
  623. switch( val ) {
  624. case 24:
  625. bSupported[0] = 1;
  626. break;
  628. case 48:
  629. bSupported[1] = 1;
  630. break;
  632. case 72:
  633. bSupported[2] = 1;
  634. break;
  636. case 73:
  637. bSupported[6] = 1;
  638. break;
  640. case 96:
  641. bSupported[3] = 1;
  642. break;
  644. case 97:
  645. bSupported[7] = 1;
  646. break;
  648. case 121:
  649. bSupported[8] = 1;
  650. bSupported[4] = 1;
  651. break;
  653. case 145:
  654. bSupported[9] = 1;
  655. bSupported[5] = 1;
  656. break;
  657. }
  659. lpTok = strtok( NULL, "," );
  660. }
  663. if( bSend )
  664. {
  665. if( m_bSendSupported[9] )
  666. {
  667. m_nMaxSendBaud = 5;
  668. }
  669. else if( m_bSendSupported[8] )
  670. {
  671. m_nMaxSendBaud = 4;
  672. }
  673. else if( m_bSendSupported[7] )
  674. {
  675. m_nMaxSendBaud = 3;
  676. }
  677. else if( m_bSendSupported[6] )
  678. {
  679. m_nMaxSendBaud = 2;
  680. }
  681. else if( m_bSendSupported[1] )
  682. {
  683. m_nMaxSendBaud = 1;
  684. }
  685. else
  686. {
  687. m_nMaxSendBaud = 0;
  688. }
  690. if( m_nSendBaud > m_nMaxSendBaud )
  691. {
  692. m_nSendBaud = m_nMaxSendBaud;
  693. }
  694. }
  695. else
  696. {
  697. if( m_bRecvSupported[9] )
  698. {
  699. m_nMaxRecvBaud = 5;
  700. }
  701. else if( m_bRecvSupported[8] )
  702. {
  703. m_nMaxRecvBaud = 4;
  704. }
  705. else if( m_bRecvSupported[7] )
  706. {
  707. m_nMaxRecvBaud = 3;
  708. }
  709. else if( m_bRecvSupported[6] )
  710. {
  711. m_nMaxRecvBaud = 2;
  712. }
  713. else if( m_bRecvSupported[1] )
  714. {
  715. m_nMaxRecvBaud = 1;
  716. }
  717. else 
  718. {
  719. m_nMaxRecvBaud = 0;
  720. }
  722. if( m_nRecvBaud > m_nMaxRecvBaud )
  723. {
  724. m_nRecvBaud = m_nMaxRecvBaud;
  725. }
  726. }
  727. }
  730. bool CModem::GetCapParam( int nIndex, int nValue )
  731. {
  732. if( nIndex >= 0 && nIndex <= FAXAPI_MAXPARAMETERS && nValue >= 0 && nValue <= FAXAPI_MAXPARAMVALUE )
  733. {
  734. return m_ParamMatrix[nIndex][nValue];
  735. }
  737. return false;
  738. }
  741. int CModem::ProcCapValueIndex( LPSTR lpValue, int nIndex, bool bComma, bool bDash, int nLast )
  742. {
  743. int nCurrent = 0;
  744. char* p = lpValue;
  745. bool bHex = false;
  746. //OnFHNG
  748. while( *p )
  749. {
  750. if( IsHex(*p) )
  751. {
  752. bHex = true;
  753. break;
  754. }
  755. p++;
  756. }
  758. if( bHex )
  759. {
  760. sscanf( lpValue, "%X", &nCurrent );
  761. }
  762. else
  763. {
  764. nCurrent = atoi(lpValue);
  765. }
  767. if( bDash )
  768. {
  769. while( nLast <= nCurrent )
  770. {
  771. if( nIndex >= 0 && nIndex < FAXAPI_MAXPARAMETERS && nLast >= 0 && nLast < FAXAPI_MAXPARAMVALUE )
  772. {
  773. m_ParamMatrix[nIndex][nLast] = true;
  774. }
  775. nLast++;
  776. }
  778. }
  779. else 
  780. {
  781. if( nIndex >= 0 && nIndex < FAXAPI_MAXPARAMETERS && nCurrent >= 0 && nCurrent < FAXAPI_MAXPARAMVALUE )
  782. {
  783. m_ParamMatrix[nIndex][nCurrent] = true;
  784. }
  785. }
  788. return nCurrent;
  789. }
  792. void CModem::ProcCapValue( LPSTR lpValue, int nIndex )
  793. {
  794. char szN[32];
  795. bool bComma = false;
  796. bool bDash = false;
  797. int nLast = 0;
  799. int i = 0;
  801. char* p = lpValue;
  803. while( *p )
  804. {
  805. bool bProcessNumber = false;
  807. if( *p == ',' )
  808. {
  809. szN[i] = 0;
  810. nLast = ProcCapValueIndex( szN, nIndex, bComma, bDash, nLast );
  811. bComma = true;
  812. bDash = false;
  813. i = 0;
  814. }
  815. else if( *p == '-' )
  816. {
  817. szN[i] = 0;
  818. nLast = ProcCapValueIndex( szN, nIndex, bComma, bDash, nLast );
  819. bDash = true;
  820. bComma = false;
  821. i = 0;
  822. }
  823. else if( IsHexDigit( *p ) )
  824. {
  825. szN[i++] = *p;
  826. }
  828. p++;
  830. if( *p == ''  )
  831. {
  832. szN[i] = 0;
  833. nLast = ProcCapValueIndex( szN, nIndex, bComma, bDash, nLast );
  834. i = 0;
  835. }
  837. }
  838. }
  841. void CModem::ProcCapabilities( LPSTR lpCaps )
  842. {
  843. char szValue[32];
  844. bool bInParens = false;
  845. int i = 0;
  846. int j = 0;
  848. ZeroMemory( m_ParamMatrix, sizeof(m_ParamMatrix) );
  850. char* p = lpCaps;
  852. while( *p )
  853. {
  854. bool bProcessNumber = false;
  856. if( bInParens == false )
  857. {
  858. if( *p == '(' )
  859. {
  860. bInParens = true;
  861. }
  862. else if( *p == ',' )
  863. {
  864. bProcessNumber = true;
  865. }
  866. else 
  867. {
  868. if( i < (sizeof(szValue) - 1) )
  869. {
  870. szValue[i++] = *p;
  871. }
  872. }
  873. }
  874. else
  875. {
  876. if( *p == ')' )
  877. {
  878. bInParens = false;
  879. }
  880. else 
  881. {
  882. if( i < (sizeof(szValue) - 1) )
  883. {
  884. szValue[i++] = *p;
  885. }
  886. }
  887. }
  888. p++;
  890. if( *p == '' || bProcessNumber )
  891. {
  892. szValue[i] = 0;
  893. ProcCapValue( szValue, j );
  894. // next element
  895. i = 0;
  896. j++;
  897. }
  898. }
  899. }
  901. //////////////////////////////////////////////////////////////////////
  902. // Handle wait timeout - do periodic processing
  903. //////////////////////////////////////////////////////////////////////
  904. bool CModem::OnWaitTimeout( void )
  905. {
  906. DWORD nInActive = GetTickCount() - m_dwActivityTimer;
  908. CheckTimeouts( nInActive );
  910. return false;
  911. }
  914. void CModem::CheckTimeouts( DWORD dwInActive )
  915. {
  916. }
  919. void CModem::PurgeWriteQueue( void )
  920. {
  921. // Purge write queue
  922. deque<CWriteBuffer*>::iterator iter = m_WriteQueue.begin();
  924. while( iter != m_WriteQueue.end() )
  925. {
  926. delete (*iter);
  927. m_WriteQueue.pop_front();
  928. iter = m_WriteQueue.begin();
  929. }
  930. }
  933. void CModem::PurgeOutput( void )
  934. {
  935. PurgeWriteQueue();
  937. PurgeComm( m_hPort, PURGE_TXABORT | PURGE_TXCLEAR );
  938. }
  941. void CModem::DoHangup( void )
  942. {
  943. SendCommand( COMMAND_HANGUP );
  944. m_nState = STATE_DISCONNECT;
  945. }
  947. void CModem::PhaseHangup(void)
  948. {
  949. // if( strnicmp( m_szLineBuff, "OK", 2 ) == 0 )
  950. {
  951. m_bGotOK = true;
  952. KillTimer( TIMER_COMMAND );
  953. m_nState = STATE_IDLE;
  954. SignalEvent( EVENT_IDLE );
  955. }
  956. }
  959. void CModem::PhaseDisconnect(void)
  960. {
  961. // if( strnicmp( m_szLineBuff, "OK", 2 ) == 0 )
  962. {
  963. m_bGotOK = true;
  964. KillTimer( TIMER_COMMAND );
  965. DisconnectPort();
  966. m_nState = STATE_NONE;
  967. SignalEvent( EVENT_DISCONNECT );
  968. m_bConnected = false;
  969. ExitAndDelete();
  970. }
  971. }
  973. void CModem::Terminate()
  974. {
  975. if( m_bTerminated == false )
  976. {
  977. SignalEvent( EVENT_TERMINATE );
  979. PurgeWriteQueue();
  981. m_FaxFile.Close();
  983. KillTimer( TIMER_MAXPAGERETRIES );
  985. m_bTerminated = true;
  986. }
  987. }
  990. bool CModem::OkToAnswer( void )
  991. {
  992. return ( m_bEnableReceive && (m_nRingCount >= m_nAnswerOnRing) );
  993. }
  996. //////////////////////////////////////////////////////////////////////
  997. // OnRead
  998. //////////////////////////////////////////////////////////////////////
  999. void CModem::OnRead(void)
  1000. {
  1001. DWORD i;
  1003. m_dwActivityTimer = GetTickCount();
  1005. // char szMsg[80];
  1006. // wsprintf( szMsg, "OnRead %d bytesn", m_BytesRead );
  1007. // OutputDebugString( szMsg );
  1009. for( i = 0; i < m_BytesRead; i++ )
  1010. {
  1011. //char szDigit[32];
  1012. //wsprintf( szDigit, "%d:[%02x]n", i, m_szReadBuff[i] );
  1013. //OutputDebugString( szDigit );
  1015. if( m_bEolFlag )
  1016. {
  1017. if( (m_szReadBuff[i] != 'r') && (m_szReadBuff[i] != 'n') )
  1018. {
  1019. m_bEolFlag = false;
  1020. }
  1021. }
  1023. if( !m_bEolFlag )
  1024. {
  1025. if( m_bHDLCMode ) // HDLC mode
  1026. {
  1027. if( m_bGotDLE ) 
  1028. {
  1029. m_bGotDLE = false;
  1031. if( m_szReadBuff[i] == ETX )
  1032. {
  1033. OnHDLCFrame();
  1034. InitLineParser();
  1035. m_bHDLCMode = false;
  1036. }
  1037. else if( m_szReadBuff[i] == DLE )
  1038. {
  1039. if( m_nHDLCBuffPtr >= READBUF_SIZE )
  1040. {
  1041. OnPartialHDLCFrame();
  1042. m_nHDLCBuffPtr = 0;
  1043. }
  1045. m_szHDLCBuff[m_nHDLCBuffPtr++] = m_szReadBuff[i];
  1046. }
  1047. else if( m_szReadBuff[i] == SUB )
  1048. {
  1049. if( m_nHDLCBuffPtr >= READBUF_SIZE )
  1050. {
  1051. OnPartialHDLCFrame();
  1052. m_nHDLCBuffPtr = 0;
  1053. }
  1055. m_szHDLCBuff[m_nHDLCBuffPtr++] = DLE;
  1057. if( m_nHDLCBuffPtr >= READBUF_SIZE )
  1058. {
  1059. OnPartialHDLCFrame();
  1060. m_nHDLCBuffPtr = 0;
  1061. }
  1063. m_szHDLCBuff[m_nHDLCBuffPtr++] = DLE;
  1064. }
  1065. else
  1066. {
  1067. //OutputDebugString( "Illegal HDLC Coding!n" );
  1068. }
  1069. }
  1070. else
  1071. {
  1072. if( m_szReadBuff[i] == DLE )
  1073. {
  1074. m_bGotDLE = true;
  1075. }
  1076. else
  1077. {
  1078. if( m_nHDLCBuffPtr >= READBUF_SIZE )
  1079. {
  1080. OnPartialHDLCFrame();
  1081. InitHDLC();
  1082. }
  1084. m_szHDLCBuff[m_nHDLCBuffPtr++] = m_szReadBuff[i];
  1085. }
  1086. }
  1088. // Sometimes NO CARRIER is returned w/o DLE-ETX
  1089. if( (m_nHDLCBuffPtr > 9) && (m_nHDLCBuffPtr < 14) && strstr( (char*) m_szHDLCBuff, "NO CARRIER" ) )
  1090. {
  1091. m_bHDLCMode = false;
  1092. memcpy( m_szLineBuff, m_szHDLCBuff, m_nHDLCBuffPtr );
  1093. m_nLineBuffPtr = m_nHDLCBuffPtr;
  1094. m_szLineBuff[m_nLineBuffPtr] = '';
  1095. OnReadLine();
  1096. InitLineParser();
  1097. }
  1099. }
  1100. else // line mode
  1101. {
  1102. if( (m_szReadBuff[i] == 'r') || (m_szReadBuff[i] == 'n') )
  1103. {
  1104. m_bEolFlag = true;
  1106. if( m_nLineBuffPtr > 0 )
  1107. {
  1108. m_szLineBuff[m_nLineBuffPtr] = '';
  1110. //char szMsg[256];
  1111. //wsprintf( szMsg, "OnRead:(%d:%d)n", m_BytesRead, i );
  1112. //OutputDebugString( szMsg );
  1114. // Ignore intermediate responses in init state
  1115. if( ( m_nState > STATE_INIT ) || ((m_BytesRead - i) <= 2 ) )
  1116. {
  1117. OnReadLine();
  1118. }
  1119. else if( ( m_nState == STATE_INIT) && 
  1120.      ((m_nLastCommand == COMMAND_QUERY_SEND_SPEEDS)||
  1121.   (m_nLastCommand == COMMAND_QUERY_RECEIVE_SPEEDS)||
  1122.   (m_nLastCommand >= COMMAND_QUERY_FCLASS)) )
  1124. {
  1125. OnReadLine();
  1126. }
  1128. if( !m_bHDLCMode )
  1129. {
  1130. InitLineParser();
  1131. }
  1132. }
  1133. }
  1134. else
  1135. {
  1136. if( m_nLineBuffPtr >= READBUF_SIZE )
  1137. {
  1138. //OutputDebugString( "Line buffer overflow!n" );
  1139. InitLineParser();
  1140. }
  1141. m_szLineBuff[m_nLineBuffPtr++] = m_szReadBuff[i];
  1142. }
  1143. }
  1144. }
  1145. }
  1146. }
  1150. void CModem::OnHDLCFrame(void)
  1151. {
  1152. }
  1154. void CModem::OnPartialHDLCFrame(void)
  1155. {
  1156. }
  1158. void CModem::OnTimer( UINT nID )
  1159. {
  1160. //OutputDebugString( "CModem::OnTimern" );
  1161. }
  1163. //////////////////////////////////////////////////////////////////////
  1164. // HandleMsg
  1165. //////////////////////////////////////////////////////////////////////
  1166. LRESULT CModem::HandleMsg( UINT message, WPARAM wParam, LPARAM lParam )
  1167. {
  1169. if( message == WM_TIMER )
  1170. {
  1171. OnTimer( wParam );
  1172. }
  1174. return DefWindowProc( m_hwnd, message, wParam, lParam );
  1175. }
  1179. int CModem::ParseFaxParams( int nMaxParams, int* pParams )
  1180. {
  1181. char szNumBuff[21];
  1182. int j;
  1183. int i;
  1185. ZeroMemory( pParams, sizeof(int) * nMaxParams );
  1187. char* p = m_szLineBuff + 5; // Skip +XXXX
  1189. if ( *p == ':' ) // skip the colon
  1190. {
  1191. p++;
  1192. }
  1194. // advance to first digit
  1195. while( *p && (IsHexDigit(*p) == false) && (*p != ',') )
  1196. {
  1197. p++;
  1198. }
  1200. for( i = 0; i < nMaxParams; i++ )
  1201. {
  1202. // check for end of string
  1203. if( *p == '' )
  1204. {
  1205. return i;
  1206. }
  1208. j = 0;
  1210. // advance to next comma
  1211. while( *p && IsHexDigit(*p) && (j < 20) )
  1212. {
  1213. szNumBuff[j++] = *p++;
  1214. }
  1216. szNumBuff[j] = '';
  1218. pParams[i] = atoi( szNumBuff );
  1220. if( *p ) // advance past comma
  1221. p++;
  1222. }
  1224. return i;
  1225. }
  1228. void CModem::ExitAndDelete(void)
  1229. {
  1230. OnShutdown();
  1232. delete this;
  1234. ExitThread(0);
  1235. }
  1237. bool CModem::IsRing(void)
  1238. {
  1239. if( stricmp( m_szLineBuff, "RING" ) == 0 )
  1240. {
  1241. return true;
  1242. }
  1244. if( !m_sRingCodes.empty() )
  1245. {
  1246. if( strchr( m_sRingCodes.c_str(), '1' ) )
  1247. {
  1248. if( ( stricmp( m_szLineBuff, "RING1" ) == 0 ) || ( stricmp( m_szLineBuff, "RINGA" ) == 0 ) )
  1249. {
  1250. return true;
  1251. }
  1252. }
  1253. if( strchr( m_sRingCodes.c_str(), '2' ) )
  1254. {
  1255. if( ( stricmp( m_szLineBuff, "RING2" ) == 0 ) || ( stricmp( m_szLineBuff, "RINGB" ) == 0 ) )
  1256. {
  1257. return true;
  1258. }
  1259. }
  1260. if( strchr( m_sRingCodes.c_str(), '3' ) )
  1261. {
  1262. if( ( stricmp( m_szLineBuff, "RING3" ) == 0 ) || ( stricmp( m_szLineBuff, "RINGC" ) == 0 ) )
  1263. {
  1264. return true;
  1265. }
  1266. }
  1267. }
  1269. return false;
  1270. }
  1273. void CModem::AbortFax(void)
  1274. {
  1275. PostMsg( WM_MODEM_ABORTFAX, 0, 0 );
  1276. }
  1279. bool CModem::IsHexDigit( char digit )
  1280. {
  1281. return (strchr( "1234567890ABCDEFabcdef", digit ) != NULL);
  1282. }
  1284. bool CModem::IsHex( char digit )
  1285. {
  1286. return (strchr( "ABCDEFabcdef", digit ) != NULL);
  1287. }
  1290. void CModem::Abort( bool bUserCancelled )
  1291. {
  1292. }
  1294. void CModem::ClearRingCount(void) 
  1295. { 
  1296. PostMsg( WM_MODEM_CLEARRINGCNT, 0, 0 );
  1297. };
  1300. void CModem::SetMaxPageRetriesTimer(void)
  1301. {
  1302. DWORD dwTimeout = 0;
  1304. if( m_nMaxPageRetries < 1 )
  1305. return;
  1307. int nPageNo = GetPageCount();
  1309. if( nPageNo > m_nMaxPageRetriesPageNo )
  1310. {
  1311. KillTimer( TIMER_MAXPAGERETRIES );
  1313. m_nMaxPageRetriesPageNo = nPageNo;
  1315. // have to be careful how this timeout is computed so we don't overflow
  1316. unsigned int nSecsPerPage = m_FaxFile.GetTotalPageSize() / (Cls2FaxParamBitRates[m_DCSParams.p.BitRate] / 8) ;
  1318. dwTimeout = m_nMaxPageRetries * 1000 * (15 + nSecsPerPage);
  1320. SetTimer( TIMER_MAXPAGERETRIES, dwTimeout );
  1322. //char szMsg[128];
  1323. //wsprintf( szMsg, "Setting timeout %d for page %d (%d bytes) Bitrate=%dn", dwTimeout, nPageNo, m_FaxFile.GetTotalPageSize(), Cls2FaxParamBitRates[m_DCSParams.p.BitRate] );
  1324. //OutputDebugString( szMsg );
  1325. }
  1326. }