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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > TAPI编程 > 查看源码
TapiLine.cpp.svn-base
资源名称：TAPISample.rar　[点击查看]
上传用户：c1686688
上传日期：2015-06-15
资源大小：73k
文件大小：19k
源码类别：

TAPI编程

开发平台：

Visual C++

TapiLine.cpp.svn-base：源码内容
  1. // TapiLine.cpp: implementation of the CTapiLine class.
  2. // Author: T.Yogaramanan
  3. // Include this header if you use any part of the code from this file 
  4. /////////////////////////////////////////////////////////////////////////////
  6. #include "stdafx.h"
  7. #include "TAPISample.h"
  8. #include "TapiLine.h"
  10. #ifdef _DEBUG
  11. #undef THIS_FILE
  12. static char THIS_FILE[]=__FILE__;
  13. #define new DEBUG_NEW
  14. #endif
  16. //////////////////////////////////////////////////////////////////////
  17. // Construction/Destruction
  18. //////////////////////////////////////////////////////////////////////
  20. CTapiLine::CTapiLine()
  21. {
  22. m_hEventFromThread = NULL;
  23. m_hLineMsgThread = NULL;   // TAPI Event monitoring thread.
  24. m_bStopLineEventThread = true; 
  25. m_lEventThreadResult = 0; 
  26. m_dwLineMsg= 0;
  27. m_nDevID = 0;
  28. m_hLineApp = NULL;
  29. m_hLine = NULL;
  30. m_hCall = NULL;
  31. m_bConnected = false;
  33. }
  35. CTapiLine::~CTapiLine()
  36. {
  37. Close();
  38. }
  40. // if nMode = 0 then it is data/fax calls
  41. //    nMode = 1 then it is data/fax/voice calls
  42. int CTapiLine::Open(int nMode)
  43. {
  44. LINEINITIALIZEEXPARAMS stInitParams;
  45. LINEDEVCAPS *lpDevCaps =NULL;
  46. LONG lRet;
  48. DWORD dwMediaMode;
  49. DWORD dwNumDevs =0;
  50. DWORD dwTAPIVer =TAPI_CURRENT_VERSION;;
  51. DWORD dwTmpVer =0;
  52. LINEEXTENSIONID stExtID;
  54. if(!nMode)
  55. dwMediaMode = LINEMEDIAMODE_DATAMODEM; // data/fax this should be
  56. else
  57. dwMediaMode = LINEMEDIAMODE_AUTOMATEDVOICE;// for voice this should be
  59. memset(&stInitParams, 0, sizeof(LINEINITIALIZEEXPARAMS));
  60. // set the options...
  61. stInitParams.dwTotalSize = sizeof(LINEINITIALIZEEXPARAMS);
  62. stInitParams.dwOptions = LINEINITIALIZEEXOPTION_USEEVENT;
  64. // Initialize TAPI.
  65. lRet = lineInitializeEx(&m_hLineApp, NULL, NULL, "CallAnswer", &dwNumDevs, &dwTAPIVer, &stInitParams);
  66. if(lRet)  //error
  67. return lRet;
  69. // Got the event handle...
  70. m_hLineEvent = stInitParams.Handles.hEvent;
  72. m_nDevID = -1;
  73. // go through the device list and select the appropriate device to transfer voice
  74. for(int i=0;i<dwNumDevs;i++)
  75. {
  76. lRet = lineNegotiateAPIVersion(m_hLineApp, i, dwTAPIVer, dwTAPIVer, &dwTmpVer, &stExtID);
  77. if(lRet != 0)
  78. continue;
  80. lpDevCaps = (LINEDEVCAPS *)malloc(sizeof(LINEDEVCAPS)+1024);// Allocate a little extra memory...
  82. memset(lpDevCaps, 0, sizeof(LINEDEVCAPS)+1024);
  83. lpDevCaps->dwTotalSize = sizeof(LINEDEVCAPS)+1024;
  85. lRet = lineGetDevCaps(m_hLineApp, i, dwTmpVer, 0, lpDevCaps);
  87. if(lRet)  //error
  88. {
  89. free(lpDevCaps);
  90. lpDevCaps=NULL;
  91. continue;
  92. }
  94. char *szText = ((char*)lpDevCaps) + lpDevCaps->dwLineNameOffset;// FOR DEBUGGING
  95. // for more refer LINEMEDIAMODE_ Constants in MSDN
  97. if(lpDevCaps->dwMediaModes & dwMediaMode) 
  98. {
  99. free(lpDevCaps);
  100. m_nDevID = i;
  101. break;
  102. }
  103. free(lpDevCaps);
  104. }
  105. if(m_nDevID < 0)
  106. return LINEERR_BADDEVICEID; // no device available
  108. // Open the line...
  109. lRet = lineOpen(m_hLineApp, m_nDevID, &m_hLine, dwTAPIVer, 0x00000000, 1,LINECALLPRIVILEGE_OWNER,dwMediaMode,NULL);
  110. if(lRet)
  111. {
  112. lineShutdown(m_hLineApp);
  113. return lRet;
  114. }
  116. // We want to be notified for everything
  117. lRet = lineSetStatusMessages(m_hLine, 0x1ffffff, 0);
  118. if(lRet)
  119. {
  120. lineShutdown(m_hLineApp);
  121. return lRet;
  122. }
  123. m_bStopLineEventThread = false;
  124. m_hLineMsgThread = CreateThread(NULL,NULL,LineEventThread,this,NULL,0);
  125. m_hEventFromThread = CreateEvent(NULL,0,0,NULL);
  126. return 0;
  127. }
  129. int CTapiLine::Close()
  130. {
  131. LINECALLSTATUS stLineStatus;
  132. LONG lRet;
  134. if(m_hCall)  // Call might be in progress...
  135. {
  136. memset(&stLineStatus, 0, sizeof(LINECALLSTATUS));
  138. lRet = lineGetCallStatus(m_hCall, &stLineStatus); 
  139. // Technically, lineGetCallStatus returns more info than 
  140. // there is in the structure.  Since we don't care about it,
  141. // We just go on our merry way...
  142. if(!lRet) // If it didn't fail, there's at least a call that needs to be droped.
  143. lineDrop(m_hCall, NULL, 0);
  144. }
  145. m_hCall = NULL;
  147. if(m_hLine)
  148. lineClose(m_hLine);
  149. m_hLine = NULL;
  151. if(m_hLineMsgThread)
  152. {
  153. m_bStopLineEventThread = true;  // stop the event waiting thread
  154. WaitForSingleObject(m_hLineMsgThread, INFINITE); // Wait for it to comit suicide..
  155. CloseHandle(m_hLineMsgThread);
  156. CloseHandle(m_hEventFromThread);
  157. }
  158. if(m_hLineApp)
  159. lineShutdown(m_hLineApp);
  160. m_hLineApp = NULL;
  162. m_hLineMsgThread = NULL;
  163. m_hEventFromThread = NULL;
  164. m_hLineMsgThread = NULL;
  166. m_lEventThreadResult = 0; 
  167. m_dwLineMsg= 0;
  168. m_nDevID = -1;
  169. m_bConnected= false;
  170. return 0;
  171. }
  174. int CTapiLine::GetIncomingCall()
  175. {
  176. long lRet;
  178. // set the ring b4 receiving the call
  179. lRet = lineSetNumRings(m_hLine,0,5);
  180. if(lRet)
  181. return lRet;
  183. // Now we wait for notification.
  184. switch(WaitForSingleObject(m_hEventFromThread, INFINITE))
  185. {
  186. case WAIT_OBJECT_0:
  187. if(m_dwLineMsg == LINECALLSTATE_OFFERING)
  188. {
  189. lRet = lineAnswer(m_hCall, NULL, 0);
  190. lRet = (lRet>0)?0:lRet;
  192. if(lRet)
  193. Close();
  194. return lRet;
  195. }
  196. break;
  197. case WAIT_TIMEOUT:
  198. return ERROR_TIMEOUT;
  199. };
  200. return 0xffffffff; // unknown error
  201. }
  203. int CTapiLine::PickupIncomingCall()
  204. {
  205. long lRet;
  207. lRet = linePickup(m_hLine,0,&m_hCall,NULL,NULL);
  209. return (lRet>=0)?0:lRet;
  210. }
  213. int CTapiLine::MakeOutgoingCall(const char *szAddress)
  214. {
  215. long lRet;
  217. LPLINECALLPARAMS lpCallParams;
  219. lpCallParams = (LPLINECALLPARAMS)malloc(sizeof(LINECALLPARAMS)+1024);
  221. memset(lpCallParams,0,sizeof(LINECALLPARAMS)+1024);
  223. lpCallParams->dwTotalSize = sizeof(LINECALLPARAMS)+1024;
  225.     // This is where we configure the line for DATAMODEM usage.
  226.     lpCallParams->dwBearerMode = LINEBEARERMODE_VOICE;
  227.     lpCallParams->dwMediaMode  = LINEMEDIAMODE_DATAMODEM;
  229.     // This specifies that we want to use only IDLE calls and
  230.     // don't want to cut into a call that might not be IDLE (ie, in use).
  231.     lpCallParams->dwCallParamFlags = LINECALLPARAMFLAGS_IDLE;
  232.                                     
  233.     // if there are multiple addresses on line, use first anyway.
  234.     // It will take a more complex application than a simple tty app
  235.     // to use multiple addresses on a line anyway.
  236.     lpCallParams->dwAddressMode = LINEADDRESSMODE_ADDRESSID;
  237.     lpCallParams->dwAddressID = 0;
  239.     // Address we are dialing.
  240.     lpCallParams->dwDisplayableAddressOffset = sizeof(LINECALLPARAMS);
  241.     lpCallParams->dwDisplayableAddressSize = strlen(szAddress);
  242.     strcpy((LPSTR)lpCallParams+sizeof(LINECALLPARAMS), szAddress);
  244. lRet = lineMakeCall(m_hLine, &m_hCall, szAddress, 0, lpCallParams);
  246. return (lRet>=0)?0:lRet;
  247. }
  249. //Author: Ramanan.T
  250. HANDLE CTapiLine::GetHandle(const char *szClassType, long *lError)
  251. {
  252. if(!m_bConnected)
  253. {
  254. *lError = ERROR_DEVICE_NOT_CONNECTED;
  255. return NULL;
  256. }
  258. VARSTRING *pvarStrDevID = (VARSTRING *)malloc(sizeof(VARSTRING)+255);
  260. memset(pvarStrDevID,0,sizeof(VARSTRING)+255);
  261. pvarStrDevID->dwTotalSize = sizeof(VARSTRING)+255;
  263. long lRet = lineGetID(m_hLine,0,m_hCall,LINECALLSELECT_LINE,pvarStrDevID,szClassType);
  264. if(lRet)
  265. {
  266. *lError = lRet;
  267. return NULL;
  268. }
  270. *lError = 0;
  272. return *((LPHANDLE)((char *)pvarStrDevID + pvarStrDevID->dwStringOffset));
  273. }
  275. //Author: Ramanan.T
  276. DWORD WINAPI CTapiLine::LineEventThread(LPVOID lpVoid)
  277. {
  278. CTapiLine *pcTapiLine = (CTapiLine *)lpVoid;
  279. long lRet;
  280. LINEMESSAGE stLineMsg;
  281. LINECALLINFO *lpCallInfo;
  283. while(!pcTapiLine->m_bStopLineEventThread)
  284. {
  285. // Get a TAPI event if available, wait for 10ms just enough to give up quontum
  286. switch(WaitForSingleObject(pcTapiLine->m_hLineEvent, 10))
  287. {
  288. case WAIT_OBJECT_0:
  289. //TAPI's got something
  290. if ((lRet = lineGetMessage(pcTapiLine->m_hLineApp, &stLineMsg, 0)) != 0)
  291. {
  292. pcTapiLine->m_lEventThreadResult = lRet;
  293. return lRet;
  294. }
  295. // Process the retruned msg
  296. switch (stLineMsg.dwMessageID)
  297. {
  298. case LINE_REPLY: // Sent after lineMakeCall or lineDrop
  299. pcTapiLine->m_lEventThreadResult = (LONG)stLineMsg.dwParam2;
  300. break;
  302. case LINE_CALLSTATE:  // Sent after change of call state
  303. switch (stLineMsg.dwParam1)
  304. {
  305. case LINECALLSTATE_OFFERING: //Incoming call is offering.
  306. //  Get the call handle
  307. pcTapiLine->m_hCall = (HCALL)stLineMsg.hDevice;
  309. pcTapiLine->m_dwLineMsg = LINECALLSTATE_OFFERING;
  310. SetEvent(pcTapiLine->m_hEventFromThread);
  311. break;
  313. case LINECALLSTATE_IDLE:
  314. lineDrop(pcTapiLine->m_hCall, NULL, 0);
  315. pcTapiLine->m_hCall = NULL;
  316. break;
  318. case LINECALLSTATE_CONNECTED:
  320. if(stLineMsg.dwCallbackInstance == 1)
  321. {
  322. pcTapiLine->m_dwLineMsg = LINECALLSTATE_CONNECTED;
  323. SetEvent(pcTapiLine->m_hEventFromThread);
  324. pcTapiLine->m_bConnected = true;
  325. }
  327. break;
  329. case LINECALLSTATE_DISCONNECTED:
  330. switch (stLineMsg.dwParam2) 
  331. {// currently these r not handled separately
  332. case LINEDISCONNECTMODE_NORMAL:
  333. case LINEDISCONNECTMODE_UNKNOWN:
  334. case LINEDISCONNECTMODE_REJECT:
  335. case LINEDISCONNECTMODE_PICKUP:
  336. case LINEDISCONNECTMODE_FORWARDED:
  337. case LINEDISCONNECTMODE_BUSY:
  338. case LINEDISCONNECTMODE_NOANSWER:
  339. case LINEDISCONNECTMODE_BADADDRESS:
  340. case LINEDISCONNECTMODE_UNREACHABLE:
  341. case LINEDISCONNECTMODE_CONGESTION:
  342. case LINEDISCONNECTMODE_INCOMPATIBLE:
  343. case LINEDISCONNECTMODE_UNAVAIL:
  344. case LINEDISCONNECTMODE_NODIALTONE:
  345. default:
  346. // Got disconnected, so drop the call
  347. lineDrop((HCALL)stLineMsg.hDevice, NULL, 0);
  348. pcTapiLine->m_bConnected = false;
  349. break;
  350. }
  351. break;
  353. default:
  354. break;
  355. }
  356. break;
  358. case LINE_CALLINFO: //  Call Info is available
  359. if(stLineMsg.dwParam1 == LINECALLINFOSTATE_CALLID)
  360. {  //Caller ID became available.
  361. lpCallInfo = (LINECALLINFO *)malloc(sizeof(LINECALLINFO)+1000);
  362. memset(lpCallInfo, 0, sizeof(LINECALLINFO)+1024);
  363. lpCallInfo->dwTotalSize = sizeof(LINECALLINFO)+1024;
  364. lineGetCallInfo(pcTapiLine->m_hCall, lpCallInfo);
  365. if (lpCallInfo->dwTotalSize < lpCallInfo->dwNeededSize)
  366. {
  367. lpCallInfo = (LINECALLINFO *)realloc(lpCallInfo, lpCallInfo->dwNeededSize);
  368. lineGetCallInfo(pcTapiLine->m_hCall, lpCallInfo);
  369. }
  370. } 
  371. break;
  373. default:
  374. break;
  375. };
  376. break;
  378. case WAIT_TIMEOUT:
  379. break;;
  381. default:
  382. continue;
  383. };
  384. }
  385. return 0;
  386. }
  388. //Author: Ramanan.T
  389. void CTapiLine::GetErrorString(int nError, char *&szErrText)
  390. {
  391. szErrText = (char*)malloc(255);
  392. switch(nError)
  393. {
  394. case LINEERR_ALLOCATED:
  395. strcpy(szErrText,"LINEERR_ALLOCATED");
  396. break;
  397. case LINEERR_BADDEVICEID:
  398. strcpy(szErrText,"LINEERR_BADDEVICEID");
  399. break;
  400. case LINEERR_BEARERMODEUNAVAIL:
  401. strcpy(szErrText,"LINEERR_BEARERMODEUNAVAIL");
  402. break;
  403. case LINEERR_CALLUNAVAIL:
  404. strcpy(szErrText,"LINEERR_CALLUNAVAIL");
  405. break;
  406. case LINEERR_COMPLETIONOVERRUN:
  407. strcpy(szErrText,"LINEERR_COMPLETIONOVERRUN");
  408. break;
  409. case LINEERR_CONFERENCEFULL:
  410. strcpy(szErrText,"LINEERR_CONFERENCEFULL");
  411. break;
  412. case LINEERR_DIALBILLING:
  413. strcpy(szErrText,"LINEERR_DIALBILLING");
  414. break;
  415. case LINEERR_DIALDIALTONE:
  416. strcpy(szErrText,"LINEERR_DIALDIALTONE");
  417. break;
  418. case LINEERR_DIALPROMPT:
  419. strcpy(szErrText,"LINEERR_DIALPROMPT");
  420. break;
  421. case LINEERR_DIALQUIET:
  422. strcpy(szErrText,"LINEERR_DIALQUIET");
  423. break;
  424. case LINEERR_INCOMPATIBLEAPIVERSION:
  425. strcpy(szErrText,"LINEERR_INCOMPATIBLEAPIVERSION");
  426. break;
  427. case LINEERR_INCOMPATIBLEEXTVERSION:
  428. strcpy(szErrText,"LINEERR_INCOMPATIBLEEXTVERSION");
  429. break;          
  430. case LINEERR_INIFILECORRUPT:
  431. strcpy(szErrText,"LINEERR_INIFILECORRUPT");
  432. break;                  
  433. case LINEERR_INUSE:
  434. strcpy(szErrText,"LINEERR_INUSE");
  435. break;                           
  436. case LINEERR_INVALADDRESS:
  437. strcpy(szErrText,"LINEERR_INVALADDRESS");
  438. break;                    
  439. case LINEERR_INVALADDRESSID:
  440. strcpy(szErrText,"LINEERR_INVALADDRESSID");
  441. break;                  
  442. case LINEERR_INVALADDRESSMODE:
  443. strcpy(szErrText,"LINEERR_INVALADDRESSMODE");
  444. break;                
  445. case LINEERR_INVALADDRESSSTATE:
  446. strcpy(szErrText,"LINEERR_INVALADDRESSSTATE");
  447. break;               
  448. case LINEERR_INVALAPPHANDLE:
  449. strcpy(szErrText,"LINEERR_INVALAPPHANDLE");
  450. break;                  
  451. case LINEERR_INVALAPPNAME:
  452. strcpy(szErrText,"LINEERR_INVALAPPNAME");
  453. break;                    
  454. case LINEERR_INVALBEARERMODE:
  455. strcpy(szErrText,"LINEERR_INVALBEARERMODE");
  456. break;                 
  457. case LINEERR_INVALCALLCOMPLMODE:
  458. strcpy(szErrText,"LINEERR_INVALCALLCOMPLMODE");
  459. break;              
  460. case LINEERR_INVALCALLHANDLE:
  461. strcpy(szErrText,"LINEERR_INVALCALLHANDLE");
  462. break;                 
  463. case LINEERR_INVALCALLPARAMS:
  464. strcpy(szErrText,"LINEERR_INVALCALLPARAMS");
  465. break;                 
  466. case LINEERR_INVALCALLPRIVILEGE:
  467. strcpy(szErrText,"LINEERR_INVALCALLPRIVILEGE");
  468. break;              
  469. case LINEERR_INVALCALLSELECT:
  470. strcpy(szErrText,"LINEERR_INVALCALLSELECT");
  471. break;                 
  472. case LINEERR_INVALCALLSTATE:
  473. strcpy(szErrText,"LINEERR_INVALCALLSTATE");
  474. break;                  
  475. case LINEERR_INVALCALLSTATELIST:
  476. strcpy(szErrText,"LINEERR_INVALCALLSTATELIST");
  477. break;              
  478. case LINEERR_INVALCARD:
  479. strcpy(szErrText,"LINEERR_INVALCARD");
  480. break;                       
  481. case LINEERR_INVALCOMPLETIONID:
  482. strcpy(szErrText,"LINEERR_INVALCOMPLETIONID");
  483. break;               
  484. case LINEERR_INVALCONFCALLHANDLE:
  485. strcpy(szErrText,"LINEERR_INVALCONFCALLHANDLE");
  486. break;             
  487. case LINEERR_INVALCONSULTCALLHANDLE:
  488. strcpy(szErrText,"LINEERR_INVALCONSULTCALLHANDLE");
  489. break;          
  490. case LINEERR_INVALCOUNTRYCODE:
  491. strcpy(szErrText,"LINEERR_INVALCOUNTRYCODE");
  492. break;                
  493. case LINEERR_INVALDEVICECLASS:
  494. strcpy(szErrText,"LINEERR_INVALDEVICECLASS");
  495. break;                
  496. case LINEERR_INVALDEVICEHANDLE:
  497. strcpy(szErrText,"LINEERR_INVALDEVICEHANDLE");
  498. break;               
  499. case LINEERR_INVALDIALPARAMS:
  500. strcpy(szErrText,"LINEERR_INVALDIALPARAMS");
  501. break;                 
  502. case LINEERR_INVALDIGITLIST:
  503. strcpy(szErrText,"LINEERR_INVALDIGITLIST");
  504. break;                  
  505. case LINEERR_INVALDIGITMODE:
  506. strcpy(szErrText,"LINEERR_INVALDIGITMODE");
  507. break;                  
  508. case LINEERR_INVALDIGITS:
  509. strcpy(szErrText,"LINEERR_INVALDIGITS");
  510. break;                    
  511. case LINEERR_INVALEXTVERSION:
  512. strcpy(szErrText,"LINEERR_INVALEXTVERSION");
  513. break;                 
  514. case LINEERR_INVALGROUPID:
  515. strcpy(szErrText,"LINEERR_INVALGROUPID");
  516. break;                    
  517. case LINEERR_INVALLINEHANDLE:
  518. strcpy(szErrText,"LINEERR_INVALLINEHANDLE");
  519. break;                
  520. case LINEERR_INVALLINESTATE:
  521. strcpy(szErrText,"LINEERR_INVALLINESTATE");
  522. break;                  
  523. case LINEERR_INVALLOCATION:
  524. strcpy(szErrText,"LINEERR_INVALLOCATION");
  525. break;                   
  526. case LINEERR_INVALMEDIALIST:
  527. strcpy(szErrText,"LINEERR_INVALMEDIALIST");
  528. break;                  
  529. case LINEERR_INVALMEDIAMODE:
  530. strcpy(szErrText,"LINEERR_INVALMEDIAMODE");
  531. break;                  
  532. case LINEERR_INVALMESSAGEID:
  533. strcpy(szErrText,"LINEERR_INVALMESSAGEID");
  534. break;                  
  535. case LINEERR_INVALPARAM:
  536. strcpy(szErrText,"LINEERR_INVALPARAM");
  537. break;                      
  538. case LINEERR_INVALPARKID:
  539. strcpy(szErrText,"LINEERR_INVALPARKID");
  540. break;                     
  541. case LINEERR_INVALPARKMODE:
  542. strcpy(szErrText,"LINEERR_INVALPARKMODE");
  543. break;                   
  544. case LINEERR_INVALPOINTER:
  545. strcpy(szErrText,"LINEERR_INVALPOINTER");
  546. break;                    
  547. case LINEERR_INVALPRIVSELECT:
  548. strcpy(szErrText,"LINEERR_INVALPRIVSELECT");
  549. break;                 
  550. case LINEERR_INVALRATE:
  551. strcpy(szErrText,"LINEERR_INVALRATE");
  552. break;                       
  553. case LINEERR_INVALREQUESTMODE:
  554. strcpy(szErrText,"LINEERR_INVALREQUESTMODE");
  555. break;                
  556. case LINEERR_INVALTERMINALID:
  557. strcpy(szErrText,"LINEERR_INVALTERMINALID");
  558. break;                 
  559. case LINEERR_INVALTERMINALMODE:
  560. strcpy(szErrText,"LINEERR_INVALTERMINALMODE");
  561. break;               
  562. case LINEERR_INVALTIMEOUT:
  563. strcpy(szErrText,"LINEERR_INVALTIMEOUT");
  564. break;                    
  565. case LINEERR_INVALTONE:
  566. strcpy(szErrText,"LINEERR_INVALTONE");
  567. break;                       
  568. case LINEERR_INVALTONELIST:
  569. strcpy(szErrText,"LINEERR_INVALTONELIST");
  570. break;                   
  571. case LINEERR_INVALTONEMODE:
  572. strcpy(szErrText,"LINEERR_INVALTONEMODE");
  573. break;                   
  574. case LINEERR_INVALTRANSFERMODE:
  575. strcpy(szErrText,"LINEERR_INVALTRANSFERMODE");
  576. break;               
  577. case LINEERR_LINEMAPPERFAILED:
  578. strcpy(szErrText,"LINEERR_LINEMAPPERFAILED");
  579. break;                
  580. case LINEERR_NOCONFERENCE:
  581. strcpy(szErrText,"LINEERR_NOCONFERENCE");
  582. break;                    
  583. case LINEERR_NODEVICE:
  584. strcpy(szErrText,"LINEERR_NODEVICE");
  585. break;                        
  586. case LINEERR_NODRIVER:
  587. strcpy(szErrText,"LINEERR_NODRIVER");
  588. break;                        
  589. case LINEERR_NOMEM:
  590. strcpy(szErrText,"LINEERR_NOMEM");
  591. break;                           
  592. case LINEERR_NOREQUEST:
  593. strcpy(szErrText,"LINEERR_NOREQUEST");
  594. break;                       
  595. case LINEERR_NOTOWNER:
  596. strcpy(szErrText,"LINEERR_NOTOWNER");
  597. break;                        
  598. case LINEERR_NOTREGISTERED:
  599. strcpy(szErrText,"LINEERR_NOTREGISTERED");
  600. break;                   
  601. case LINEERR_OPERATIONFAILED:
  602. strcpy(szErrText,"LINEERR_OPERATIONFAILED");
  603. break;                 
  604. case LINEERR_OPERATIONUNAVAIL:
  605. strcpy(szErrText,"LINEERR_OPERATIONUNAVAIL");
  606. break;                
  607. case LINEERR_RATEUNAVAIL:
  608. strcpy(szErrText,"LINEERR_RATEUNAVAIL");
  609. break;                     
  610. case LINEERR_RESOURCEUNAVAIL:
  611. strcpy(szErrText,"LINEERR_RESOURCEUNAVAIL");
  612. break;                 
  613. case LINEERR_REQUESTOVERRUN:
  614. strcpy(szErrText,"LINEERR_REQUESTOVERRUN");
  615. break;                  
  616. case LINEERR_STRUCTURETOOSMALL:
  617. strcpy(szErrText,"LINEERR_STRUCTURETOOSMALL");
  618. break;               
  619. case LINEERR_TARGETNOTFOUND:
  620. strcpy(szErrText,"LINEERR_TARGETNOTFOUND");
  621. break;                  
  622. case LINEERR_TARGETSELF:
  623. strcpy(szErrText,"LINEERR_TARGETSELF");
  624. break;                      
  625. case LINEERR_UNINITIALIZED:
  626. strcpy(szErrText,"LINEERR_UNINITIALIZED");
  627. break;                   
  628. case LINEERR_USERUSERINFOTOOBIG:
  629. strcpy(szErrText,"LINEERR_USERUSERINFOTOOBIG");
  630. break;           
  631. case LINEERR_REINIT:
  632. strcpy(szErrText,"LINEERR_REINIT");
  633. break;
  634. case LINEERR_ADDRESSBLOCKED:
  635. strcpy(szErrText,"LINEERR_ADDRESSBLOCKED");
  636. break;
  637. case LINEERR_BILLINGREJECTED:
  638. strcpy(szErrText,"LINEERR_BILLINGREJECTED");
  639. break;
  640. case LINEERR_INVALFEATURE:
  641. strcpy(szErrText,"LINEERR_INVALFEATURE");
  642. break;
  643. case LINEERR_NOMULTIPLEINSTANCE:
  644. strcpy(szErrText,"LINEERR_NOMULTIPLEINSTANCE");
  645. break;
  646. case LINEERR_INVALAGENTID:
  647. strcpy(szErrText,"LINEERR_INVALAGENTID");
  648. break;
  649. case LINEERR_INVALAGENTGROUP:
  650. strcpy(szErrText,"LINEERR_INVALAGENTGROUP");
  651. break;
  652. case LINEERR_INVALPASSWORD:
  653. strcpy(szErrText,"LINEERR_INVALPASSWORD");
  654. break;
  655. case LINEERR_INVALAGENTSTATE:
  656. strcpy(szErrText,"LINEERR_INVALAGENTSTATE");
  657. break;
  658. case LINEERR_INVALAGENTACTIVITY:
  659. strcpy(szErrText,"LINEERR_INVALAGENTACTIVITY");
  660. break;
  661. case LINEERR_DIALVOICEDETECT:
  662. strcpy(szErrText,"LINEERR_DIALVOICEDETECT");
  663. break;
  664. default:
  665. free(szErrText);
  666. FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,NULL,nError,0,(LPTSTR)&szErrText,0,NULL);
  667. };
  668. }