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

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

TAPI编程

开发平台：

Visual C++

TapiLine.cpp：源码内容
  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. /// 在这个事件上建立信号
  126. m_hEventFromThread = CreateEvent(NULL,0,0,NULL);
  127. return 0;
  128. }
  130. int CTapiLine::Close()
  131. {
  132. LINECALLSTATUS stLineStatus;
  133. LONG lRet;
  135. if(m_hCall)  // Call might be in progress...
  136. {
  137. memset(&stLineStatus, 0, sizeof(LINECALLSTATUS));
  139. lRet = lineGetCallStatus(m_hCall, &stLineStatus); 
  140. // Technically, lineGetCallStatus returns more info than 
  141. // there is in the structure.  Since we don't care about it,
  142. // We just go on our merry way...
  143. if(!lRet) // If it didn't fail, there's at least a call that needs to be droped.
  144. lineDrop(m_hCall, NULL, 0);
  145. }
  146. m_hCall = NULL;
  148. if(m_hLine)
  149. lineClose(m_hLine);
  150. m_hLine = NULL;
  152. if(m_hLineMsgThread)
  153. {
  154. m_bStopLineEventThread = true;  // stop the event waiting thread
  155. WaitForSingleObject(m_hLineMsgThread, INFINITE); // Wait for it to comit suicide..
  156. CloseHandle(m_hLineMsgThread);
  157. CloseHandle(m_hEventFromThread);
  158. }
  159. if(m_hLineApp)
  160. lineShutdown(m_hLineApp);
  161. m_hLineApp = NULL;
  163. m_hLineMsgThread = NULL;
  164. m_hEventFromThread = NULL;
  165. m_hLineMsgThread = NULL;
  167. m_lEventThreadResult = 0; 
  168. m_dwLineMsg= 0;
  169. m_nDevID = -1;
  170. m_bConnected= false;
  171. return 0;
  172. }
  175. int CTapiLine::GetIncomingCall()
  176. {
  177. long lRet;
  179. // set the ring b4 receiving the call
  180. lRet = lineSetNumRings(m_hLine,0,5);
  181. if(lRet)
  182. return lRet;
  184. // Now we wait for notification.
  185. switch(WaitForSingleObject(m_hEventFromThread, INFINITE))
  186. {
  187. case WAIT_OBJECT_0:
  188. if(m_dwLineMsg == LINECALLSTATE_OFFERING)
  189. {
  190. lRet = lineAnswer(m_hCall, NULL, 0);
  191. lRet = (lRet>0)?0:lRet;
  193. if(lRet)
  194. Close();
  195. return lRet;
  196. }
  197. break;
  198. case WAIT_TIMEOUT:
  199. return ERROR_TIMEOUT;
  200. };
  201. return 0xffffffff; // unknown error
  202. }
  204. int CTapiLine::PickupIncomingCall()
  205. {
  206. long lRet;
  208. lRet = linePickup(m_hLine,0,&m_hCall,NULL,NULL);
  210. return (lRet>=0)?0:lRet;
  211. }
  214. int CTapiLine::MakeOutgoingCall(const char *szAddress)
  215. {
  216. long lRet;
  218. LPLINECALLPARAMS lpCallParams;
  220. lpCallParams = (LPLINECALLPARAMS)malloc(sizeof(LINECALLPARAMS)+1024);
  222. memset(lpCallParams,0,sizeof(LINECALLPARAMS)+1024);
  224. lpCallParams->dwTotalSize = sizeof(LINECALLPARAMS)+1024;
  226.     // This is where we configure the line for DATAMODEM usage.
  227.     lpCallParams->dwBearerMode = LINEBEARERMODE_VOICE;
  228.     lpCallParams->dwMediaMode  = LINEMEDIAMODE_DATAMODEM;
  230.     // This specifies that we want to use only IDLE calls and
  231.     // don't want to cut into a call that might not be IDLE (ie, in use).
  232.     lpCallParams->dwCallParamFlags = LINECALLPARAMFLAGS_IDLE;
  233.                                     
  234.     // if there are multiple addresses on line, use first anyway.
  235.     // It will take a more complex application than a simple tty app
  236.     // to use multiple addresses on a line anyway.
  237.     lpCallParams->dwAddressMode = LINEADDRESSMODE_ADDRESSID;
  238.     lpCallParams->dwAddressID = 0;
  240.     // Address we are dialing.
  241.     lpCallParams->dwDisplayableAddressOffset = sizeof(LINECALLPARAMS);
  242.     lpCallParams->dwDisplayableAddressSize = strlen(szAddress);
  243.     strcpy((LPSTR)lpCallParams+sizeof(LINECALLPARAMS), szAddress);
  245. lRet = lineMakeCall(m_hLine, &m_hCall, szAddress, 0, lpCallParams);
  247. return (lRet>=0)?0:lRet;
  248. }
  250. //Author: Ramanan.T
  251. HANDLE CTapiLine::GetHandle(const char *szClassType, long *lError)
  252. {
  253. if(!m_bConnected)
  254. {
  255. *lError = ERROR_DEVICE_NOT_CONNECTED;
  256. return NULL;
  257. }
  259. VARSTRING *pvarStrDevID = (VARSTRING *)malloc(sizeof(VARSTRING)+255);
  261. memset(pvarStrDevID,0,sizeof(VARSTRING)+255);
  262. pvarStrDevID->dwTotalSize = sizeof(VARSTRING)+255;
  264. long lRet = lineGetID(m_hLine,0,m_hCall,LINECALLSELECT_LINE,pvarStrDevID,szClassType);
  265. if(lRet)
  266. {
  267. *lError = lRet;
  268. return NULL;
  269. }
  271. *lError = 0;
  273. return *((LPHANDLE)((char *)pvarStrDevID + pvarStrDevID->dwStringOffset));
  274. }
  276. //Author: Ramanan.T
  277. /// 这里有事件处理函数
  278. DWORD WINAPI CTapiLine::LineEventThread(LPVOID lpVoid)
  279. {
  280. CTapiLine *pcTapiLine = (CTapiLine *)lpVoid;
  281. long lRet;
  282. LINEMESSAGE stLineMsg;
  283. LINECALLINFO *lpCallInfo;
  285. while(!pcTapiLine->m_bStopLineEventThread)
  286. {
  287. // Get a TAPI event if available, wait for 10ms just enough to give up quontum
  288. switch(WaitForSingleObject(pcTapiLine->m_hLineEvent, 10))
  289. {
  290. case WAIT_OBJECT_0:
  291. //TAPI's got something
  292. if ((lRet = lineGetMessage(pcTapiLine->m_hLineApp, &stLineMsg, 0)) != 0)
  293. {
  294. pcTapiLine->m_lEventThreadResult = lRet;
  295. return lRet;
  296. }
  297. // Process the retruned msg
  298. switch (stLineMsg.dwMessageID)
  299. {
  300. case LINE_REPLY: // Sent after lineMakeCall or lineDrop
  301. pcTapiLine->m_lEventThreadResult = (LONG)stLineMsg.dwParam2;
  302. break;
  304. case LINE_CALLSTATE:  // Sent after change of call state
  305. switch (stLineMsg.dwParam1)
  306. {
  307. case LINECALLSTATE_OFFERING: //Incoming call is offering.
  308. //  Get the call handle
  309. pcTapiLine->m_hCall = (HCALL)stLineMsg.hDevice;
  310. ///  设置消息
  311. pcTapiLine->m_dwLineMsg = LINECALLSTATE_OFFERING;
  312. /// 设置事件
  313. SetEvent(pcTapiLine->m_hEventFromThread);
  314. break;
  316. case LINECALLSTATE_IDLE:
  317. lineDrop(pcTapiLine->m_hCall, NULL, 0);
  318. pcTapiLine->m_hCall = NULL;
  319. break;
  321. case LINECALLSTATE_CONNECTED:
  323. if(stLineMsg.dwCallbackInstance == 1)
  324. {
  325. pcTapiLine->m_dwLineMsg = LINECALLSTATE_CONNECTED;
  326. SetEvent(pcTapiLine->m_hEventFromThread);
  327. pcTapiLine->m_bConnected = true;
  328. }
  330. break;
  332. case LINECALLSTATE_DISCONNECTED:
  333. switch (stLineMsg.dwParam2) 
  334. {// currently these r not handled separately
  335. case LINEDISCONNECTMODE_NORMAL:
  336. case LINEDISCONNECTMODE_UNKNOWN:
  337. case LINEDISCONNECTMODE_REJECT:
  338. case LINEDISCONNECTMODE_PICKUP:
  339. case LINEDISCONNECTMODE_FORWARDED:
  340. case LINEDISCONNECTMODE_BUSY:
  341. case LINEDISCONNECTMODE_NOANSWER:
  342. case LINEDISCONNECTMODE_BADADDRESS:
  343. case LINEDISCONNECTMODE_UNREACHABLE:
  344. case LINEDISCONNECTMODE_CONGESTION:
  345. case LINEDISCONNECTMODE_INCOMPATIBLE:
  346. case LINEDISCONNECTMODE_UNAVAIL:
  347. case LINEDISCONNECTMODE_NODIALTONE:
  348. default:
  349. // Got disconnected, so drop the call
  350. lineDrop((HCALL)stLineMsg.hDevice, NULL, 0);
  351. pcTapiLine->m_bConnected = false;
  352. break;
  353. }
  354. break;
  356. default:
  357. break;
  358. }
  359. break;
  361. case LINE_CALLINFO: //  Call Info is available
  362. if(stLineMsg.dwParam1 == LINECALLINFOSTATE_CALLID)
  363. {  //Caller ID became available.
  364. lpCallInfo = (LINECALLINFO *)malloc(sizeof(LINECALLINFO)+1000);
  365. memset(lpCallInfo, 0, sizeof(LINECALLINFO)+1024);
  366. lpCallInfo->dwTotalSize = sizeof(LINECALLINFO)+1024;
  367. lineGetCallInfo(pcTapiLine->m_hCall, lpCallInfo);
  368. if (lpCallInfo->dwTotalSize < lpCallInfo->dwNeededSize)
  369. {
  370. lpCallInfo = (LINECALLINFO *)realloc(lpCallInfo, lpCallInfo->dwNeededSize);
  371. lineGetCallInfo(pcTapiLine->m_hCall, lpCallInfo);
  372. }
  373. } 
  374. break;
  376. default:
  377. break;
  378. };
  379. break;
  381. case WAIT_TIMEOUT:
  382. break;;
  384. default:
  385. continue;
  386. };
  387. }
  388. return 0;
  389. }
  391. //Author: Ramanan.T
  392. void CTapiLine::GetErrorString(int nError, char *&szErrText)
  393. {
  394. szErrText = (char*)malloc(255);
  395. switch(nError)
  396. {
  397. case LINEERR_ALLOCATED:
  398. strcpy(szErrText,"LINEERR_ALLOCATED");
  399. break;
  400. case LINEERR_BADDEVICEID:
  401. strcpy(szErrText,"LINEERR_BADDEVICEID");
  402. break;
  403. case LINEERR_BEARERMODEUNAVAIL:
  404. strcpy(szErrText,"LINEERR_BEARERMODEUNAVAIL");
  405. break;
  406. case LINEERR_CALLUNAVAIL:
  407. strcpy(szErrText,"LINEERR_CALLUNAVAIL");
  408. break;
  409. case LINEERR_COMPLETIONOVERRUN:
  410. strcpy(szErrText,"LINEERR_COMPLETIONOVERRUN");
  411. break;
  412. case LINEERR_CONFERENCEFULL:
  413. strcpy(szErrText,"LINEERR_CONFERENCEFULL");
  414. break;
  415. case LINEERR_DIALBILLING:
  416. strcpy(szErrText,"LINEERR_DIALBILLING");
  417. break;
  418. case LINEERR_DIALDIALTONE:
  419. strcpy(szErrText,"LINEERR_DIALDIALTONE");
  420. break;
  421. case LINEERR_DIALPROMPT:
  422. strcpy(szErrText,"LINEERR_DIALPROMPT");
  423. break;
  424. case LINEERR_DIALQUIET:
  425. strcpy(szErrText,"LINEERR_DIALQUIET");
  426. break;
  427. case LINEERR_INCOMPATIBLEAPIVERSION:
  428. strcpy(szErrText,"LINEERR_INCOMPATIBLEAPIVERSION");
  429. break;
  430. case LINEERR_INCOMPATIBLEEXTVERSION:
  431. strcpy(szErrText,"LINEERR_INCOMPATIBLEEXTVERSION");
  432. break;          
  433. case LINEERR_INIFILECORRUPT:
  434. strcpy(szErrText,"LINEERR_INIFILECORRUPT");
  435. break;                  
  436. case LINEERR_INUSE:
  437. strcpy(szErrText,"LINEERR_INUSE");
  438. break;                           
  439. case LINEERR_INVALADDRESS:
  440. strcpy(szErrText,"LINEERR_INVALADDRESS");
  441. break;                    
  442. case LINEERR_INVALADDRESSID:
  443. strcpy(szErrText,"LINEERR_INVALADDRESSID");
  444. break;                  
  445. case LINEERR_INVALADDRESSMODE:
  446. strcpy(szErrText,"LINEERR_INVALADDRESSMODE");
  447. break;                
  448. case LINEERR_INVALADDRESSSTATE:
  449. strcpy(szErrText,"LINEERR_INVALADDRESSSTATE");
  450. break;               
  451. case LINEERR_INVALAPPHANDLE:
  452. strcpy(szErrText,"LINEERR_INVALAPPHANDLE");
  453. break;                  
  454. case LINEERR_INVALAPPNAME:
  455. strcpy(szErrText,"LINEERR_INVALAPPNAME");
  456. break;                    
  457. case LINEERR_INVALBEARERMODE:
  458. strcpy(szErrText,"LINEERR_INVALBEARERMODE");
  459. break;                 
  460. case LINEERR_INVALCALLCOMPLMODE:
  461. strcpy(szErrText,"LINEERR_INVALCALLCOMPLMODE");
  462. break;              
  463. case LINEERR_INVALCALLHANDLE:
  464. strcpy(szErrText,"LINEERR_INVALCALLHANDLE");
  465. break;                 
  466. case LINEERR_INVALCALLPARAMS:
  467. strcpy(szErrText,"LINEERR_INVALCALLPARAMS");
  468. break;                 
  469. case LINEERR_INVALCALLPRIVILEGE:
  470. strcpy(szErrText,"LINEERR_INVALCALLPRIVILEGE");
  471. break;              
  472. case LINEERR_INVALCALLSELECT:
  473. strcpy(szErrText,"LINEERR_INVALCALLSELECT");
  474. break;                 
  475. case LINEERR_INVALCALLSTATE:
  476. strcpy(szErrText,"LINEERR_INVALCALLSTATE");
  477. break;                  
  478. case LINEERR_INVALCALLSTATELIST:
  479. strcpy(szErrText,"LINEERR_INVALCALLSTATELIST");
  480. break;              
  481. case LINEERR_INVALCARD:
  482. strcpy(szErrText,"LINEERR_INVALCARD");
  483. break;                       
  484. case LINEERR_INVALCOMPLETIONID:
  485. strcpy(szErrText,"LINEERR_INVALCOMPLETIONID");
  486. break;               
  487. case LINEERR_INVALCONFCALLHANDLE:
  488. strcpy(szErrText,"LINEERR_INVALCONFCALLHANDLE");
  489. break;             
  490. case LINEERR_INVALCONSULTCALLHANDLE:
  491. strcpy(szErrText,"LINEERR_INVALCONSULTCALLHANDLE");
  492. break;          
  493. case LINEERR_INVALCOUNTRYCODE:
  494. strcpy(szErrText,"LINEERR_INVALCOUNTRYCODE");
  495. break;                
  496. case LINEERR_INVALDEVICECLASS:
  497. strcpy(szErrText,"LINEERR_INVALDEVICECLASS");
  498. break;                
  499. case LINEERR_INVALDEVICEHANDLE:
  500. strcpy(szErrText,"LINEERR_INVALDEVICEHANDLE");
  501. break;               
  502. case LINEERR_INVALDIALPARAMS:
  503. strcpy(szErrText,"LINEERR_INVALDIALPARAMS");
  504. break;                 
  505. case LINEERR_INVALDIGITLIST:
  506. strcpy(szErrText,"LINEERR_INVALDIGITLIST");
  507. break;                  
  508. case LINEERR_INVALDIGITMODE:
  509. strcpy(szErrText,"LINEERR_INVALDIGITMODE");
  510. break;                  
  511. case LINEERR_INVALDIGITS:
  512. strcpy(szErrText,"LINEERR_INVALDIGITS");
  513. break;                    
  514. case LINEERR_INVALEXTVERSION:
  515. strcpy(szErrText,"LINEERR_INVALEXTVERSION");
  516. break;                 
  517. case LINEERR_INVALGROUPID:
  518. strcpy(szErrText,"LINEERR_INVALGROUPID");
  519. break;                    
  520. case LINEERR_INVALLINEHANDLE:
  521. strcpy(szErrText,"LINEERR_INVALLINEHANDLE");
  522. break;                
  523. case LINEERR_INVALLINESTATE:
  524. strcpy(szErrText,"LINEERR_INVALLINESTATE");
  525. break;                  
  526. case LINEERR_INVALLOCATION:
  527. strcpy(szErrText,"LINEERR_INVALLOCATION");
  528. break;                   
  529. case LINEERR_INVALMEDIALIST:
  530. strcpy(szErrText,"LINEERR_INVALMEDIALIST");
  531. break;                  
  532. case LINEERR_INVALMEDIAMODE:
  533. strcpy(szErrText,"LINEERR_INVALMEDIAMODE");
  534. break;                  
  535. case LINEERR_INVALMESSAGEID:
  536. strcpy(szErrText,"LINEERR_INVALMESSAGEID");
  537. break;                  
  538. case LINEERR_INVALPARAM:
  539. strcpy(szErrText,"LINEERR_INVALPARAM");
  540. break;                      
  541. case LINEERR_INVALPARKID:
  542. strcpy(szErrText,"LINEERR_INVALPARKID");
  543. break;                     
  544. case LINEERR_INVALPARKMODE:
  545. strcpy(szErrText,"LINEERR_INVALPARKMODE");
  546. break;                   
  547. case LINEERR_INVALPOINTER:
  548. strcpy(szErrText,"LINEERR_INVALPOINTER");
  549. break;                    
  550. case LINEERR_INVALPRIVSELECT:
  551. strcpy(szErrText,"LINEERR_INVALPRIVSELECT");
  552. break;                 
  553. case LINEERR_INVALRATE:
  554. strcpy(szErrText,"LINEERR_INVALRATE");
  555. break;                       
  556. case LINEERR_INVALREQUESTMODE:
  557. strcpy(szErrText,"LINEERR_INVALREQUESTMODE");
  558. break;                
  559. case LINEERR_INVALTERMINALID:
  560. strcpy(szErrText,"LINEERR_INVALTERMINALID");
  561. break;                 
  562. case LINEERR_INVALTERMINALMODE:
  563. strcpy(szErrText,"LINEERR_INVALTERMINALMODE");
  564. break;               
  565. case LINEERR_INVALTIMEOUT:
  566. strcpy(szErrText,"LINEERR_INVALTIMEOUT");
  567. break;                    
  568. case LINEERR_INVALTONE:
  569. strcpy(szErrText,"LINEERR_INVALTONE");
  570. break;                       
  571. case LINEERR_INVALTONELIST:
  572. strcpy(szErrText,"LINEERR_INVALTONELIST");
  573. break;                   
  574. case LINEERR_INVALTONEMODE:
  575. strcpy(szErrText,"LINEERR_INVALTONEMODE");
  576. break;                   
  577. case LINEERR_INVALTRANSFERMODE:
  578. strcpy(szErrText,"LINEERR_INVALTRANSFERMODE");
  579. break;               
  580. case LINEERR_LINEMAPPERFAILED:
  581. strcpy(szErrText,"LINEERR_LINEMAPPERFAILED");
  582. break;                
  583. case LINEERR_NOCONFERENCE:
  584. strcpy(szErrText,"LINEERR_NOCONFERENCE");
  585. break;                    
  586. case LINEERR_NODEVICE:
  587. strcpy(szErrText,"LINEERR_NODEVICE");
  588. break;                        
  589. case LINEERR_NODRIVER:
  590. strcpy(szErrText,"LINEERR_NODRIVER");
  591. break;                        
  592. case LINEERR_NOMEM:
  593. strcpy(szErrText,"LINEERR_NOMEM");
  594. break;                           
  595. case LINEERR_NOREQUEST:
  596. strcpy(szErrText,"LINEERR_NOREQUEST");
  597. break;                       
  598. case LINEERR_NOTOWNER:
  599. strcpy(szErrText,"LINEERR_NOTOWNER");
  600. break;                        
  601. case LINEERR_NOTREGISTERED:
  602. strcpy(szErrText,"LINEERR_NOTREGISTERED");
  603. break;                   
  604. case LINEERR_OPERATIONFAILED:
  605. strcpy(szErrText,"LINEERR_OPERATIONFAILED");
  606. break;                 
  607. case LINEERR_OPERATIONUNAVAIL:
  608. strcpy(szErrText,"LINEERR_OPERATIONUNAVAIL");
  609. break;                
  610. case LINEERR_RATEUNAVAIL:
  611. strcpy(szErrText,"LINEERR_RATEUNAVAIL");
  612. break;                     
  613. case LINEERR_RESOURCEUNAVAIL:
  614. strcpy(szErrText,"LINEERR_RESOURCEUNAVAIL");
  615. break;                 
  616. case LINEERR_REQUESTOVERRUN:
  617. strcpy(szErrText,"LINEERR_REQUESTOVERRUN");
  618. break;                  
  619. case LINEERR_STRUCTURETOOSMALL:
  620. strcpy(szErrText,"LINEERR_STRUCTURETOOSMALL");
  621. break;               
  622. case LINEERR_TARGETNOTFOUND:
  623. strcpy(szErrText,"LINEERR_TARGETNOTFOUND");
  624. break;                  
  625. case LINEERR_TARGETSELF:
  626. strcpy(szErrText,"LINEERR_TARGETSELF");
  627. break;                      
  628. case LINEERR_UNINITIALIZED:
  629. strcpy(szErrText,"LINEERR_UNINITIALIZED");
  630. break;                   
  631. case LINEERR_USERUSERINFOTOOBIG:
  632. strcpy(szErrText,"LINEERR_USERUSERINFOTOOBIG");
  633. break;           
  634. case LINEERR_REINIT:
  635. strcpy(szErrText,"LINEERR_REINIT");
  636. break;
  637. case LINEERR_ADDRESSBLOCKED:
  638. strcpy(szErrText,"LINEERR_ADDRESSBLOCKED");
  639. break;
  640. case LINEERR_BILLINGREJECTED:
  641. strcpy(szErrText,"LINEERR_BILLINGREJECTED");
  642. break;
  643. case LINEERR_INVALFEATURE:
  644. strcpy(szErrText,"LINEERR_INVALFEATURE");
  645. break;
  646. case LINEERR_NOMULTIPLEINSTANCE:
  647. strcpy(szErrText,"LINEERR_NOMULTIPLEINSTANCE");
  648. break;
  649. case LINEERR_INVALAGENTID:
  650. strcpy(szErrText,"LINEERR_INVALAGENTID");
  651. break;
  652. case LINEERR_INVALAGENTGROUP:
  653. strcpy(szErrText,"LINEERR_INVALAGENTGROUP");
  654. break;
  655. case LINEERR_INVALPASSWORD:
  656. strcpy(szErrText,"LINEERR_INVALPASSWORD");
  657. break;
  658. case LINEERR_INVALAGENTSTATE:
  659. strcpy(szErrText,"LINEERR_INVALAGENTSTATE");
  660. break;
  661. case LINEERR_INVALAGENTACTIVITY:
  662. strcpy(szErrText,"LINEERR_INVALAGENTACTIVITY");
  663. break;
  664. case LINEERR_DIALVOICEDETECT:
  665. strcpy(szErrText,"LINEERR_DIALVOICEDETECT");
  666. break;
  667. default:
  668. free(szErrText);
  669. FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,NULL,nError,0,(LPTSTR)&szErrText,0,NULL);
  670. };
  671. }