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

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

TAPI编程

开发平台：

Visual C++

WaveTsp.cpp：源码内容
  1. // WaveTsp.cpp
  3. #include "pch.h"
  4. #include "wavetsp.h"
  5. #include "tspline.h"
  6. #include "tspcall.h"
  7. #include "resource.h"
  9. HINSTANCE           g_hinst = 0;
  10. HPROVIDER           g_hProvider = 0;
  11. DWORD               g_dwLineDeviceIDBase = 0;
  12. DWORD               g_dwPermanentProviderID = 0;
  13. ASYNC_COMPLETION    g_pfnCompletionProc = 0;
  15. // { dwDialPause, dwDialSpeed, dwDigitDuration, dwWaitForDialtone }
  16. LINEDIALPARAMS      g_dpMin = { 100,  50, 100,  100 };
  17. LINEDIALPARAMS      g_dpDef = { 250,  50, 250,  500 };
  18. LINEDIALPARAMS      g_dpMax = { 1000, 50, 1000, 1000 };
  20. BOOL WINAPI DllMain(
  21.     HINSTANCE   hinst,
  22.     DWORD       dwReason,
  23.     void*      /*pReserved*/)
  24. {
  25.     if( dwReason == DLL_PROCESS_ATTACH )
  26.     {
  27.         g_hinst = hinst;
  28.     }
  29.     
  30.     return TRUE;
  31. }
  33. // TSPI_providerXxx functions /////////////////////////////////////////
  35. LONG TSPIAPI TSPI_providerEnumDevices(
  36.     DWORD       dwPermanentProviderID,
  37.     LPDWORD     pdwNumLines,
  38.     LPDWORD     pdwNumPhones,
  39.     HPROVIDER   hProvider,
  40.     LINEEVENT   pfnLineCreateProc,
  41.     PHONEEVENT  pfnPhoneCreateProc)
  42. {
  43.     BEGIN_PARAM_TABLE("TSPI_providerEnumDevices")
  44.         DWORD_IN_ENTRY(dwPermanentProviderID)
  45.         DWORD_OUT_ENTRY(pdwNumLines)
  46.         DWORD_OUT_ENTRY(pdwNumPhones)
  47.         DWORD_IN_ENTRY(hProvider)
  48.         DWORD_IN_ENTRY(pfnLineCreateProc)
  49.         DWORD_IN_ENTRY(pfnPhoneCreateProc)
  50.     END_PARAM_TABLE()
  52.     g_hProvider = hProvider;
  53.     *pdwNumLines = 1;
  54.     *pdwNumPhones = 0;
  56.     return EPILOG(0);
  57. }
  59. LONG TSPIAPI TSPI_providerInit(
  60.     DWORD               dwTSPIVersion,
  61.     DWORD               dwPermanentProviderID,
  62.     DWORD               dwLineDeviceIDBase,
  63.     DWORD               dwPhoneDeviceIDBase,
  64.     DWORD               dwNumLines,
  65.     DWORD               dwNumPhones,
  66.     ASYNC_COMPLETION    pfnCompletionProc,
  67.     LPDWORD             pdwTSPIOptions)
  68. {
  69.     BEGIN_PARAM_TABLE("TSPI_providerInit")
  70.         DWORD_IN_ENTRY(dwTSPIVersion)
  71.         DWORD_IN_ENTRY(dwPermanentProviderID)
  72.         DWORD_IN_ENTRY(dwLineDeviceIDBase)
  73.         DWORD_IN_ENTRY(dwPhoneDeviceIDBase)
  74.         DWORD_IN_ENTRY(dwNumLines)
  75.         DWORD_IN_ENTRY(dwNumPhones)
  76.         DWORD_IN_ENTRY(pfnCompletionProc)
  77.         DWORD_OUT_ENTRY(pdwTSPIOptions)
  78.     END_PARAM_TABLE()
  80.     g_dwPermanentProviderID = dwPermanentProviderID;
  81.     g_dwLineDeviceIDBase = dwLineDeviceIDBase;
  82.     g_pfnCompletionProc  = pfnCompletionProc;
  83.     *pdwTSPIOptions = LINETSPIOPTION_NONREENTRANT;
  85.     return EPILOG(0);
  86. }
  88. LONG TSPIAPI TSPI_providerShutdown(
  89.     DWORD   dwTSPIVersion,
  90.     DWORD   dwPermanentProviderID)
  91. {
  92.     BEGIN_PARAM_TABLE("TSPI_providerShutdown")
  93.         DWORD_IN_ENTRY(dwTSPIVersion)
  94.         DWORD_IN_ENTRY(dwPermanentProviderID)
  95.     END_PARAM_TABLE()
  97.     return EPILOG(0);
  98. }
  100. LONG TSPIAPI TSPI_providerConfig(
  101.     HWND    hwndOwner,
  102.     DWORD   dwPermanentProviderID)
  103. {
  104.     // Although this func is never called by TAPI v2.0, we export
  105.     // it so that the Telephony Control Panel Applet knows that it
  106.     // can configure this provider via lineConfigProvider(),
  107.     // otherwise Telephon.cpl will not consider it configurable
  108.     BEGIN_PARAM_TABLE("TSPI_providerConfig")
  109.         DWORD_IN_ENTRY(hwndOwner)
  110.         DWORD_IN_ENTRY(dwPermanentProviderID)
  111.     END_PARAM_TABLE()
  113.     return EPILOG(0);
  114. }
  116. LONG TSPIAPI TSPI_providerGenericDialogData(
  117.     DWORD   dwObjectID,
  118.     DWORD   dwObjectType,
  119.     LPVOID  pParams,
  120.     DWORD   dwSize)
  121. {
  122.     BEGIN_PARAM_TABLE("TSPI_providerGenericDialogData")
  123.         DWORD_IN_ENTRY(dwObjectID)
  124.         DWORD_IN_ENTRY(dwObjectType)
  125.         DWORD_IN_ENTRY(pParams)
  126.         DWORD_IN_ENTRY(dwSize)
  127.     END_PARAM_TABLE()
  129.     if( dwObjectType == TUISPIDLL_OBJECT_DIALOGINSTANCE )
  130.     {
  131.         // Handle requests from the UI for dialog-related data
  132.         TSPUIDATA*  pData = (TSPUIDATA*)pParams;
  133.         if( pData->dwRequestID )
  134.         {
  135.             // Complete asynch operation
  136.             g_pfnCompletionProc(pData->dwRequestID, pData->tr);
  137.         }
  139.         // Update call state
  140.         if( pData->tr == 0 )
  141.         {
  142.             pData->pCall->SetCallState(pData->nCallState);
  143.         }
  144.     }
  146.     return EPILOG(0);
  147. }
  149. LONG TSPIAPI TSPI_providerFreeDialogInstance(
  150.     HDRVDIALOGINSTANCE hdDlgInst)
  151. {
  152.     BEGIN_PARAM_TABLE("TSPI_providerFreeDialogInstance")
  153.         DWORD_IN_ENTRY(hdDlgInst)
  154.     END_PARAM_TABLE()
  156.     // W/o this function, TAPISVR.EXE crashes
  157.     return EPILOG(0);
  158. }
  160. LONG TSPIAPI TSPI_providerInstall(
  161.     HWND    hwndOwner,
  162.     DWORD   dwPermanentProviderID)
  163. {
  164.     // Although this func is never called by TAPI v2.0, we export
  165.     // it so that the Telephony Control Panel Applet knows that it
  166.     // can add this provider via lineAddProvider(), otherwise
  167.     // Telephon.cpl will not consider it installable
  168.     BEGIN_PARAM_TABLE("TSPI_providerInstall")
  169.         DWORD_IN_ENTRY(hwndOwner)
  170.         DWORD_IN_ENTRY(dwPermanentProviderID)
  171.     END_PARAM_TABLE()
  173.     return EPILOG(0);
  174. }
  176. LONG TSPIAPI TSPI_providerRemove(
  177.     HWND    hwndOwner,
  178.     DWORD   dwPermanentProviderID)
  179. {
  180.     // Although this func is never called by TAPI v2.0, we export
  181.     // it so that the Telephony Control Panel Applet knows that it
  182.     // can remove this provider via lineRemoveProvider(), otherwise
  183.     // Telephon.cpl will not consider it removable
  184.     BEGIN_PARAM_TABLE("TSPI_providerRemove")
  185.         DWORD_IN_ENTRY(hwndOwner)
  186.         DWORD_IN_ENTRY(dwPermanentProviderID)
  187.     END_PARAM_TABLE()
  189.     return EPILOG(0);
  190. }
  192. LONG TSPIAPI TSPI_providerUIIdentify(
  193.     LPWSTR   pszUIDLLName)
  194. {
  195.     BEGIN_PARAM_TABLE("TSPI_providerUIIdentify")
  196.         STRING_OUT_ENTRY(pszUIDLLName)
  197.     END_PARAM_TABLE()
  199.     // Use the same DLL for both non-UI and UI functions
  200.     char    szFileName[MAX_PATH+1];
  201.     GetModuleFileNameA(g_hinst, szFileName, MAX_PATH);
  202.     mbstowcs(pszUIDLLName, szFileName, strlen(szFileName) + 1);
  204.     return EPILOG(0);
  205. }
  207. // TSPI_lineXxx functions /////////////////////////////////////////////
  209. #define MIN(a, b) (a < b ? a : b)
  211. LONG TSPIAPI TSPI_lineNegotiateTSPIVersion(
  212.     DWORD   dwDeviceID,
  213.     DWORD   dwLowVersion,
  214.     DWORD   dwHighVersion,
  215.     LPDWORD pdwTSPIVersion)
  216. {
  217.     BEGIN_PARAM_TABLE("TSPI_lineNegotiateTSPIVersion")
  218.         DWORD_IN_ENTRY(dwDeviceID)
  219.         DWORD_IN_ENTRY(dwLowVersion)
  220.         DWORD_IN_ENTRY(dwHighVersion)
  221.         DWORD_OUT_ENTRY(pdwTSPIVersion)
  222.     END_PARAM_TABLE()
  224.     LONG    tr = 0;
  225.     
  226.     if( dwLowVersion <= TAPI_CURRENT_VERSION )
  227.     {
  228.         *pdwTSPIVersion = MIN(TAPI_CURRENT_VERSION, dwHighVersion);
  229.     }
  230.     else
  231.     {
  232.         tr = LINEERR_INCOMPATIBLEAPIVERSION;
  233.     }
  235.     return EPILOG(tr);
  236. }
  238. LONG TSPIAPI TSPI_lineGetDevCaps(
  239.     DWORD           dwDeviceID,
  240.     DWORD           dwTSPIVersion,
  241.     DWORD           dwExtVersion,
  242.     LPLINEDEVCAPS   pldc)
  243. {
  244.     BEGIN_PARAM_TABLE("TSPI_lineGetDevCaps")
  245.         DWORD_IN_ENTRY(dwDeviceID)
  246.         DWORD_IN_ENTRY(dwTSPIVersion)
  247.         DWORD_IN_ENTRY(dwExtVersion)
  248.         DWORD_IN_ENTRY(pldc)
  249.     END_PARAM_TABLE()
  251.     LONG            tr = 0;
  252.     const wchar_t   szProviderInfo[] = L"WAVE Service Provider";
  253.     const wchar_t   szLineName[] = L"WaveLine";
  255.     pldc->dwNeededSize = sizeof(LINEDEVCAPS) +
  256.                          sizeof(szProviderInfo) +
  257.                          sizeof(szLineName);
  258.     
  259.     if( pldc->dwNeededSize <= pldc->dwTotalSize )
  260.     {
  261.         pldc->dwUsedSize = pldc->dwNeededSize;
  263.         pldc->dwProviderInfoSize    = sizeof(szProviderInfo);
  264.         pldc->dwProviderInfoOffset  = sizeof(LINEDEVCAPS) + 0;
  265.         wchar_t* pszProviderInfo = (wchar_t*)((BYTE*)pldc + pldc->dwProviderInfoOffset);
  266.         wcscpy(pszProviderInfo, szProviderInfo);
  267.         
  268.         pldc->dwLineNameSize        = sizeof(szLineName);
  269.         pldc->dwLineNameOffset      = sizeof(LINEDEVCAPS) + sizeof(szProviderInfo);
  270.         wchar_t* pszLineName = (wchar_t*)((BYTE*)pldc + pldc->dwLineNameOffset);
  271.         wcscpy(pszLineName, szLineName);
  272.     }
  273.     else
  274.     {
  275.         pldc->dwUsedSize = sizeof(LINEDEVCAPS);
  276.     }
  277.     
  278.     pldc->dwStringFormat      = STRINGFORMAT_ASCII;
  280. // Microsoft recommended algorithm for
  281. // calculating the permanent line ID
  282. #define MAKEPERMLINEID(dwPermProviderID, dwDeviceID) 
  283.     ((LOWORD(dwPermProviderID) << 16) | dwDeviceID)
  285.     pldc->dwPermanentLineID   = MAKEPERMLINEID(g_dwPermanentProviderID, dwDeviceID - g_dwLineDeviceIDBase);
  286.     pldc->dwAddressModes      = LINEADDRESSMODE_ADDRESSID;
  287.     pldc->dwNumAddresses      = 1;
  288.     pldc->dwBearerModes       = LINEBEARERMODE_VOICE;
  289.     pldc->dwMediaModes        = LINEMEDIAMODE_INTERACTIVEVOICE;
  290.     pldc->dwGenerateDigitModes= LINEDIGITMODE_DTMF;
  291.     pldc->dwDevCapFlags       = LINEDEVCAPFLAGS_CLOSEDROP;
  292.     pldc->dwMaxNumActiveCalls = 1;
  293.     pldc->dwLineFeatures      = LINEFEATURE_MAKECALL;
  295.     // DialParams
  296.     pldc->MinDialParams = g_dpMin;
  297.     pldc->MaxDialParams = g_dpMax;
  298.     pldc->DefaultDialParams = g_dpDef;
  299.     
  300.     return EPILOG(tr);
  301. }
  303. LONG TSPIAPI TSPI_lineGetAddressCaps(
  304.     DWORD              dwDeviceID,
  305.     DWORD              dwAddressID,
  306.     DWORD              dwTSPIVersion,
  307.     DWORD              dwExtVersion,
  308.     LPLINEADDRESSCAPS  pac)
  309. {
  310.     BEGIN_PARAM_TABLE("TSPI_lineGetAddressCaps")
  311.         DWORD_IN_ENTRY(dwDeviceID)
  312.         DWORD_IN_ENTRY(dwAddressID)
  313.         DWORD_IN_ENTRY(dwTSPIVersion)
  314.         DWORD_IN_ENTRY(dwExtVersion)
  315.     END_PARAM_TABLE()
  317.     if( dwAddressID != 0 ) return EPILOG(LINEERR_INVALADDRESSID);
  319.     pac->dwNeededSize           = sizeof(LINEADDRESSCAPS);
  320.     pac->dwUsedSize             = sizeof(LINEADDRESSCAPS);
  322.     pac->dwLineDeviceID         = dwDeviceID;
  323.     pac->dwAddressSharing       = LINEADDRESSSHARING_PRIVATE;
  324.     pac->dwCallInfoStates       = LINECALLINFOSTATE_MEDIAMODE |
  325.                                   LINECALLINFOSTATE_APPSPECIFIC;
  327.     pac->dwCallerIDFlags        = LINECALLPARTYID_UNAVAIL;
  328.     pac->dwCalledIDFlags        = LINECALLPARTYID_UNAVAIL;
  329.     pac->dwRedirectionIDFlags   = LINECALLPARTYID_UNAVAIL;
  330.     pac->dwRedirectingIDFlags   = LINECALLPARTYID_UNAVAIL;
  332.     pac->dwCallStates           = LINECALLSTATE_IDLE |
  333.                                   LINECALLSTATE_DIALING |
  334.                                   LINECALLSTATE_CONNECTED;
  336.     pac->dwDialToneModes        = LINEDIALTONEMODE_UNAVAIL;
  337.     pac->dwBusyModes            = LINEBUSYMODE_UNAVAIL;
  338.     pac->dwSpecialInfo          = LINESPECIALINFO_UNAVAIL;
  340.     pac->dwDisconnectModes      = LINEDISCONNECTMODE_UNAVAIL;
  342.     pac->dwMaxNumActiveCalls    = 1;
  343.     pac->dwAddrCapFlags         = LINEADDRCAPFLAGS_DIALED;
  345.     pac->dwCallFeatures         = LINECALLFEATURE_DIAL |
  346.                                   LINECALLFEATURE_DROP |
  347.                                   LINECALLFEATURE_GENERATEDIGITS;
  349.     pac->dwAddressFeatures      = LINEADDRFEATURE_MAKECALL;
  350.     
  351.     return EPILOG(0);
  352. }
  354. LONG TSPIAPI TSPI_lineGetID(
  355.     HDRVLINE    hdLine,
  356.     DWORD       dwAddressID,
  357.     HDRVCALL    hdCall,
  358.     DWORD       dwSelect,
  359.     LPVARSTRING pDeviceID,
  360.     LPCWSTR     pszDeviceClass,
  361.     HANDLE      hTargetProcess)
  362. {
  363.     BEGIN_PARAM_TABLE("TSPI_lineGetID")
  364.         DWORD_IN_ENTRY(hdLine)
  365.         DWORD_IN_ENTRY(dwAddressID)
  366.         DWORD_IN_ENTRY(hdCall)
  367.         DWORD_IN_ENTRY(dwSelect)
  368.         DWORD_IN_ENTRY(pDeviceID)
  369.         STRING_IN_ENTRY(pszDeviceClass)
  370.         DWORD_IN_ENTRY(hTargetProcess)
  371.     END_PARAM_TABLE()
  372.     
  373.     LONG    tr = LINEERR_NODEVICE;
  375.     /*
  376.     // TAPI handles "tapi/line" and "tapi/phone",
  377.     // so long as this function is present and returns LINEERR_NODEVICE
  379.     LONG        tr = 0;
  380.     CtspCall*   pCall = (dwSelect == LINECALLSELECT_CALL ? (CtspCall*)hdCall : 0);
  381.     CtspLine*   pLine = (dwSelect == LINECALLSELECT_LINE ? (CtspLine*)hdLine : (pCall ? pCall->GetLine() : 0));
  383.     if( lstrcmpiW(pszDeviceClass, L"tapi/line") == 0 )
  384.     {
  385.         pDeviceID->dwNeededSize = sizeof(VARSTRING) + sizeof(DWORD);
  387.         if( pDeviceID->dwNeededSize <= pDeviceID->dwTotalSize )
  388.         {
  389.             pDeviceID->dwUsedSize      = pDeviceID->dwNeededSize;
  390.             pDeviceID->dwStringFormat  = STRINGFORMAT_BINARY;
  391.             pDeviceID->dwStringSize    = sizeof(DWORD);
  392.             pDeviceID->dwStringOffset  = sizeof(VARSTRING);
  393.             
  394.             *((LPDWORD)(pDeviceID + 1)) = pLine->GetDeviceID();
  395.         }
  396.         else
  397.         {
  398.             pDeviceID->dwUsedSize = 3 * sizeof(DWORD);
  399.             tr = LINEERR_STRUCTURETOOSMALL;
  400.         }
  401.     }
  402.     else
  403.     {
  404.         tr = LINEERR_NODEVICE;
  405.     }
  406.     */
  407.     
  408.     return EPILOG(tr);
  409. }
  411. LONG TSPIAPI TSPI_lineOpen(
  412.     DWORD       dwDeviceID,
  413.     HTAPILINE   htLine,
  414.     LPHDRVLINE  phdLine,
  415.     DWORD       dwTSPIVersion,
  416.     LINEEVENT   pfnEventProc)
  417. {
  418.     BEGIN_PARAM_TABLE("TSPI_lineOpen")
  419.         DWORD_IN_ENTRY(dwDeviceID)
  420.         DWORD_IN_ENTRY(htLine)
  421.         DWORD_OUT_ENTRY(phdLine)
  422.         DWORD_IN_ENTRY(dwTSPIVersion)
  423.         DWORD_IN_ENTRY(pfnEventProc)
  424.     END_PARAM_TABLE()
  425.     
  426.     LONG        tr = LINEERR_NOMEM;
  427.     CtspLine*   pLine = new CtspLine(htLine, pfnEventProc, dwDeviceID);
  429.     if( pLine )
  430.     {
  431.         *phdLine = (HDRVLINE)pLine;
  432.         tr = 0;
  433.     }
  434.     
  435.     return EPILOG(tr);
  436. }
  438. LONG TSPIAPI TSPI_lineSetDefaultMediaDetection(
  439.     HDRVLINE    hdLine,
  440.     DWORD       dwMediaModes)
  441. {
  442.     BEGIN_PARAM_TABLE("TSPI_lineSetDefaultMediaDetection")
  443.         DWORD_IN_ENTRY(hdLine)
  444.         DWORD_IN_ENTRY(dwMediaModes)
  445.     END_PARAM_TABLE()
  446.     
  447.     // This function is required, or TAPISRV will crash
  448.     // if any application attempts to open this line
  449.     // for incoming calls (sigh)
  450.     return EPILOG(LINEERR_OPERATIONUNAVAIL);
  451. }
  453. LONG TSPIAPI TSPI_lineGetNumAddressIDs(
  454.     HDRVLINE    hdLine,
  455.     LPDWORD     pdwNumAddressIDs)
  456. {
  457.     BEGIN_PARAM_TABLE("TSPI_lineGetNumAddressIDs")
  458.         DWORD_IN_ENTRY(hdLine)
  459.         DWORD_OUT_ENTRY(pdwNumAddressIDs)
  460.     END_PARAM_TABLE()
  461.     
  462.     // We only support 1 address (id=0)
  463.     *pdwNumAddressIDs = 1;
  464.     return EPILOG(0);
  465. }
  467. LONG TSPIAPI TSPI_lineClose(
  468.     HDRVLINE    hdLine)
  469. {
  470.     BEGIN_PARAM_TABLE("TSPI_lineClose")
  471.         DWORD_IN_ENTRY(hdLine)
  472.     END_PARAM_TABLE()
  474.     delete (CtspLine*)hdLine;
  476.     return EPILOG(0);
  477. }
  479. LONG TSPIAPI TSPI_lineMakeCall(
  480.     DRV_REQUESTID       dwRequestID,
  481.     HDRVLINE            hdLine,
  482.     HTAPICALL           htCall,
  483.     LPHDRVCALL          phdCall,
  484.     LPCWSTR             pszDestAddress,
  485.     DWORD               dwCountryCode,
  486.     LPLINECALLPARAMS    const pCallParams)
  487. {
  488.     BEGIN_PARAM_TABLE("TSPI_lineMakeCall")
  489.         DWORD_IN_ENTRY(dwRequestID)
  490.         DWORD_IN_ENTRY(hdLine)
  491.         DWORD_IN_ENTRY(htCall)
  492.         DWORD_OUT_ENTRY(phdCall)
  493.         STRING_IN_ENTRY(pszDestAddress)
  494.         DWORD_IN_ENTRY(dwCountryCode)
  495.         DWORD_IN_ENTRY(pCallParams)
  496.     END_PARAM_TABLE()
  498.     LONG        tr;
  499.     CtspLine*   pLine = (CtspLine*)hdLine;
  500.     tr = pLine->MakeCall(dwRequestID, htCall, phdCall, pszDestAddress, dwCountryCode, pCallParams);
  501.     return EPILOG(tr);
  502. }
  504. LONG TSPIAPI TSPI_lineSetStatusMessages(
  505.     HDRVLINE    hdLine,
  506.     DWORD       dwLineStates,
  507.     DWORD       dwAddressStates)
  508. {
  509.     BEGIN_PARAM_TABLE("TSPI_lineSetStatusMessages")
  510.         DWORD_IN_ENTRY(hdLine)
  511.         DWORD_IN_ENTRY(dwLineStates)
  512.         DWORD_IN_ENTRY(dwAddressStates)
  513.     END_PARAM_TABLE()
  515.     // Since we don't ever send status messages of any kind
  516.     // we're happy at any limit. However, some apps require
  517.     // that this function return successfully before a call
  518.     // can be made, e.g. Outlook 98.
  520.     return EPILOG(0);
  521. }
  523. LONG TSPIAPI TSPI_lineDrop(
  524.     DRV_REQUESTID   dwRequestID,
  525.     HDRVCALL        hdCall,
  526.     LPCSTR          psUserUserInfo,
  527.     DWORD           dwSize)
  528. {
  529.     BEGIN_PARAM_TABLE("TSPI_lineDrop")
  530.         DWORD_IN_ENTRY(dwRequestID)
  531.         DWORD_IN_ENTRY(hdCall)
  532.         DWORD_IN_ENTRY(psUserUserInfo)
  533.         DWORD_IN_ENTRY(dwSize)
  534.     END_PARAM_TABLE()
  536.     CtspCall*   pCall = (CtspCall*)hdCall;
  538.     pCall->Drop();
  539.     g_pfnCompletionProc(dwRequestID, 0);
  541.     return EPILOG(dwRequestID);
  542. }
  544. LONG TSPIAPI TSPI_lineCloseCall(
  545.     HDRVCALL    hdCall)
  546. {
  547.     BEGIN_PARAM_TABLE("TSPI_lineCloseCall")
  548.         DWORD_IN_ENTRY(hdCall)
  549.     END_PARAM_TABLE()
  551.     // Note that in TAPI 2.0 TSPI_lineCloseCall can get called
  552.     // without TSPI_lineDrop ever being called, so we need to
  553.     // be prepared for either case.
  554.     CtspCall*   pCall = (CtspCall*)hdCall;
  556.     pCall->Drop();
  557.     delete pCall;
  559.     return EPILOG(0);
  560. }
  562. LONG TSPIAPI TSPI_lineGetAddressStatus(
  563.     HDRVLINE            hdLine,
  564.     DWORD               dwAddressID,
  565.     LPLINEADDRESSSTATUS pas)
  566. {
  567.     BEGIN_PARAM_TABLE("TSPI_lineGetAddressStatus")
  568.         DWORD_IN_ENTRY(hdLine)
  569.         DWORD_IN_ENTRY(dwAddressID)
  570.         DWORD_IN_ENTRY(pas)
  571.     END_PARAM_TABLE()
  573.     pas->dwNeededSize = sizeof(LINEADDRESSSTATUS);
  574.     pas->dwUsedSize   = sizeof(LINEADDRESSSTATUS);
  575.     pas->dwNumActiveCalls  = ((CtspLine*)hdLine)->GetNumActiveCalls();
  576.     pas->dwAddressFeatures = LINEADDRFEATURE_MAKECALL;
  577.     
  578.     return EPILOG(0);
  579. }
  581. LONG TSPIAPI TSPI_lineGetCallAddressID(
  582.     HDRVCALL    hdCall,
  583.     LPDWORD     pdwAddressID)
  584. {
  585.     BEGIN_PARAM_TABLE("TSPI_lineGetCallAddressID")
  586.         DWORD_IN_ENTRY(hdCall)
  587.         DWORD_OUT_ENTRY(pdwAddressID)
  588.     END_PARAM_TABLE()
  590.     // We only support 1 address (id=0)
  591.     *pdwAddressID = 0;
  593.     return EPILOG(0);
  594. }
  596. LONG TSPIAPI TSPI_lineGetCallInfo(
  597.     HDRVCALL        hdCall,
  598.     LPLINECALLINFO  pli)
  599. {
  600.     BEGIN_PARAM_TABLE("TSPI_lineGetCallInfo")
  601.         DWORD_IN_ENTRY(hdCall)
  602.         DWORD_IN_ENTRY(pli)
  603.     END_PARAM_TABLE()
  605.     pli->dwNeededSize           = sizeof(LINECALLINFO);
  606.     pli->dwUsedSize             = sizeof(LINECALLINFO);
  607.     
  608.     pli->dwBearerMode           = LINEBEARERMODE_VOICE;
  609.     pli->dwMediaMode            = LINEMEDIAMODE_INTERACTIVEVOICE;
  610.     pli->dwCallStates           = LINECALLSTATE_IDLE |
  611.                                   LINECALLSTATE_DIALING |
  612.                                   LINECALLSTATE_CONNECTED |
  613.                                   LINECALLSTATE_PROCEEDING |
  614.                                   LINECALLSTATE_UNKNOWN;
  616.     pli->dwOrigin               = LINECALLORIGIN_OUTBOUND;
  617.     pli->dwReason               = LINECALLREASON_DIRECT;
  618.     pli->dwCallerIDFlags        = LINECALLPARTYID_UNAVAIL;
  619.     pli->dwCalledIDFlags        = LINECALLPARTYID_UNAVAIL;
  620.     pli->dwConnectedIDFlags     = LINECALLPARTYID_UNAVAIL;
  621.     pli->dwRedirectionIDFlags   = LINECALLPARTYID_UNAVAIL;
  622.     pli->dwRedirectingIDFlags   = LINECALLPARTYID_UNAVAIL;
  623.     
  624.     return EPILOG(0);
  625. }
  627. LONG TSPIAPI TSPI_lineGetCallStatus(
  628.     HDRVCALL            hdCall,
  629.     LPLINECALLSTATUS    pls)
  630. {
  631.     BEGIN_PARAM_TABLE("TSPI_lineGetCallStatus")
  632.         DWORD_IN_ENTRY(hdCall)
  633.         DWORD_IN_ENTRY(pls)
  634.     END_PARAM_TABLE()
  636.     CtspCall*   pCall = (CtspCall*)hdCall;
  638.     pls->dwNeededSize = sizeof(LINECALLSTATUS);
  639.     pls->dwUsedSize   = sizeof(LINECALLSTATUS);
  640.     pls->dwCallState  = pCall->GetCallState();
  641.     
  642.     if( pls->dwCallState != LINECALLSTATE_IDLE )
  643.     {
  644.         pls->dwCallFeatures = LINECALLFEATURE_DROP;
  645.     }
  646.     
  647.     return EPILOG(0);
  648. }
  650. LONG TSPIAPI TSPI_lineGetLineDevStatus(
  651.     HDRVLINE        hdLine,
  652.     LPLINEDEVSTATUS plds)
  653. {
  654.     BEGIN_PARAM_TABLE("TSPI_lineGetLineDevStatus")
  655.         DWORD_IN_ENTRY(hdLine)
  656.         DWORD_IN_ENTRY(plds)
  657.     END_PARAM_TABLE()
  659.     plds->dwUsedSize        = sizeof(LINEDEVSTATUS);
  660.     plds->dwNeededSize      = sizeof(LINEDEVSTATUS);
  661.     
  662.     plds->dwNumActiveCalls  = ((CtspLine*)hdLine)->GetNumActiveCalls();
  663.     plds->dwDevStatusFlags  = LINEDEVSTATUSFLAGS_CONNECTED |
  664.                               LINEDEVSTATUSFLAGS_INSERVICE;
  666.     return EPILOG(0);
  667. }
  669. LONG TSPIAPI TSPI_lineGetIcon(
  670.     DWORD   dwDeviceID,
  671.     LPCWSTR lpszDeviceClass,  
  672.     LPHICON lphIcon)
  673. {
  674.     BEGIN_PARAM_TABLE("TSPI_lineGetIcon")
  675.         DWORD_IN_ENTRY(dwDeviceID)
  676.         STRING_IN_ENTRY(lpszDeviceClass)
  677.         DWORD_OUT_ENTRY(lphIcon)
  678.     END_PARAM_TABLE()
  680.     *lphIcon = LoadIcon(g_hinst, MAKEINTRESOURCE(IDI_WAVETSP));
  682.     return EPILOG(0);
  683. }