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

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

传真(Fax)编程

开发平台：

Visual C++

FaxAPI.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. #include "stdafx.h"
  18. #include "FaxAPI.h"
  20. #include "ModemDetect.h"
  21. #include "ClassOne.h"
  22. #include "ClassOnePointZero.h"
  23. #include "ClassTwo.h"
  24. #include "ClassTwoPointZero.h"
  25. #include "ClassTwoPointOne.h"
  27. HINSTANCE g_Instance = NULL;
  29. //////////////////////////////////////////////////////////////////////
  30. // TiffWarningHandler
  31. //////////////////////////////////////////////////////////////////////
  32. static void TiffWarningHandler(const char* module, const char* fmt, va_list ap)
  33. {
  34. #ifdef DEBUG
  35. char buf[256] = {0};
  36. _vsnprintf( buf, sizeof(buf) - 1, fmt, ap);
  37. OutputDebugString( "Warning: " );
  38. OutputDebugString( buf );
  39. OutputDebugString( "n" );
  40. #endif
  41. }
  43. //////////////////////////////////////////////////////////////////////
  44. // TiffErrorHandler
  45. //////////////////////////////////////////////////////////////////////
  46. static void TiffErrorHandler(const char* module, const char* fmt, va_list ap)
  47. {
  48. #ifdef DEBUG
  49. char buf[256] = {0};
  50. _vsnprintf( buf, sizeof(buf) - 1, fmt, ap);
  51. OutputDebugString( "Error: " );
  52. OutputDebugString( buf );
  53. OutputDebugString( "n" );
  54. #endif
  55. }
  57. //////////////////////////////////////////////////////////////////////
  58. // DllMain
  59. //////////////////////////////////////////////////////////////////////
  60. BOOL APIENTRY DllMain( HANDLE hModule, 
  61.                        DWORD  dwReason, 
  62.                        LPVOID lpReserved
  63.  )
  64. {
  66. switch (dwReason)
  67. {
  68. case DLL_PROCESS_ATTACH:
  69. g_Instance = (HINSTANCE)hModule;
  70. CHiddenWindow::RegisterWindowClass( g_Instance );
  72. // set tiff error handlers
  73. TIFFSetErrorHandler( TiffErrorHandler );
  74. TIFFSetWarningHandler( TiffWarningHandler );
  76. break;
  78. case DLL_PROCESS_DETACH:
  79. CHiddenWindow::UnRegisterWindowClass();
  80. break;
  81. }
  83.     return TRUE;
  84. }
  87. //////////////////////////////////////////////////////////////////////
  88. // FaxApiGetModem - internal function
  89. //////////////////////////////////////////////////////////////////////
  90. CModem* FaxApiGetModem( FaxApiModem pModem )
  91. {
  92. // check the obvious
  93. if( pModem == NULL )
  94. return NULL;
  96. // and the not so obvious
  97. if( IsBadWritePtr( pModem, sizeof(CModem) ) )
  98. {
  99. return NULL;
  100. }
  102. // cast it
  103. return (CModem*) pModem;
  104. }
  107. //////////////////////////////////////////////////////////////////////
  108. // FaxApiCreateModem
  109. //////////////////////////////////////////////////////////////////////
  110. FaxApiModem FAXAPI_CALL FaxApiCreateModem( int nClass )
  111. {
  112. FaxApiModem pModem = NULL;
  113. CModem* pMdm;
  115. switch( nClass )
  116. {
  117. case FAXAPI_DETECT:
  118. pMdm = new CModemDetect;
  119. break;
  121. case FAXAPI_CLASS_1:
  122. pMdm = new CClassOne;
  123. break;
  125. case FAXAPI_CLASS_1_0:
  126. pMdm = new CClassOnePointZero;
  127. break;
  129. case FAXAPI_CLASS_2:
  130. pMdm = new CClassTwo;
  131. break;
  133. case FAXAPI_CLASS_2_0:
  134. pMdm = new CClassTwoPointZero;
  135. break;
  137. case FAXAPI_CLASS_2_1:
  138. pMdm = new CClassTwoPointOne;
  139. break;
  141. default:
  142. pMdm = NULL;
  143. break;
  144. }
  146. if( pMdm )
  147. {
  148. pModem = pMdm;
  149. }
  151. return pModem;
  152. }
  156. //////////////////////////////////////////////////////////////////////
  157. // FaxApiDeleteMessage
  158. //////////////////////////////////////////////////////////////////////
  159. int FAXAPI_CALL FaxApiDeleteMessage( MSG* pMsg )
  160. {
  161. // todo: check pMsg->cbm_cbSize
  163. if( pMsg == NULL )
  164. {
  165. return FAXAPI_ERROR_BAD_MSG;
  166. }
  168. if( pMsg->lParam == NULL )
  169. {
  170. return FAXAPI_ERROR_BAD_MSG;
  171. }
  173. switch( pMsg->lParam )
  174. {
  175. case FAXAPI_EVENT_DETECT_FINISHED:
  176. {
  177. FaxApiModemDetectMsg* pMMsg = (FaxApiModemDetectMsg*)pMsg->wParam;
  179. if( IsBadWritePtr( pMMsg, sizeof(FaxApiModemDetectMsg) ) )
  180. {
  181. return FAXAPI_ERROR_BAD_MSG;
  182. }
  184. delete pMMsg;
  185. }
  186. break;
  188. default:
  189. {
  190. FaxApiModemMsg* pMMsg = (FaxApiModemMsg*)pMsg->wParam;
  192. if( IsBadWritePtr( pMMsg, sizeof(FaxApiModemMsg) ) )
  193. {
  194. return FAXAPI_ERROR_BAD_MSG;
  195. }
  197. delete pMMsg;
  198. }
  199. }
  201. return FAXAPI_SUCCESS;
  202. }
  205. //////////////////////////////////////////////////////////////////////
  206. // FaxApiSetCommParam
  207. //////////////////////////////////////////////////////////////////////
  208. int FAXAPI_CALL FaxApiSetCommParam( FaxApiModem pModem, DWORD BaudRate, BYTE ByteSize, BYTE Parity, BYTE StopBits )
  209. {
  210. CModem* pMdm = FaxApiGetModem( pModem );
  212. if( pMdm == NULL )
  213. {
  214. return FAXAPI_ERROR_BAD_MODEM;
  215. }
  217. if( pMdm->ThreadStarted() )
  218. {
  219. // can't change the port once the thread is started.
  220. return FAXAPI_ERROR_THREAD_STARTED;
  221. }
  223. pMdm->SetCommParam( BaudRate, ByteSize, Parity, StopBits );
  225. return FAXAPI_SUCCESS;
  226. }
  228. //////////////////////////////////////////////////////////////////////
  229. // FaxApiSetFlowControl
  230. //////////////////////////////////////////////////////////////////////
  231. int FAXAPI_CALL FaxApiSetFlowControl( FaxApiModem pModem, bool bDSRFlowControl, bool bCTSFlowControl, bool bSoftFlowControl )
  232. {
  233. CModem* pMdm = FaxApiGetModem( pModem );
  235. if( pMdm == NULL )
  236. {
  237. return FAXAPI_ERROR_BAD_MODEM;
  238. }
  240. if( pMdm->ThreadStarted() )
  241. {
  242. // can't change the port once the thread is started.
  243. return FAXAPI_ERROR_THREAD_STARTED;
  244. }
  246. pMdm->SetFlowControl( bDSRFlowControl, bCTSFlowControl, bSoftFlowControl );
  248. return FAXAPI_SUCCESS;
  249. }
  252. //////////////////////////////////////////////////////////////////////
  253. // FaxApiSetPort
  254. //////////////////////////////////////////////////////////////////////
  255. int FAXAPI_CALL FaxApiSetPort( FaxApiModem pModem, char* szPort )
  256. {
  257. CModem* pMdm = FaxApiGetModem( pModem );
  259. if( pMdm == NULL )
  260. {
  261. return FAXAPI_ERROR_BAD_MODEM;
  262. }
  264. if( pMdm->ThreadStarted() )
  265. {
  266. // can't change the port once the thread is started.
  267. return FAXAPI_ERROR_THREAD_STARTED;
  268. }
  270. pMdm->SetPort( szPort );
  272. return FAXAPI_SUCCESS;
  273. }
  275. //////////////////////////////////////////////////////////////////////
  276. // FaxApiSetSpkrParams
  277. //////////////////////////////////////////////////////////////////////
  278. int FAXAPI_CALL FaxApiSetSpkrParams( FaxApiModem pModem, int nSpkrVol, int nSpkrMode )
  279. {
  280. CModem* pMdm = FaxApiGetModem( pModem );
  282. if( pMdm == NULL )
  283. {
  284. return FAXAPI_ERROR_BAD_MODEM;
  285. }
  287. if( pMdm->ThreadStarted() )
  288. {
  289. // can't change the port once the thread is started.
  290. return FAXAPI_ERROR_THREAD_STARTED;
  291. }
  293. pMdm->SetSpkrParams( nSpkrVol, nSpkrMode );
  295. return FAXAPI_SUCCESS;
  296. }
  298. //////////////////////////////////////////////////////////////////////
  299. // FaxApiSetDistinctiveRing
  300. //////////////////////////////////////////////////////////////////////
  301. int FAXAPI_CALL FaxApiSetDistinctiveRing( FaxApiModem pModem, LPCSTR szRingCodes )
  302. {
  303. CModem* pMdm = FaxApiGetModem( pModem );
  305. if( pMdm == NULL )
  306. {
  307. return FAXAPI_ERROR_BAD_MODEM;
  308. }
  310. if( pMdm->ThreadStarted() )
  311. {
  312. // can't change the port once the thread is started.
  313. return FAXAPI_ERROR_THREAD_STARTED;
  314. }
  316. pMdm->SetDistinctiveRing( szRingCodes );
  318. return FAXAPI_SUCCESS;
  319. }
  321. //////////////////////////////////////////////////////////////////////
  322. // FaxApiSetInitString
  323. //////////////////////////////////////////////////////////////////////
  324. int FAXAPI_CALL FaxApiSetInitString( FaxApiModem pModem, LPCSTR szString )
  325. {
  326. CModem* pMdm = FaxApiGetModem( pModem );
  328. if( pMdm == NULL )
  329. {
  330. return FAXAPI_ERROR_BAD_MODEM;
  331. }
  333. if( pMdm->ThreadStarted() )
  334. {
  335. // can't change the port once the thread is started.
  336. return FAXAPI_ERROR_THREAD_STARTED;
  337. }
  339. pMdm->SetInitString( szString );
  341. return FAXAPI_SUCCESS;
  342. }
  344. //////////////////////////////////////////////////////////////////////
  345. // FaxApiSetSendEncoding
  346. //////////////////////////////////////////////////////////////////////
  347. int FAXAPI_CALL FaxApiSetSendEncoding( FaxApiModem pModem, int nEncoding )
  348. {
  349. CModem* pMdm = FaxApiGetModem( pModem );
  351. if( pMdm == NULL )
  352. {
  353. return FAXAPI_ERROR_BAD_MODEM;
  354. }
  356. if( pMdm->ThreadStarted() )
  357. {
  358. // can't change the port once the thread is started.
  359. return FAXAPI_ERROR_THREAD_STARTED;
  360. }
  362. pMdm->SetSendEncoding( nEncoding );
  364. return FAXAPI_SUCCESS;
  365. }
  367. //////////////////////////////////////////////////////////////////////
  368. // FaxApiSetSendECM
  369. //////////////////////////////////////////////////////////////////////
  370. int FAXAPI_CALL FaxApiSetSendECM( FaxApiModem pModem, bool bECMSupported )
  371. {
  372. CModem* pMdm = FaxApiGetModem( pModem );
  374. if( pMdm == NULL )
  375. {
  376. return FAXAPI_ERROR_BAD_MODEM;
  377. }
  379. if( pMdm->ThreadStarted() )
  380. {
  381. // can't change the port once the thread is started.
  382. return FAXAPI_ERROR_THREAD_STARTED;
  383. }
  385. pMdm->SetSendECM( bECMSupported );
  387. return FAXAPI_SUCCESS;
  388. }
  390. //////////////////////////////////////////////////////////////////////
  391. // FaxApiSetSendFine
  392. //////////////////////////////////////////////////////////////////////
  393. int FAXAPI_CALL FaxApiSetSendFine( FaxApiModem pModem, bool bFineSupported )
  394. {
  395. CModem* pMdm = FaxApiGetModem( pModem );
  397. if( pMdm == NULL )
  398. {
  399. return FAXAPI_ERROR_BAD_MODEM;
  400. }
  402. if( pMdm->ThreadStarted() )
  403. {
  404. // can't change the port once the thread is started.
  405. return FAXAPI_ERROR_THREAD_STARTED;
  406. }
  408. pMdm->SetSendFine( bFineSupported );
  410. return FAXAPI_SUCCESS;
  411. }
  413. //////////////////////////////////////////////////////////////////////
  414. // FaxApiSetSendUnlimited
  415. //////////////////////////////////////////////////////////////////////
  416. int FAXAPI_CALL FaxApiSetSendUnlimited( FaxApiModem pModem, bool bUnlimitedSupported )
  417. {
  418. CModem* pMdm = FaxApiGetModem( pModem );
  420. if( pMdm == NULL )
  421. {
  422. return FAXAPI_ERROR_BAD_MODEM;
  423. }
  425. if( pMdm->ThreadStarted() )
  426. {
  427. // can't change the port once the thread is started.
  428. return FAXAPI_ERROR_THREAD_STARTED;
  429. }
  431. pMdm->SetSendUnlimited( bUnlimitedSupported );
  433. return FAXAPI_SUCCESS;
  434. }
  436. //////////////////////////////////////////////////////////////////////
  437. // FaxApiSetPulseDialing
  438. //////////////////////////////////////////////////////////////////////
  439. int FAXAPI_CALL FaxApiSetPulseDialing( FaxApiModem pModem, bool bPulseDialing )
  440. {
  441. CModem* pMdm = FaxApiGetModem( pModem );
  443. if( pMdm == NULL )
  444. {
  445. return FAXAPI_ERROR_BAD_MODEM;
  446. }
  448. if( pMdm->ThreadStarted() )
  449. {
  450. // can't change the port once the thread is started.
  451. return FAXAPI_ERROR_THREAD_STARTED;
  452. }
  454. pMdm->SetPulseDialing( bPulseDialing );
  456. return FAXAPI_SUCCESS;
  457. }
  459. //////////////////////////////////////////////////////////////////////
  460. // FaxApiEnableDebugLog
  461. //////////////////////////////////////////////////////////////////////
  462. int FAXAPI_CALL FaxApiEnableDebugLog( FaxApiModem pModem, bool bEnable, char* LogDirectory )
  463. {
  464. CModem* pMdm = FaxApiGetModem( pModem );
  466. if( pMdm == NULL )
  467. {
  468. return FAXAPI_ERROR_BAD_MODEM;
  469. }
  471. if( pMdm->ThreadStarted() )
  472. {
  473. // can't change the port once the thread is started.
  474. return FAXAPI_ERROR_THREAD_STARTED;
  475. }
  477. pMdm->EnableDebugLog( bEnable, LogDirectory );
  479. return FAXAPI_SUCCESS;
  480. }
  482. //////////////////////////////////////////////////////////////////////
  483. // FaxApiEnableDebugLog
  484. //////////////////////////////////////////////////////////////////////
  486. int FAXAPI_CALL FaxApiSetMaxPageRetries( FaxApiModem pModem, int nRetries )
  487. {
  488. CModem* pMdm = FaxApiGetModem( pModem );
  490. if( pMdm == NULL )
  491. {
  492. return FAXAPI_ERROR_BAD_MODEM;
  493. }
  495. if( pMdm->ThreadStarted() )
  496. {
  497. // can't change the port once the thread is started.
  498. return FAXAPI_ERROR_THREAD_STARTED;
  499. }
  501. pMdm->SetMaxPageRetries( nRetries );
  503. return FAXAPI_SUCCESS;
  504. }
  506. //////////////////////////////////////////////////////////////////////
  507. // FaxApiSetCSID
  508. //////////////////////////////////////////////////////////////////////
  509. int FAXAPI_CALL FaxApiSetCSID( FaxApiModem pModem, LPCSTR szString )
  510. {
  511. CModem* pMdm = FaxApiGetModem( pModem );
  513. if( pMdm == NULL )
  514. {
  515. return FAXAPI_ERROR_BAD_MODEM;
  516. }
  518. if( pMdm->ThreadStarted() )
  519. {
  520. pMdm->ChangeCSID( szString );
  521. return FAXAPI_SUCCESS;
  522. }
  524. pMdm->SetCSID( szString );
  526. return FAXAPI_SUCCESS;
  527. }
  529. //////////////////////////////////////////////////////////////////////
  530. // FaxApiSetSendBaud
  531. //////////////////////////////////////////////////////////////////////
  532. int FAXAPI_CALL FaxApiSetSendBaud( FaxApiModem pModem, int nBaud )
  533. {
  534. CModem* pMdm = FaxApiGetModem( pModem );
  536. if( pMdm == NULL )
  537. {
  538. return FAXAPI_ERROR_BAD_MODEM;
  539. }
  541. if( pMdm->ThreadStarted() )
  542. {
  543. // can't change the port once the thread is started.
  544. return FAXAPI_ERROR_THREAD_STARTED;
  545. }
  547. pMdm->SetSendBaud( nBaud );
  549. return FAXAPI_SUCCESS;
  550. }
  552. //////////////////////////////////////////////////////////////////////
  553. // FaxApiSetRecvBaud
  554. //////////////////////////////////////////////////////////////////////
  555. int FAXAPI_CALL FaxApiSetRecvBaud( FaxApiModem pModem, int nBaud )
  556. {
  557. CModem* pMdm = FaxApiGetModem( pModem );
  559. if( pMdm == NULL )
  560. {
  561. return FAXAPI_ERROR_BAD_MODEM;
  562. }
  564. if( pMdm->ThreadStarted() )
  565. {
  566. // can't change the port once the thread is started.
  567. return FAXAPI_ERROR_THREAD_STARTED;
  568. }
  570. pMdm->SetRecvBaud( nBaud );
  572. return FAXAPI_SUCCESS;
  573. }
  576. //////////////////////////////////////////////////////////////////////
  577. // FaxApiStartThread
  578. //////////////////////////////////////////////////////////////////////
  579. int FAXAPI_CALL FaxApiStartThread( FaxApiModem pModem, HANDLE hStop, DWORD faxThreadID )
  580. {
  581. CModem* pMdm = FaxApiGetModem( pModem );
  583. if( pMdm == NULL )
  584. {
  585. return FAXAPI_ERROR_BAD_MODEM;
  586. }
  588. if( pMdm->ThreadStarted() )
  589. {
  590. // can't change the port once the thread is started.
  591. return FAXAPI_ERROR_THREAD_STARTED;
  592. }
  594. pMdm->Initialize( hStop, faxThreadID );
  596. return FAXAPI_SUCCESS;
  597. }
  600. //////////////////////////////////////////////////////////////////////
  601. // FaxApiWaitForModemToExit
  602. //////////////////////////////////////////////////////////////////////
  603. int FAXAPI_CALL FaxApiWaitForModemToExit( FaxApiModem pModem )
  604. {
  605. CModem* pMdm = FaxApiGetModem( pModem );
  607. if( pMdm == NULL )
  608. {
  609. return FAXAPI_ERROR_BAD_MODEM;
  610. }
  612. if( pMdm->ThreadStarted() == false)
  613. {
  614. // can't wait for the modem if isn't started
  615. return FAXAPI_ERROR_THREAD_STARTED;
  616. }
  618. DWORD dwResult = WaitForSingleObject( pMdm->GetHandle(), 5000 );
  620. if( dwResult == WAIT_OBJECT_0 )
  621. {
  622. return FAXAPI_SUCCESS;
  623. }
  624. else
  625. {
  626. return FAXAPI_ERROR_BAD_MODEM;
  627. }
  628. }
  631. //////////////////////////////////////////////////////////////////////
  632. // FaxApiSendFax
  633. //////////////////////////////////////////////////////////////////////
  634. bool FAXAPI_CALL FaxApiSendFax( FaxApiModem pModem, char* szNumberToDial, char* szFaxFile )
  635. {
  636. CModem* pMdm = FaxApiGetModem( pModem );
  638. if( pMdm == NULL )
  639. {
  640. return false;
  641. }
  643. if( pMdm->ThreadStarted() == false)
  644. {
  645. // can't wait for the modem if isn't started
  646. return false;
  647. }
  649. return pMdm->SendFax( szNumberToDial, szFaxFile );
  650. }
  653. //////////////////////////////////////////////////////////////////////
  654. // FaxApiReceiveFax
  655. //////////////////////////////////////////////////////////////////////
  656. void FAXAPI_CALL FaxApiReceiveFax( FaxApiModem pModem, char* szFaxFile )
  657. {
  658. CModem* pMdm = FaxApiGetModem( pModem );
  660. if( pMdm == NULL )
  661. {
  662. return;
  663. }
  665. if( pMdm->ThreadStarted() == false)
  666. {
  667. // can't wait for the modem if isn't started
  668. return;
  669. }
  671. pMdm->RecvFax( szFaxFile );
  672. }
  675. //////////////////////////////////////////////////////////////////////
  676. // FaxApiAbortFax
  677. //////////////////////////////////////////////////////////////////////
  678. void FAXAPI_CALL FaxApiAbortFax( FaxApiModem pModem )
  679. {
  680. CModem* pMdm = FaxApiGetModem( pModem );
  682. if( pMdm == NULL )
  683. {
  684. return;
  685. }
  687. if( pMdm->ThreadStarted() == false)
  688. {
  689. // can't abort fax if the modem isn't started
  690. return;
  691. }
  693. pMdm->AbortFax();
  694. }
  696. //////////////////////////////////////////////////////////////////////
  697. // FaxApiDisconnect
  698. //////////////////////////////////////////////////////////////////////
  699. void FAXAPI_CALL FaxApiDisconnect( FaxApiModem pModem )
  700. {
  701. CModem* pMdm = FaxApiGetModem( pModem );
  703. if( pMdm == NULL )
  704. {
  705. return;
  706. }
  708. if( pMdm->ThreadStarted() == false)
  709. {
  710. // can't abort fax if the modem isn't started
  711. return;
  712. }
  714. pMdm->Disconnect();
  715. }
  718. //////////////////////////////////////////////////////////////////////
  719. // FaxApiClearRingCount
  720. //////////////////////////////////////////////////////////////////////
  721. void FAXAPI_CALL FaxApiClearRingCount( FaxApiModem pModem )
  722. {
  723. CModem* pMdm = FaxApiGetModem( pModem );
  725. if( pMdm == NULL )
  726. {
  727. return;
  728. }
  730. if( pMdm->ThreadStarted() == false)
  731. {
  732. return;
  733. }
  735. pMdm->ClearRingCount();
  736. }