home *** CD-ROM | disk | FTP | other *** search
/ HomeWare 14 / HOMEWARE14.bin / windows / win31 / atvsp.arj / ATVSP.C < prev    next >
C/C++ Source or Header  |  1994-03-10  |  50KB  |  1,524 lines
  1.  
  2.  
  3. /******************************************************************************\
  4. *       This is a part of the Microsoft Source Code Samples.
  5. *       Copyright (C) 1993,1994 Microsoft Corporation.
  6. *       All rights reserved.
  7. *       This source code is only intended as a supplement to
  8. *       Microsoft Development Tools and/or WinHelp documentation.
  9. \******************************************************************************/
  10. /* 
  11.  
  12. The Software provided is for your personal use only and may not be copied or distributed.
  13.  
  14. THE SOFTWARE IS PROVIDED TO YOU "AS IS" WITHOUT WARRANTY OF ANY KIND,
  15. EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
  16. WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
  17. PURPOSE.  YOU ASSUME THE ENTIRE RISK AS TO THE ACCURACY AND THE USE
  18. OF THE SOFTWARE.  MICROSOFT SHALL NOT BE LIABLE FOR ANY DAMAGES
  19. WHATSOEVER ARISING OUT OF THE USE OF OR INABILITY TO USE THE
  20. SOFTWARE, EVEN IF MICROSOFT HAS BEEN ADVISED OF THE POSSIBILITY OF
  21. SUCH DAMAGE.
  22. */
  23.  
  24. #include <windows.h>
  25. #include <memory.h>    
  26. #include <stdlib.h>   
  27. #include <string.h>
  28. #include <assert.h>
  29. #include "atvexe.h"
  30. #include "atvsp.h"
  31.                
  32. #pragma warning (disable : 4100)
  33.  
  34. int FAR PASCAL ConfigDlgProc(HWND, UINT, WPARAM, LPARAM);
  35. int FAR PASCAL LineConfDlgProc(HWND, UINT, WPARAM, LPARAM);
  36.  
  37. void    LoadIniStrings (DWORD);
  38. int SendModemCommand (int, const void *);
  39. int GetModemReply(int, void *, int);   
  40.  
  41. void    fillDialParams (LPLINEDIALPARAMS, LPLINEDIALPARAMS);
  42. long    appCall (int msg, long param, long dwRequestID);
  43.  
  44. char *lpszCommDevArray[NUMPORTS] = 
  45. { "COM1", "COM2", "COM3", "COM4" };
  46. char *lpszCommSpeedArray[NUMSPEEDS] = 
  47. { "300", "1200", "2400", "9600", "19200", "38400", "57600" };
  48.  
  49. char _based(_segname("ATVSP_TEXT")) ATV_CLASSNAME[] =  "AtvspAppWinClass";
  50.  
  51.  
  52. // Various tags in the ini file.
  53. char s_telephon_ini[] = "telephon.ini";
  54. char s_one[]            = "1";
  55. char s_zero[]           = "0";
  56. char s_numlines[]       = "NumLines";
  57. char s_numphones[]  = "NumPhones";
  58. char s_providerx[]  = "Provider%d";
  59.  
  60. char s_port[]           = "Port";
  61. char s_speed[]          = "Speed";
  62. char s_initstr[]        = "InitString";
  63. char s_ignore[]     = "IgnoreInternalString";
  64. char s_pulse[]          = "PulseDial";
  65. char s_linename[]       = "LineName";
  66. char s_lineaddr[]       = "LineAddress";
  67.  
  68. #define MIN_DURATION        50
  69. #define DEF_DURATION        95
  70. #define MAX_DURATION        255
  71. #define MIN_DIALSPEED   50
  72. #define DEF_DIALSPEED   95
  73. #define MAX_DIALSPEED   255
  74. #define MIN_DIALTONE        1000
  75. #define DEF_DIALTONE        60000
  76. #define MAX_DIALTONE        255000
  77. #define MIN_DIALPAUSE   0
  78. #define DEF_DIALPAUSE   2000
  79. #define MAX_DIALPAUSE   255000
  80.  
  81. // The global module handle
  82. HANDLE hInst = NULL;
  83.  
  84. // Line object.
  85. ATSPLineData line;
  86.  
  87. // Provider description string
  88. char gszProviderInfo[PROVIDERINFOSIZE];
  89.  
  90.  
  91. ///////////////////////////////////////////////////////////
  92. // The required DLL functions
  93. ///////////////////////////////////////////////////////////
  94.  
  95. int FAR PASCAL LibMain(HANDLE hInstance, WORD wDataSegment,
  96.                    WORD wHeapSize, LPSTR lpszCmdLine)
  97. {                      
  98.     // Under normal circumstances, this function is never called (or exported!)
  99.     DebugMsg(("Wow, this is weird!  We are in LibMain!"));
  100.     if (hInst != NULL)
  101.         return FALSE;
  102.     
  103.     hInst = hInstance;
  104.  
  105.     return TRUE;
  106. }
  107.  
  108. VOID FAR PASCAL __export WEP (int bSystemExit)
  109. { 
  110.     DebugMsg(("Yes, we are actually calling WEP!\r\n"));
  111.     hInst = NULL;
  112. }
  113.  
  114.  
  115. ///////////////////////////////////////////////////////////
  116. // The Service Provider Basic Configuration Routines
  117. ///////////////////////////////////////////////////////////
  118.                                 
  119. static appstartup  = FALSE;
  120. static atspexehwnd = 0;
  121.  
  122. #ifdef DEBUG
  123. static BOOL initialised = FALSE;
  124. #endif
  125.  
  126. LONG TSPIAPI TSPI_lineNegotiateTSPIVersion (
  127. DWORD       dwDeviceID,
  128. DWORD       dwLowVersion,
  129. DWORD       dwHighVersion,
  130. LPDWORD lpdwTSPIVersion)
  131. {
  132.     DebugMsg (("Entering TSPI_lineNegotiateTSPIVersion"));
  133.  
  134.     // line.lineID will contain garbage before provider_init has
  135.     // been called (ie. first time through). However, we can guarantee
  136.     // that the first call will be with INITIALIZE_NEGOTIATION and that
  137.     // is followed immediately by provider_init. This would be a problem
  138.     // if the line data structure was dynamically allocated !
  139.  
  140. #ifdef DEBUG
  141.     if (!initialised)
  142.         assert (dwDeviceID == INITIALIZE_NEGOTIATION);
  143. #endif
  144.  
  145.     if (dwDeviceID == INITIALIZE_NEGOTIATION ||
  146.          dwDeviceID == line.lineID)         // we support only one line
  147.     {
  148.         *lpdwTSPIVersion = ATSP_VERSION;
  149.         
  150.         if (dwLowVersion  > ATSP_VERSION || // the app is too new for us
  151.              dwHighVersion < ATSP_VERSION)  // we are too new for the app
  152.             return LINEERR_INCOMPATIBLEAPIVERSION;
  153.         else
  154.             return 0;
  155.     }
  156.  
  157.     return LINEERR_BADDEVICEID;             // The requested device doesn't exist
  158. }
  159.  
  160.  
  161. LONG TSPIAPI TSPI_providerInit (
  162. DWORD             dwTSPIVersion,
  163. DWORD             dwPermanentProviderID,
  164. DWORD             dwLineDeviceIDBase,
  165. DWORD             dwPhoneDeviceIDBase,
  166. DWORD             dwNumLines,
  167. DWORD             dwNumPhones,
  168. ASYNC_COMPLETION  lpfnCompletionProc)
  169. {
  170.     int res;
  171.  
  172.     DebugMsg (("Entering TSPI_providerInit"));
  173.  
  174.     assert (dwTSPIVersion == ATSP_VERSION);
  175.     assert (dwNumLines    == 1);
  176.     assert (dwNumPhones   == 0);
  177.  
  178.  
  179.     // launch our companion app to get an async thread
  180.  
  181.     res = WinExec ("atvexe.exe", SW_SHOWMINIMIZED);
  182.  
  183.     if (res <= HINSTANCE_ERROR)
  184.     {
  185.         DebugMsg (("App didn't start"));
  186.         return LINEERR_NODRIVER;
  187.     }
  188.  
  189.     atspexehwnd = FindWindow(ATV_CLASSNAME,NULL);
  190.     
  191.     if (atspexehwnd == NULL)
  192.         {
  193.         DebugMsg(("Failed to find the ATVEXE.EXE window"));
  194.         return FALSE;
  195.         }       
  196.     else
  197.         DebugMsg(("The window handle is %ld",(LONG)atspexehwnd));      
  198.  
  199.     // initialise our internal structures
  200.  
  201.     _fmemset (&line, 0, sizeof (ATSPLineData));
  202.   
  203.     line.lpfnCompletion = lpfnCompletionProc;
  204.     line.lineID             = dwLineDeviceIDBase;
  205.     line.dwMediaMode        = LINEMEDIAMODE_INTERACTIVEVOICE;
  206.   
  207.     line.callState                              = 0;
  208.     line.dpDialParams.dwDialPause           = 2000;
  209.     line.dpDialParams.dwDialSpeed           = DEF_DIALSPEED;
  210.     line.dpDialParams.dwDigitDuration   = DEF_DURATION;
  211.     line.dpDialParams.dwWaitForDialtone = 60000;
  212.     line.bBusy = FALSE;
  213.     
  214.     LoadIniStrings (dwPermanentProviderID);
  215.  
  216. #ifdef DEBUG
  217.     initialised = TRUE;
  218. #endif
  219.  
  220.     return 0;
  221. }
  222.  
  223.  
  224. LONG TSPIAPI TSPI_providerShutdown (DWORD dwTSPIVersion)
  225. {                                              
  226.     DebugMsg (("Entering TSPI_providerShutdown"));
  227.  
  228.     // close our shadow app. We do it here as it registers with us
  229.     // and therefore our module count doesn't hit 0 so WEP isn't called
  230.     SendMessage (atspexehwnd, M_UNINSTALL, 0, 0);
  231.     atspexehwnd = 0;
  232.  
  233.     return 0;
  234. }
  235.  
  236.  
  237. ///////////////////////////////////////////////////////////
  238. // The Line Specific Calls
  239. ///////////////////////////////////////////////////////////
  240.  
  241.  
  242. ///////////////////////////////////////////////////////////
  243. // NO CHANGES NEEDED!!!
  244. ///////////////////////////////////////////////////////////
  245.  
  246.  
  247. LONG TSPIAPI TSPI_lineConfigDialog (
  248. DWORD    dwDeviceID, 
  249. HWND     hwndOwner,
  250. LPCSTR lpszDeviceClass)
  251. {
  252.     DebugMsg (("Entering TSPI_lineConfigDialog"));
  253.     
  254.     if (dwDeviceID != line.lineID)
  255.         return LINEERR_BADDEVICEID;
  256.  
  257.     DialogBox (hInst, MAKEINTRESOURCE (IDD_CFGDLG),
  258.                             hwndOwner, ConfigDlgProc);
  259.  
  260.     return 0;
  261. }
  262.  
  263.  
  264. void lineDropCore (ATSPLineData *theLine)
  265. {
  266.     // if the call is not idle, transition to idle and close the comms port
  267.  
  268.     if (theLine->callState != LINECALLSTATE_IDLE &&
  269.          theLine->callState != 0)
  270.     {
  271. // This is different from ATSP because ATVEXE handles the state transition for us.
  272.         {   ATSPLineData *myline = &line;
  273.             appCall (msgDrop, (long) myline, 0);
  274.         }
  275.     }
  276. }
  277.  
  278.  
  279. LONG TSPIAPI TSPI_lineCloseCall (HDRVCALL hdCall)
  280. {
  281.     DebugMsg (("Entering TSPI_lineCloseCall"));
  282.   
  283.     if (hdCall != (HDRVCALL) line.hdCall)
  284.         {
  285.         DebugMsg(("LINEERR_INVALCALLHANDLE"));
  286.         return LINEERR_INVALCALLHANDLE;
  287.         }
  288.     
  289.     // call drop in case there is still an active call on the line
  290.     lineDropCore (&line);
  291.  
  292.     line.callState = 0;
  293.     return 0;
  294. }
  295.  
  296.  
  297. LONG TSPIAPI TSPI_lineGetAddressID (
  298. HDRVLINE         hdLine, 
  299. LPDWORD      lpdwAddressID, 
  300. DWORD            dwAddressMode,
  301. LPCSTR       lpsAddress, 
  302. DWORD            dwSize)
  303. {
  304.     DebugMsg (("Entering TSPI_lineGetAddressID"));
  305.  
  306.     if (hdLine != (HDRVLINE) &line)
  307.         return LINEERR_INVALLINEHANDLE;
  308.  
  309.     assert (dwAddressMode == LINEADDRESSMODE_DIALABLEADDR);
  310.  
  311.     if (_fstrcmp (line.lineaddr, lpsAddress))
  312.         return LINEERR_INVALADDRESS;
  313.     else
  314.     { 
  315.         *lpdwAddressID = 0; // we support only 1 line
  316.         return 0;
  317.     }
  318. }
  319.  
  320. LONG TSPIAPI TSPI_lineGetAddressStatus (
  321. HDRVLINE                    hdLine,
  322. DWORD                       dwAddressID,
  323. LPLINEADDRESSSTATUS lpAddressStatus)
  324. {
  325.     DebugMsg (("Entering TSPI_lineGetAddressStatus"));
  326.  
  327.     if (dwAddressID)
  328.         return LINEERR_INVALADDRESSID;
  329.  
  330.     lpAddressStatus->dwUsedSize = 
  331.     lpAddressStatus->dwNeededSize   = sizeof (LINEADDRESSSTATUS);
  332.   
  333.     // if we are idle a call can be made
  334.  
  335.     if (line.callState == 0)        // our internal flag that line is not in use
  336.         lpAddressStatus->dwAddressFeatures = LINEADDRFEATURE_MAKECALL;
  337.     else
  338.     {
  339.         lpAddressStatus->dwNumInUse      = 1;
  340.         lpAddressStatus->dwNumActiveCalls = 1;
  341.     }
  342.  
  343.     return 0;
  344. }
  345.  
  346. LONG TSPIAPI TSPI_lineGetCallAddressID (
  347. HDRVCALL    hdCall,
  348. LPDWORD lpdwAddressID)
  349. {
  350.     DebugMsg (("Entering TSPI_lineGetCallAddressID"));
  351.  
  352.     if (hdCall != (HDRVCALL) line.hdCall)
  353.         return LINEERR_INVALCALLHANDLE;
  354.  
  355.     // There is but a single address where a call may exist.
  356.     *lpdwAddressID = 0;
  357.   
  358.     return 0;
  359. }
  360.  
  361.  
  362. LONG TSPIAPI TSPI_lineGetDevCaps (
  363. DWORD dwDeviceID,
  364. DWORD dwTSPIVersion, 
  365. DWORD dwExtVersion,
  366. LPLINEDEVCAPS lpLineDevCaps)
  367. {
  368.     int cbname = _fstrlen (line.linename)   + 1;
  369.     int cbinfo = _fstrlen (gszProviderInfo) + 1;
  370.  
  371.     DebugMsg (("Entering TSPI_lineGetDevCaps"));
  372.  
  373.     if (dwDeviceID != line.lineID)
  374.         return LINEERR_BADDEVICEID;
  375.  
  376.  
  377.     lpLineDevCaps->dwUsedSize   = sizeof (LINEDEVCAPS);
  378.     lpLineDevCaps->dwNeededSize = sizeof (LINEDEVCAPS) + cbinfo + cbname;
  379.  
  380.   
  381.     if (lpLineDevCaps->dwTotalSize >= lpLineDevCaps->dwUsedSize + cbinfo)
  382.     {
  383.         // Copy in the provider info
  384.  
  385.         _fmemcpy ((char *)lpLineDevCaps + lpLineDevCaps->dwUsedSize, 
  386.                                                 gszProviderInfo, cbinfo);
  387.  
  388.         lpLineDevCaps->dwProviderInfoSize   = cbinfo;
  389.         lpLineDevCaps->dwProviderInfoOffset = lpLineDevCaps->dwUsedSize;
  390.         lpLineDevCaps->dwUsedSize             += cbinfo;
  391.     }
  392.   
  393.     if (lpLineDevCaps->dwTotalSize >= lpLineDevCaps->dwUsedSize + cbname)
  394.     {
  395.         // Copy in the line name
  396.  
  397.         _fmemcpy((char *) lpLineDevCaps + lpLineDevCaps->dwUsedSize,
  398.                                                 line.linename, cbname);
  399.    
  400.         lpLineDevCaps->dwLineNameSize       = cbname;
  401.         lpLineDevCaps->dwLineNameOffset = lpLineDevCaps->dwUsedSize;
  402.         lpLineDevCaps->dwUsedSize         += cbname;
  403.     }
  404.   
  405.  
  406.     lpLineDevCaps->dwPermanentLineID        = (line.dwppID << 16) + 0;
  407.   
  408.     // TAPI.DLL fills in APIVersion and ExtVersion.
  409.  
  410.     lpLineDevCaps->dwNumAddresses           =   1;
  411.     lpLineDevCaps->dwMaxNumActiveCalls  =   1;
  412.     lpLineDevCaps->dwStringFormat           =   STRINGFORMAT_ASCII;
  413.     lpLineDevCaps->dwBearerModes            =   LINEBEARERMODE_VOICE;
  414.     lpLineDevCaps->dwMediaModes         =   LINEMEDIAMODE_INTERACTIVEVOICE |
  415.                                                 LINEMEDIAMODE_AUTOMATEDVOICE;
  416.     lpLineDevCaps->dwGenerateToneModes  =   LINETONEMODE_CUSTOM |
  417.                                                 LINETONEMODE_BEEP;
  418.     lpLineDevCaps->dwGenerateToneMaxNumFreq = 2;
  419.     lpLineDevCaps->dwMonitorToneMaxNumFreq = 0;
  420.     lpLineDevCaps->dwMonitorDigitModes  =   LINEDIGITMODE_DTMF;
  421.     lpLineDevCaps->dwGenerateDigitModes =   LINEDIGITMODE_PULSE | LINEDIGITMODE_DTMF;
  422.     lpLineDevCaps->dwRingModes          =   1;
  423.     lpLineDevCaps->dwLineStates         =   LINEDEVSTATE_OTHER |
  424.                                                         LINEDEVSTATE_RINGING |
  425.                                                         LINEDEVSTATE_CONNECTED |
  426.                                                         LINEDEVSTATE_DISCONNECTED |
  427.                                                         LINEDEVSTATE_OPEN |
  428.                                                         LINEDEVSTATE_CLOSE |
  429.                                                         LINEDEVSTATE_NUMCALLS |
  430.                                                         LINEDEVSTATE_REINIT;
  431.  
  432.     lpLineDevCaps->MinDialParams.dwDialSpeed                = MIN_DIALSPEED;
  433.     lpLineDevCaps->DefaultDialParams.dwDialSpeed            = DEF_DIALSPEED;
  434.     lpLineDevCaps->MaxDialParams.dwDialSpeed                = MAX_DIALSPEED;
  435.  
  436.     lpLineDevCaps->MinDialParams.dwDigitDuration            = MIN_DURATION;
  437.     lpLineDevCaps->DefaultDialParams.dwDigitDuration    = DEF_DURATION;
  438.     lpLineDevCaps->MaxDialParams.dwDigitDuration            = MAX_DURATION;
  439.  
  440.     lpLineDevCaps->MinDialParams.dwWaitForDialtone      = MIN_DIALTONE;
  441.     lpLineDevCaps->DefaultDialParams.dwWaitForDialtone  = DEF_DIALTONE;
  442.     lpLineDevCaps->MaxDialParams.dwWaitForDialtone      = MAX_DIALTONE;
  443.  
  444.     lpLineDevCaps->MinDialParams.dwDialPause                = MIN_DIALPAUSE;
  445.     lpLineDevCaps->DefaultDialParams.dwDialPause            = DEF_DIALPAUSE;
  446.     lpLineDevCaps->MaxDialParams.dwDialPause                = MAX_DIALPAUSE;
  447.  
  448.     // we make an assumption in this sample code that a "stock"
  449.     // at modem will understand @ and W but not $ modifiers
  450.  
  451.     lpLineDevCaps->dwDevCapFlags =  LINEDEVCAPFLAGS_DIALQUIET |
  452.                                                 LINEDEVCAPFLAGS_DIALDIALTONE;
  453.  
  454.     return 0;
  455. }
  456.  
  457. LONG TSPIAPI TSPI_lineGetID (
  458. HDRVLINE            hdLine,
  459. DWORD               dwAddressID,
  460. HDRVCALL            hdCall,
  461. DWORD               dwSelect,
  462. LPVARSTRING     lpDeviceID,
  463. LPCSTR          lpszDeviceClass)
  464. {
  465.     DebugMsg (("Entering TSPI_lineGetID"));
  466.  
  467.     // Since we have only one device, we don't have to
  468.     // check the location of the line, address, or call.
  469.  
  470.     if (hdLine != (HDRVLINE) &line)
  471.         return LINEERR_INVALLINEHANDLE;
  472.  
  473.     if (hdCall != (HDRVCALL) line.hdCall)
  474.         return LINEERR_INVALCALLHANDLE;
  475.  
  476.     if (_fstrcmp (lpszDeviceClass, "tapi/line") == 0)
  477.     {
  478.         lpDeviceID->dwNeededSize = sizeof (VARSTRING) + sizeof (DWORD);
  479.  
  480.         if (lpDeviceID->dwTotalSize >= lpDeviceID->dwNeededSize)
  481.         {
  482.             lpDeviceID->dwUsedSize      = lpDeviceID->dwNeededSize;
  483.         lpDeviceID->dwStringFormat  = STRINGFORMAT_BINARY;
  484.         lpDeviceID->dwStringSize    = sizeof (DWORD);
  485.         lpDeviceID->dwStringOffset  = sizeof (VARSTRING);
  486.         
  487.         *((DWORD *) ((char *) lpDeviceID + sizeof (VARSTRING))) = line.lineID;
  488.         }
  489.  
  490.       return 0;
  491.     }
  492.   
  493.     if (_fstrcmp (lpszDeviceClass, "comm") == 0)
  494.     {
  495.       int cbport = _fstrlen (line.port) + 1;
  496.  
  497.       lpDeviceID->dwNeededSize = sizeof (VARSTRING) + cbport;
  498.  
  499.         if (lpDeviceID->dwTotalSize >= lpDeviceID->dwNeededSize)
  500.         {
  501.             lpDeviceID->dwUsedSize      = lpDeviceID->dwNeededSize;
  502.             lpDeviceID->dwStringFormat = STRINGFORMAT_ASCII;
  503.             lpDeviceID->dwStringSize    = cbport;
  504.             lpDeviceID->dwStringOffset = sizeof (VARSTRING);
  505.  
  506.             _fmemcpy ((char *) lpDeviceID + sizeof (VARSTRING), line.port, cbport);
  507.         }
  508.  
  509.         return 0;
  510.     }
  511.   
  512.     return LINEERR_NODEVICE;
  513. }
  514.  
  515. LONG TSPIAPI TSPI_lineGetLineDevStatus (
  516. HDRVLINE             hdLine,
  517. LPLINEDEVSTATUS lpLineDevStatus)
  518. {
  519.     DebugMsg (("Entering TSPI_lineGetLineDevStatus"));
  520.   
  521.     if (hdLine != (HDRVLINE) &line)
  522.         return LINEERR_INVALLINEHANDLE;
  523.  
  524.     lpLineDevStatus->dwUsedSize      =
  525.     lpLineDevStatus->dwNeededSize        = sizeof (LINEDEVSTATUS);
  526.  
  527.     lpLineDevStatus->dwOpenMediaModes = line.dwLineMediaModes;
  528.     lpLineDevStatus->dwRoamMode      = LINEROAMMODE_UNAVAIL;
  529.  
  530.     if (line.callState == 0)
  531.     {
  532.         lpLineDevStatus->dwNumActiveCalls = 0;
  533.         lpLineDevStatus->dwLineFeatures  = LINEFEATURE_MAKECALL;
  534.     }
  535.     else
  536.     {
  537.         lpLineDevStatus->dwNumActiveCalls = 1;
  538.         lpLineDevStatus->dwDevStatusFlags = LINEDEVSTATUSFLAGS_CONNECTED |
  539.                                                         LINEDEVSTATUSFLAGS_INSERVICE;
  540.     }
  541.  
  542.     return 0;
  543. }
  544.  
  545. LONG TSPIAPI TSPI_lineGetNumAddressIDs (
  546. HDRVLINE    hdLine,
  547. LPDWORD lpNumAddressIDs)
  548. {
  549.     DebugMsg (("Entering TSPI_lineGetNumAddressIDs"));
  550.   
  551.     if (hdLine != (HDRVLINE) &line)
  552.         return LINEERR_INVALLINEHANDLE;
  553.  
  554.     *lpNumAddressIDs = 1;   // We only support one address
  555.     return 0;
  556. }
  557.  
  558. LONG CheckDestAddress (LPCSTR szAddr)
  559. {
  560.     char ch;
  561.     int  i;
  562.  
  563.     for (i = 1; ch = *szAddr++; i++)
  564.     {
  565.         if (ch == '?')
  566.             return LINEERR_DIALPROMPT;
  567.         else if (ch == '$')
  568.             return LINEERR_DIALBILLING;
  569.     }
  570.  
  571.     if (i > TAPIMAXDESTADDRESSSIZE)
  572.         return LINEERR_INVALPOINTER;
  573.  
  574.     return 0;
  575. }
  576.  
  577. LONG TSPIAPI TSPI_lineMakeCall (
  578. DRV_REQUESTID               dwRequestID,
  579. HDRVLINE                        hdLine,
  580. HTAPICALL                   htCall,
  581. LPHDRVCALL                  lphdCall,
  582. LPCSTR                      lpszDestAddress,
  583. DWORD                           dwCountryCode,
  584. LPLINECALLPARAMS const  lpCallParams)
  585. {
  586.     long res;
  587.     
  588.     DebugMsg (("Entering TSPI_lineMakeCall"));
  589.  
  590.     // check for invalid dial string (wierd chars or length)
  591.     if (lpszDestAddress && (res = CheckDestAddress (lpszDestAddress)))
  592.         return res;
  593.  
  594.     if (line.callState != 0 && line.callState != LINECALLSTATE_IDLE)
  595.         return LINEERR_RESOURCEUNAVAIL;
  596.   
  597.     if (lpCallParams)
  598.     {
  599.         if (lpCallParams->dwBearerMode != LINEBEARERMODE_VOICE)
  600.             return LINEERR_INVALBEARERMODE;
  601.  
  602.         if (lpCallParams->dwMediaMode != LINEMEDIAMODE_INTERACTIVEVOICE)
  603.             return LINEERR_INVALMEDIAMODE;
  604.     
  605.         if (lpCallParams->dwCallParamFlags & 
  606.              !(LINECALLPARAMFLAGS_IDLE | LINECALLPARAMFLAGS_BLOCKID))
  607.             return LINEERR_INVALCALLPARAMS;
  608.  
  609.         fillDialParams (&lpCallParams->DialParams, &line.dpDialParams);
  610.     }
  611.  
  612.     // fill in fields of the call record
  613.     line.hdCall = (HDRVCALL)htCall; // We have no hdCall of our own, so we'll use TAPI's handle
  614.     line.htCall = htCall;
  615.     *lphdCall = (HDRVCALL) htCall;
  616.  
  617.     if (lpszDestAddress != NULL)
  618.         _fstrcpy (line.DestAddress, lpszDestAddress);
  619.     else 
  620.         line.DestAddress[0] = 0;            
  621.   
  622.  
  623.     // finally, set off the async call in our companion app
  624.     {   
  625.         ATSPLineData *myline = &line;
  626.         long res = appCall (msgMakeCall, (long) myline, dwRequestID);
  627.  
  628.         if (res < 0)
  629.             return res;
  630.         else
  631.             return dwRequestID;
  632.     }
  633. }
  634.  
  635.  
  636. LONG TSPIAPI TSPI_lineSetAppSpecific (
  637. HDRVCALL    hdCall,
  638. DWORD       dwAppSpecific)
  639. {
  640.     DebugMsg (("Entering TSPI_lineSetAppSpecific"));
  641.  
  642.     if (hdCall != line.hdCall)
  643.         return LINEERR_INVALCALLHANDLE;
  644.  
  645.     line.dwAppSpecific = dwAppSpecific;
  646.  
  647.     (*(line.lpfnEventProc)) (line.htLine, line.htCall, LINE_CALLINFO, 
  648.                                      LINECALLINFOSTATE_APPSPECIFIC, 0, 0);
  649.     return 0;
  650. }
  651.  
  652. LONG TSPIAPI TSPI_lineConditionalMediaDetection ( 
  653. HDRVLINE          hdLine,
  654. DWORD             dwMediaModes,
  655. LPLINECALLPARAMS  const lpCallParams)
  656. {
  657.     DebugMsg (("Entering TSPI_lineConditionalMediaDetection"));
  658.  
  659.     if (hdLine != (HDRVLINE) &line)
  660.         return LINEERR_INVALLINEHANDLE;
  661.  
  662.     if (dwMediaModes != LINEMEDIAMODE_INTERACTIVEVOICE)
  663.         return LINEERR_INVALMEDIAMODE;
  664.  
  665.     return 0;
  666. }
  667.  
  668. LONG TSPIAPI TSPI_lineSetDefaultMediaDetection (
  669. HDRVLINE    hdLine,
  670. DWORD       dwMediaModes)
  671. {
  672.     DebugMsg (("Entering TSPI_lineSetDefaultMediaDetection"));
  673.  
  674.     if (hdLine != (HDRVLINE) &line)
  675.         return LINEERR_INVALLINEHANDLE;
  676.  
  677.     if (dwMediaModes && (dwMediaModes & (~LINEMEDIAMODE_INTERACTIVEVOICE) & (~LINEMEDIAMODE_AUTOMATEDVOICE)) )
  678.         {
  679.         DebugMsg(("Returning LINEERR_INVALMEDIAMODE"));
  680.         return LINEERR_INVALMEDIAMODE;
  681.         }
  682.         
  683.     line.dwLineMediaModes = dwMediaModes;
  684.     
  685.     return 0;
  686. }
  687.  
  688. LONG TSPIAPI TSPI_lineSetMediaMode (
  689. HDRVCALL    hdCall,
  690. DWORD       dwMediaMode)
  691. { 
  692.     DebugMsg (("Entering TSPI_lineSetMediaMode"));
  693.   
  694.     if (hdCall != (HDRVCALL) line.hdCall)
  695.         {
  696.         DebugMsg(("Invalid call handle"));
  697.         return LINEERR_INVALCALLHANDLE;
  698.         }
  699.         
  700.     if (dwMediaMode && (dwMediaMode & (LINEMEDIAMODE_INTERACTIVEVOICE | LINEMEDIAMODE_AUTOMATEDVOICE) ) == 0 )
  701.         {
  702.         DebugMsg(("Invalid Media Mode"));
  703.         return LINEERR_INVALMEDIAMODE;
  704.         }
  705.         
  706.     line.dwMediaMode = dwMediaMode;
  707.     
  708.     return 0;
  709. }
  710.  
  711. LONG TSPIAPI TSPI_lineSetStatusMessages (
  712. HDRVLINE    hdLine,
  713. DWORD       dwLineStates,
  714. DWORD       dwAddressStates)
  715. {
  716.     DebugMsg (("Entering TSPI_lineSetStatusMessages"));
  717.  
  718.     if (hdLine != (HDRVLINE) &line)
  719.         return LINEERR_INVALLINEHANDLE;
  720.  
  721.     line.dwLineStates       = dwLineStates;
  722.     line.dwAddressStates    = dwAddressStates;
  723.     
  724.     return 0;
  725. }
  726.  
  727.  
  728. ///////////////////////////////////////////////////////////
  729. // CHANGES NEEDED!!!
  730. ///////////////////////////////////////////////////////////
  731.  
  732.  
  733. LONG TSPIAPI TSPI_lineDial (
  734. DRV_REQUESTID   dwRequestID, 
  735. HDRVCALL            hdCall,
  736. LPCSTR          lpszDestAddress, 
  737. DWORD               dwCountryCode)
  738. {
  739.     LONG res;
  740.  
  741.     DebugMsg (("Entering TSPI_lineDial"));
  742.   
  743.     if (hdCall != (HDRVCALL) line.hdCall)
  744.         return LINEERR_INVALCALLHANDLE;
  745.  
  746.     if  (line.callState != LINECALLSTATE_DIALTONE &&
  747.          line.callState != LINECALLSTATE_DIALING)
  748.         return LINEERR_INVALCALLSTATE;
  749.  
  750.     // check for invalid dial string (wierd chars or length)
  751.     // we can assume lpszDestAddress is a valid pointer as TAPI checks it
  752.  
  753.     if (res = CheckDestAddress (lpszDestAddress))
  754.         return res;
  755.  
  756.     _fstrcpy (line.DestAddress, lpszDestAddress);
  757.  
  758.     // With the second parameter set to TRUE, DialAndGetState
  759.     // will take care of updating the state of the call through
  760.     // the event proc.
  761.   
  762. //BUG DialAndGetState should return error as retval
  763. //  if (DialAndGetState (&line, TRUE) == CALL_STATE_ERROR)
  764.         res = LINEERR_OPERATIONFAILED;
  765.    
  766.     (*(line.lpfnCompletion)) (dwRequestID, res);
  767.     return dwRequestID;
  768. }
  769.  
  770.  
  771. LONG TSPIAPI TSPI_lineGenerateDigits (
  772. HDRVCALL            hdCall,
  773. DWORD               dwEndToEndID,
  774. DWORD               dwDigitMode, 
  775. LPCSTR          lpszDigits,
  776. DWORD               dwDuration)
  777. { 
  778.     char szDigitBuf[MEDIUMBUFFER];
  779.     int  res;
  780.  
  781. //BUG this could go real async in new model
  782. //BUG in that case a new generate digits call would be required 
  783. // to kill an old call and a call with null for lpszDigits would
  784. // kill the old digit generation without initiating a new string
  785.  
  786.     DebugMsg (("Entering TSPI_lineGenerateDigits"));
  787.  
  788.     if (hdCall != (HDRVCALL) line.hdCall)
  789.         return LINEERR_INVALCALLHANDLE;
  790.  
  791.     if (line.callState != LINECALLSTATE_BUSY &&
  792.          line.callState != LINECALLSTATE_DIALTONE &&
  793.          line.callState != LINECALLSTATE_CONNECTED)
  794.         return LINEERR_INVALCALLSTATE;
  795.  
  796.     if (dwDuration == 0)
  797.         dwDuration = line.dpDialParams.dwDigitDuration;
  798.     else if (dwDuration < MIN_DURATION)
  799.         dwDuration = MIN_DURATION;
  800.     else if (dwDuration > MAX_DURATION)
  801.         dwDuration = MAX_DURATION;
  802.  
  803.     if (dwDigitMode == LINEDIGITMODE_PULSE)
  804.         wsprintf (szDigitBuf, "ATX0S6=0DP%s;X4", lpszDigits);
  805.     else
  806.         wsprintf (szDigitBuf, "ATX0S6=0S11=%luDT%s;X4", dwDuration, lpszDigits);
  807.   
  808.     // We neglect to check for some errors here to speed up this
  809.     // process.  It's time critical and failure is unimportant in
  810.     // most cases.
  811.  
  812. //  res = SendModemCommand (line.uiCommId, szDigitBuf);
  813.  
  814.     if (res >= 0)   //BUG what does >0 mean ?
  815.     {
  816. //      res = GetModemReply (line.uiCommId, szDigitBuf, sizeof (szDigitBuf));
  817.         
  818. //BUG why not just send command, what's the deal with the following hangup
  819.  
  820.         if (res == SERIAL_OK &&
  821.              _fstrcmp (szDigitBuf, "OK") == 0)
  822.             {
  823. //              SendModemCommand (line.uiCommId, s_hangup);
  824. //BUG
  825. // and send LINEGENERATE message
  826.             }
  827.     }
  828.  
  829.   return LINEERR_OPERATIONFAILED;
  830. }
  831.  
  832. LONG TSPIAPI TSPI_lineGetAddressCaps (
  833. DWORD                   dwDeviceID,
  834. DWORD                   dwAddressID,
  835. DWORD                   dwTSPIVersion,
  836. DWORD                   dwExtVersion,
  837. LPLINEADDRESSCAPS lpAddressCaps)
  838.  
  839. {
  840.     int cbLineAddr;
  841.  
  842.     DebugMsg (("Entering TSPI_lineGetAddressCaps"));
  843.  
  844.     // We support only one line and one address.
  845.   
  846.     if (dwDeviceID != line.lineID)
  847.         return LINEERR_BADDEVICEID;
  848.  
  849.     if (dwAddressID != 0)
  850.         return LINEERR_INVALADDRESSID;
  851.   
  852.     cbLineAddr = _fstrlen (line.lineaddr) + 1;
  853.  
  854.     lpAddressCaps->dwNeededSize = sizeof (LINEADDRESSCAPS) + cbLineAddr;
  855.  
  856.     if (lpAddressCaps->dwTotalSize < lpAddressCaps->dwNeededSize)
  857.         lpAddressCaps->dwUsedSize = sizeof (LINEADDRESSCAPS);
  858.     else
  859.     {
  860.         _fmemcpy((char *) lpAddressCaps + sizeof (LINEADDRESSCAPS), 
  861.                     line.lineaddr, cbLineAddr);
  862.  
  863.         lpAddressCaps->dwAddressSize     = cbLineAddr;
  864.         lpAddressCaps->dwAddressOffset = sizeof (LINEADDRESSCAPS);
  865.         lpAddressCaps->dwUsedSize        = lpAddressCaps->dwNeededSize;
  866.     }
  867.   
  868.     lpAddressCaps->dwLineDeviceID           =   line.lineID;
  869.  
  870.     lpAddressCaps->dwAddressSharing     =   LINEADDRESSSHARING_PRIVATE;
  871.     lpAddressCaps->dwAddressStates      =   LINEADDRESSSTATE_OTHER |
  872.                                                         LINEADDRESSSTATE_INUSEZERO |
  873.                                                         LINEADDRESSSTATE_INUSEONE |
  874.                                                         LINEADDRESSSTATE_NUMCALLS;
  875.     lpAddressCaps->dwCallInfoStates     =   LINECALLINFOSTATE_OTHER |
  876.                                                         LINECALLINFOSTATE_APPSPECIFIC |
  877.                                                         LINECALLINFOSTATE_NUMOWNERINCR |
  878.                                                         LINECALLINFOSTATE_NUMOWNERDECR |
  879.                                                         LINECALLINFOSTATE_NUMMONITORS |
  880.                                                         LINECALLINFOSTATE_DIALPARAMS |
  881.                                                         LINECALLINFOSTATE_MONITORMODES;
  882.     lpAddressCaps->dwCallerIDFlags      =   LINECALLPARTYID_UNAVAIL;
  883.     lpAddressCaps->dwCalledIDFlags      =   LINECALLPARTYID_UNAVAIL;
  884.     lpAddressCaps->dwConnectedIDFlags   =   LINECALLPARTYID_UNAVAIL;
  885.     lpAddressCaps->dwRedirectionIDFlags =   LINECALLPARTYID_UNAVAIL;
  886.     lpAddressCaps->dwRedirectingIDFlags =   LINECALLPARTYID_UNAVAIL;
  887.     lpAddressCaps->dwCallStates         =   LINECALLSTATE_IDLE |
  888.                                                         LINECALLSTATE_OFFERING |
  889.                                                         LINECALLSTATE_DIALTONE |
  890.                                                         LINECALLSTATE_DIALING |
  891.                                                         LINECALLSTATE_BUSY |
  892.                                                         LINECALLSTATE_CONNECTED |
  893.                                                         LINECALLSTATE_PROCEEDING |
  894.                                                         LINECALLSTATE_UNKNOWN;
  895.     lpAddressCaps->dwDialToneModes      =   LINEDIALTONEMODE_UNAVAIL;
  896.     lpAddressCaps->dwBusyModes              =   LINEBUSYMODE_UNAVAIL;
  897.     lpAddressCaps->dwSpecialInfo            =   LINESPECIALINFO_UNAVAIL;
  898.     lpAddressCaps->dwDisconnectModes        =   LINEDISCONNECTMODE_UNKNOWN;
  899.     lpAddressCaps->dwMaxNumActiveCalls  =   1;
  900.     lpAddressCaps->dwAddrCapFlags           =   LINEADDRCAPFLAGS_BLOCKIDDEFAULT |
  901.                                                         LINEADDRCAPFLAGS_DIALED |
  902.                                                         LINEADDRCAPFLAGS_PARTIALDIAL;
  903.     lpAddressCaps->dwCallFeatures           =   LINECALLFEATURE_ANSWER |
  904.                                                         LINECALLFEATURE_DIAL |
  905.                                                         LINECALLFEATURE_DROP |
  906.                                                         LINECALLFEATURE_GENERATEDIGITS |
  907.                                                         LINECALLFEATURE_GENERATETONE |
  908.                                                         LINECALLFEATURE_MONITORDIGITS |
  909.                                                         LINECALLFEATURE_MONITORTONES;
  910.  
  911.     return 0;
  912. }
  913.  
  914.  
  915. LONG TSPIAPI TSPI_lineGetCallInfo (
  916. HDRVCALL            hdCall,
  917. LPLINECALLINFO  lpCallInfo)
  918. {
  919.     int cbDestAddr = _fstrlen (line.DestAddress) + 1;
  920.     
  921.     DebugMsg (("Entering TSPI_lineGetCallInfo"));
  922.  
  923.     if (hdCall != (HDRVCALL) line.hdCall)
  924.         return LINEERR_INVALCALLHANDLE;
  925.  
  926.  
  927.     lpCallInfo->dwUsedSize   = sizeof (LINECALLINFO);
  928.     lpCallInfo->dwNeededSize = sizeof (LINECALLINFO) + cbDestAddr;
  929.  
  930.     if (lpCallInfo->dwTotalSize < lpCallInfo->dwNeededSize)
  931.         lpCallInfo->dwUsedSize = sizeof (LINECALLINFO);
  932.     else
  933.     {
  934.         _fmemcpy((char *) lpCallInfo + sizeof (LINECALLINFO), 
  935.                     line.DestAddress, cbDestAddr);
  936.  
  937.         lpCallInfo->dwDisplayableAddressSize    = cbDestAddr;
  938.         lpCallInfo->dwDisplayableAddressOffset  = sizeof (LINECALLINFO);
  939.         lpCallInfo->dwUsedSize                      = lpCallInfo->dwNeededSize;
  940.     }
  941.  
  942.     lpCallInfo->dwLineDeviceID                  =   line.lineID;
  943.     lpCallInfo->dwBearerMode                    =   LINEBEARERMODE_VOICE;
  944.     lpCallInfo->dwMediaMode                     =   line.dwMediaMode;
  945.     lpCallInfo->dwAppSpecific                   =   line.dwAppSpecific;
  946.     lpCallInfo->dwCallParamFlags                =   LINECALLPARAMFLAGS_IDLE |
  947.                                                             LINECALLPARAMFLAGS_BLOCKID;
  948.     lpCallInfo->dwCallStates                    =   LINECALLSTATE_IDLE |
  949.                                                             LINECALLSTATE_OFFERING |
  950.                                                             LINECALLSTATE_DIALTONE |
  951.                                                             LINECALLSTATE_DIALING |
  952.                                                             LINECALLSTATE_BUSY |
  953.                                                             LINECALLSTATE_CONNECTED |
  954.                                                             LINECALLSTATE_PROCEEDING |
  955.                                                             LINECALLSTATE_UNKNOWN;
  956.     lpCallInfo->dwMonitorMediaModes = LINEMEDIAMODE_INTERACTIVEVOICE | LINEMEDIAMODE_AUTOMATEDVOICE;
  957.     lpCallInfo->dwOrigin                            =   line.dwOrigin;
  958.     lpCallInfo->dwReason                            =   LINECALLREASON_UNAVAIL;
  959.  
  960.     // Bug: Caller-ID should be enabled!
  961.     lpCallInfo->dwCallerIDFlags             =   LINECALLPARTYID_UNAVAIL;
  962.     lpCallInfo->dwCalledIDFlags             =   LINECALLPARTYID_UNAVAIL;
  963.     lpCallInfo->dwConnectedIDFlags          =   LINECALLPARTYID_UNAVAIL;
  964.     lpCallInfo->dwRedirectionIDFlags            =   LINECALLPARTYID_UNAVAIL;
  965.     lpCallInfo->dwRedirectingIDFlags            =   LINECALLPARTYID_UNAVAIL;
  966.  
  967.     lpCallInfo->DialParams                      =   line.dpDialParams;
  968.  
  969.     return 0;
  970. }
  971.  
  972. LONG TSPIAPI TSPI_lineGetCallStatus (
  973. HDRVCALL              hdCall,
  974. LPLINECALLSTATUS lpCallStatus)
  975. {
  976.     DebugMsg (("Entering TSPI_lineGetCallStatus"));
  977.  
  978.     if (hdCall != (HDRVCALL) line.hdCall)
  979.         return LINEERR_INVALCALLHANDLE;
  980.     
  981.     lpCallStatus->dwCallState = line.callState;
  982.     
  983.     switch (line.callState)
  984.     {
  985.         case LINECALLSTATE_IDLE:
  986.         case LINECALLSTATE_UNKNOWN:
  987.             break;
  988.  
  989.         case LINECALLSTATE_DIALTONE:
  990.             lpCallStatus->dwCallStateMode   =   LINEDIALTONEMODE_UNAVAIL;
  991.             // fall thru
  992.  
  993.         case LINECALLSTATE_DIALING:
  994.             lpCallStatus->dwCallFeatures    =   LINECALLFEATURE_DIAL |
  995.                                                         LINECALLFEATURE_DROP |
  996.                                                         LINECALLFEATURE_GENERATEDIGITS;
  997.             break;
  998.  
  999.  
  1000.         case LINECALLSTATE_BUSY:
  1001.             lpCallStatus->dwCallStateMode   =   LINEBUSYMODE_UNAVAIL;
  1002.             // fall thru
  1003.  
  1004.         case LINECALLSTATE_CONNECTED:
  1005.         case LINECALLSTATE_PROCEEDING:
  1006.             lpCallStatus->dwCallFeatures    =   LINECALLFEATURE_DROP |
  1007.                                                         LINECALLFEATURE_GENERATEDIGITS;
  1008.             break;
  1009.     }
  1010.  
  1011.     return 0;
  1012. }
  1013.  
  1014.  
  1015. void fillDialParams (LPLINEDIALPARAMS source, LPLINEDIALPARAMS dest)
  1016. {   
  1017.     // this could also be called from lineSetCallParams
  1018.     // Set the dial params if there are any.
  1019.  
  1020.     DWORD   pause       = source->dwDialPause;
  1021.     DWORD   speed       = source->dwDialSpeed;
  1022.     DWORD   duration = source->dwDigitDuration;
  1023.     DWORD   dialtone = source->dwWaitForDialtone;
  1024.  
  1025.     if (pause == 0)
  1026.         pause = DEF_DIALPAUSE;
  1027.     else if (pause < MIN_DIALPAUSE)
  1028.         pause = MIN_DIALPAUSE;
  1029.     else if (pause > MAX_DIALPAUSE)
  1030.         pause = MAX_DIALPAUSE;
  1031.  
  1032.     if (speed == 0)
  1033.         speed = DEF_DIALSPEED;
  1034.     else if (speed < MIN_DIALSPEED)
  1035.         speed = MIN_DIALSPEED;
  1036.     else if (speed > MAX_DIALSPEED)
  1037.         speed = MAX_DIALSPEED;
  1038.  
  1039.     if (duration == 0)
  1040.         duration = DEF_DURATION;
  1041.     else if (duration < MIN_DURATION)
  1042.         duration = MIN_DURATION;
  1043.     else if (duration > MAX_DURATION)
  1044.         duration = MAX_DURATION;
  1045.  
  1046.     if (dialtone == 0)
  1047.         dialtone = DEF_DIALTONE;
  1048.     else if (dialtone < MIN_DIALTONE)
  1049.         dialtone = MIN_DIALTONE;
  1050.     else if (dialtone > MAX_DIALTONE)
  1051.         dialtone = MAX_DIALTONE;
  1052.  
  1053.     dest->dwDialPause           = pause;
  1054.     dest->dwDialSpeed           = speed;
  1055.     dest->dwDigitDuration   = duration;
  1056.     dest->dwWaitForDialtone = dialtone;
  1057. }
  1058.  
  1059.  
  1060. ///////////////////////////////////////////////////////////
  1061. // ALREADY CHANGED!!!
  1062. ///////////////////////////////////////////////////////////
  1063.  
  1064.  
  1065. LONG TSPIAPI TSPI_lineClose (HDRVLINE hdLine)
  1066. {
  1067.     DebugMsg (("Entering TSPI_lineClose"));
  1068.   
  1069.     if (hdLine != (HDRVLINE) &line)
  1070.         return LINEERR_INVALLINEHANDLE;
  1071.  
  1072.     // call drop in case there is still an active call on the line
  1073.     lineDropCore (&line);
  1074.     
  1075.     // Tell our companion app that we are no longer accepting anything from this line
  1076.     appCall(msgClose,(LONG)(VOID FAR *)&line,0);
  1077.         
  1078.     return 0;
  1079. }
  1080.  
  1081.           
  1082. LONG TSPIAPI TSPI_lineOpen (
  1083. DWORD           dwDeviceID,
  1084. HTAPILINE   htLine,
  1085. LPHDRVLINE  lphdLine,
  1086. DWORD           dwTSPIVersion,
  1087. LINEEVENT   lpfnEventProc)
  1088. {
  1089.     DebugMsg (("Entering TSPI_lineOpen"));
  1090.   
  1091.     if (dwDeviceID != line.lineID)
  1092.         return LINEERR_BADDEVICEID;
  1093.     
  1094.     // Since we only support outgoing calls, we
  1095.     // don't open the serial port until we need to make a call
  1096.   
  1097.     line.lpfnEventProc = lpfnEventProc;
  1098.     line.htLine          = htLine;
  1099.     line.htCall          = 0;
  1100.     line.hdCall          = 0;
  1101.     *lphdLine            = (HDRVLINE) &line;
  1102.     
  1103.     DebugMsg(("htLine = %ld",(LONG)htLine));
  1104.     
  1105.     // We must inform our companion app of the lineOpen, so it knows what to do with RING!
  1106.     appCall(msgOpen,(LONG)(VOID FAR *)&line,0);
  1107.     
  1108.     return 0;
  1109. }
  1110.  
  1111.  
  1112. LONG TSPIAPI TSPI_lineDrop (
  1113. DRV_REQUESTID   dwRequestID, 
  1114. HDRVCALL            hdCall,
  1115. LPCSTR          lpsUserUserInfo, 
  1116. DWORD               dwSize)
  1117. {
  1118.     // Transition a call to the IDLE state.
  1119.   
  1120.     DebugMsg (("Entering TSPI_lineDrop"));
  1121.   
  1122.     if (hdCall != (HDRVCALL) line.hdCall)
  1123.         return LINEERR_INVALCALLHANDLE;
  1124.     
  1125.     lineDropCore (&line);   // it was our active call
  1126.     
  1127.     (*(line.lpfnCompletion)) (dwRequestID, 0);
  1128.     return dwRequestID;
  1129. }
  1130.  
  1131.  
  1132. long appCall (int msg, long param, long dwRequestID)
  1133. {
  1134.     long res;
  1135.  
  1136.     if (atspexehwnd == 0)
  1137.     {
  1138.         DebugMsg (("companion app has not yet registered"));
  1139.         return LINEERR_NODRIVER;
  1140.     }
  1141.     
  1142.     line.dwRequestID = dwRequestID;
  1143.     res = SendMessage(atspexehwnd, msg, 0, param);
  1144.     
  1145.     if (res < 0)
  1146.         {
  1147.         DebugMsg(("send message returned error: %li", res));
  1148.         return res;
  1149.         }
  1150.     else
  1151.         return dwRequestID;
  1152. }
  1153.  
  1154.  
  1155. ///////////////////////////////////////////////////////////
  1156. // NEW FUNCTIONS FOR ATVSP!!!
  1157. ///////////////////////////////////////////////////////////
  1158.  
  1159. LONG TSPIAPI TSPI_lineAnswer (
  1160. DRV_REQUESTID   dwRequestID,
  1161. HDRVCALL    hdCall,
  1162. LPCSTR  lpsUserUserInfo,
  1163. DWORD   dwSize)
  1164. {
  1165.     DebugMsg(("Entering TSPI_lineAnswer"));
  1166.     if (hdCall != (HDRVCALL)line.hdCall)
  1167.         return LINEERR_INVALCALLHANDLE;
  1168.         
  1169.     return appCall(msgAnswer, (LONG)(VOID FAR *)&line, dwRequestID);
  1170. }
  1171.  
  1172. LONG TSPIAPI TSPI_lineMonitorTones (
  1173. HDRVCALL    hdCall,
  1174. DWORD   dwToneListID,
  1175. LPLINEMONITORTONE   const lpToneList,
  1176. DWORD   dwNumEntries)
  1177. {
  1178.     DebugMsg(("Entering TSPI_lineMonitorTones"));
  1179.     
  1180.     if (hdCall != (HDRVCALL)line.hdCall)
  1181.         return LINEERR_INVALCALLHANDLE;
  1182.     
  1183.     // Note that we can only handle one tone list at a time!!!
  1184.     // Since all we can detect is silence anyway, it would be silly to have more than one tone list.
  1185.     
  1186.     if (lpToneList && dwNumEntries != 1)
  1187.         {
  1188.         DebugMsg(("Line Error: Invalid number of entries in ToneList"));
  1189.         return LINEERR_RESOURCEUNAVAIL;
  1190.         }
  1191.     if (line.callState == LINECALLSTATE_IDLE)
  1192.         {
  1193.         DebugMsg(("Line Error: CallState = IDLE")); 
  1194.         return LINEERR_INVALCALLSTATE;
  1195.         }
  1196.     if (lpToneList == NULL)
  1197.         {
  1198.         if (dwToneListID != line.dwToneListID)
  1199.             {
  1200.             DebugMsg(("Line Error: Invalid ToneListID"));
  1201.             return LINEERR_OPERATIONFAILED;
  1202.             }
  1203.             
  1204.         // We're turning off Silence Detection
  1205.         line.wSilenceSensitivity = 0;
  1206.         line.wSilenceDuration = 0;
  1207.         return 0;
  1208.         }
  1209. // Bug: The Answering Machine sends us only one frequency right now, so we comment this out!!!
  1210. //    if (lpToneList->dwFrequency1 || lpToneList->dwFrequency2 || lpToneList->dwFrequency3)
  1211. //        {
  1212. //        DebugMsg(("Line Error: Invalid tone frequency specified"));
  1213. //        return LINEERR_INVALTONE;
  1214. //        }
  1215.     
  1216.     line.dwToneListID = dwToneListID;
  1217.     line.wSilenceSensitivity = 15;   // Manufacturer's default for the modem
  1218.     line.wSilenceDuration = (WORD)lpToneList->dwDuration / 100;
  1219.     line.dwAppSpecific = lpToneList->dwAppSpecific;
  1220.         
  1221.     return appCall(msgMonitorTones, (LONG)(VOID FAR *)&line, 0L);
  1222. }
  1223.  
  1224. LONG TSPIAPI TSPI_lineMonitorDigits (
  1225. HDRVCALL    hdCall,
  1226. DWORD   dwDigitModes)
  1227. {
  1228.     DebugMsg(("Entering TSPI_lineMonitorDigits STUB"));
  1229.     return 0;
  1230. }
  1231.  
  1232. LONG TSPIAPI TSPI_lineGenerateTone (
  1233. HDRVCALL    hdCall,
  1234. DWORD   dwEndToEndID,
  1235. DWORD   dwToneMode,
  1236. DWORD   dwDuration,
  1237. DWORD   dwNumTones,
  1238. LPLINEGENERATETONE  const lpTones)
  1239. {
  1240.     LONG res;
  1241.  
  1242.     DebugMsg(("Entering TSPI_lineGenerateTone"));
  1243.     
  1244.     if (hdCall != (HDRVCALL)line.hdCall)
  1245.         return LINEERR_INVALCALLHANDLE;
  1246.     
  1247.     line.dwToneMode = dwToneMode;
  1248.     line.dwDuration = dwDuration;
  1249.     line.dwNumTones = dwNumTones;
  1250.     line.lpTones = lpTones;
  1251.         
  1252.     res = appCall(msgGenerateTone, (LONG)(VOID FAR *)&line, dwEndToEndID);
  1253.     
  1254.     return (res >= 0 ? 0 : res);
  1255. }
  1256.  
  1257.  
  1258. ///////////////////////////////////////////////////////////
  1259. // The configuration trio
  1260. ///////////////////////////////////////////////////////////
  1261.  
  1262. // These routines are called from the control panel applet
  1263. // TAPI may not be running at this point, so one cannot assume
  1264. // we have been initialised
  1265.  
  1266. LONG TSPIAPI TSPI_providerConfig (HWND hwnd, DWORD dwPermanentProviderId)
  1267. {
  1268.     DebugMsg (("Entering TSPI_providerConfig"));
  1269.  
  1270.     LoadIniStrings (dwPermanentProviderId);
  1271.  
  1272.     DialogBox (hInst, MAKEINTRESOURCE (IDD_CFGDLG), hwnd, ConfigDlgProc);
  1273.  
  1274.     return 0;
  1275. }
  1276.  
  1277.  
  1278. LONG TSPIAPI TSPI_providerInstall (HWND hwnd, DWORD dwPermanentProviderId)
  1279. {
  1280.     int res;
  1281.     char szProvider[sizeof (s_providerx) + 5];      // room for 65535
  1282.  
  1283.     DebugMsg (("Entering TSPI_providerInstall"));
  1284.  
  1285.     LoadIniStrings (dwPermanentProviderId);
  1286.  
  1287.     wsprintf (szProvider, s_providerx, (int) dwPermanentProviderId);
  1288.     
  1289.     // we support 1 line and 0 phones
  1290.  
  1291.     WritePrivateProfileString (szProvider, s_numlines,  s_one,  s_telephon_ini);
  1292.     WritePrivateProfileString (szProvider, s_numphones, s_zero, s_telephon_ini);
  1293.  
  1294.     // Flush the ini file cache.
  1295.     WritePrivateProfileString (0, 0, 0, s_telephon_ini);
  1296.  
  1297.     // display the config screen
  1298.     res = DialogBox (hInst, MAKEINTRESOURCE (IDD_CFGDLG), hwnd, ConfigDlgProc);
  1299.     return (res ? LINEERR_OPERATIONFAILED : 0);
  1300. }
  1301.  
  1302.  
  1303. LONG TSPIAPI TSPI_providerRemove (HWND hwnd, DWORD dwPermanentProviderId)
  1304. {
  1305.     DebugMsg (("Entering TSPI_providerRemove"));
  1306.  
  1307.     // The control panel removes all of our junk for us
  1308.     // (and then some) when the provider is removed.
  1309.     
  1310.     return 0;
  1311. }
  1312.  
  1313.  
  1314.  
  1315. ///////////////////////////////////////////////////////////
  1316. // Internal support routines
  1317. ///////////////////////////////////////////////////////////
  1318.  
  1319. static BOOL StringResourcesLoaded = FALSE;
  1320.  
  1321. void LoadIniStrings (DWORD ppID)
  1322. {
  1323.     char section[sizeof (s_providerx) + 5];     // room for 65535
  1324.  
  1325.     if (StringResourcesLoaded)
  1326.         return;  
  1327.  
  1328.     wsprintf (section, s_providerx, (int) ppID);
  1329.     line.dwppID = ppID;
  1330.  
  1331.     // user preferences come from the telephon.ini file
  1332.  
  1333.     line.ignore = GetPrivateProfileInt (section, s_ignore, 0, s_telephon_ini);
  1334.     line.pulse  = GetPrivateProfileInt (section, s_pulse,  0, s_telephon_ini);
  1335.  
  1336.     GetPrivateProfileString (section, s_port, "COM1", 
  1337.                                      line.port,  sizeof (line.port), s_telephon_ini);
  1338.     GetPrivateProfileString (section, s_speed, "9600", 
  1339.                                      line.speed, sizeof (line.speed), s_telephon_ini);
  1340.     GetPrivateProfileString (section, s_initstr, "", 
  1341.                                      line.initstr, sizeof (line.initstr), s_telephon_ini);
  1342.     GetPrivateProfileString (section, s_linename, "", 
  1343.                                      line.linename, sizeof (line.linename), s_telephon_ini);
  1344.     GetPrivateProfileString (section, s_lineaddr, "", 
  1345.                                      line.lineaddr, sizeof (line.lineaddr), s_telephon_ini);
  1346.  
  1347.     // the provider info string comes from the resource file
  1348.  
  1349.     gszProviderInfo[0] = 0;     // in case loadstring fails
  1350.  
  1351.     LoadString (hInst, ID_PROVIDER_INFO, gszProviderInfo, sizeof (gszProviderInfo));
  1352.   
  1353.  
  1354.     StringResourcesLoaded = TRUE;
  1355.  
  1356.     return;
  1357. }
  1358.  
  1359.  
  1360. BOOL CALLBACK __export 
  1361. ConfigDlgProc (HWND hDlg, UINT uiMsg, WPARAM wParam, LPARAM lParam)
  1362. {
  1363.   int CurrSel;
  1364.  
  1365.   switch (uiMsg) 
  1366.   {
  1367.     case WM_INITDIALOG:
  1368.    {
  1369.         for (CurrSel = 0; CurrSel < NUMPORTS; CurrSel++)
  1370.         {
  1371.             // List the port in the combo box.
  1372.             SendDlgItemMessage (hDlg, ID_PORT, CB_ADDSTRING,
  1373.                                     0, (LPARAM) ((LPSTR) lpszCommDevArray[CurrSel]));
  1374.         }
  1375.                                     
  1376.         for (CurrSel = 0; CurrSel < NUMSPEEDS; CurrSel++)
  1377.         {
  1378.             SendDlgItemMessage(hDlg, ID_SPEED, CB_ADDSTRING,
  1379.                                 0, (LPARAM) ((LPSTR) lpszCommSpeedArray[CurrSel]));
  1380.         }
  1381.     
  1382.         CurrSel = (int) SendDlgItemMessage (hDlg, ID_PORT,  CB_FINDSTRING, 0, (LPARAM) (LPSTR) line.port);
  1383.         SendDlgItemMessage (hDlg, ID_PORT,      CB_SETCURSEL, CurrSel, 0);
  1384.         CurrSel = (int) SendDlgItemMessage (hDlg, ID_SPEED, CB_FINDSTRING, 0, (LPARAM) (LPSTR) line.speed);
  1385.         SendDlgItemMessage (hDlg, ID_SPEED,     CB_SETCURSEL, CurrSel, 0);
  1386.  
  1387.         SendDlgItemMessage (hDlg, ID_LINENAME, WM_SETTEXT, 0, (LPARAM) (LPSTR) line.linename);
  1388.         SendDlgItemMessage (hDlg, ID_LINEADDR, WM_SETTEXT, 0, (LPARAM) (LPSTR) line.lineaddr);
  1389.         SendDlgItemMessage (hDlg, ID_INITSTR,   WM_SETTEXT, 0, (LPARAM) (LPSTR) line.initstr);
  1390.         SendDlgItemMessage (hDlg, ID_IGNORE,    BM_SETCHECK, line.ignore, 0);
  1391.         SendDlgItemMessage (hDlg, ID_PULSE,     BM_SETCHECK, line.pulse, 0);
  1392.     }
  1393.     break;
  1394.  
  1395.     case WM_COMMAND:
  1396.     {
  1397.       switch (wParam) 
  1398.       {
  1399.         case IDOK:
  1400.         {
  1401.             // This code is a little brutal, it writes out all the
  1402.             // (new) values when OK is pressed, even if nothing
  1403.             // changed
  1404.  
  1405.             char Buffer[20];    // for itoa of small ints
  1406.  
  1407.             char szp[sizeof (s_providerx) + 5];     // room for 65535
  1408.             wsprintf (szp, s_providerx, (int) line.dwppID);
  1409.  
  1410.             // Port
  1411.  
  1412.             CurrSel = (int) SendDlgItemMessage (hDlg, ID_PORT, CB_GETCURSEL, 0, 0);
  1413.             SendDlgItemMessage (hDlg, ID_PORT, CB_GETLBTEXT, CurrSel, (LPARAM) (LPSTR) line.port);
  1414.             WritePrivateProfileString (szp, s_port, line.port, s_telephon_ini);
  1415.       
  1416.             // Speed
  1417.  
  1418.             CurrSel = (int) SendDlgItemMessage (hDlg, ID_SPEED, CB_GETCURSEL, 0, 0);
  1419.             SendDlgItemMessage (hDlg, ID_SPEED, CB_GETLBTEXT, CurrSel, (LPARAM) (LPSTR) line.speed);
  1420.             WritePrivateProfileString (szp, s_speed, line.speed, s_telephon_ini);
  1421.         
  1422.             // Line Name
  1423.  
  1424.             SendDlgItemMessage (hDlg, ID_LINENAME, WM_GETTEXT,
  1425.                                     sizeof (line.linename), (LPARAM) (LPSTR) line.linename);
  1426.             WritePrivateProfileString (szp, s_linename, line.linename, s_telephon_ini);
  1427.  
  1428.             // Line Address
  1429.  
  1430.             SendDlgItemMessage (hDlg, ID_LINEADDR, WM_GETTEXT,
  1431.                                     sizeof (line.lineaddr), (LPARAM) (LPSTR) line.lineaddr);
  1432.             WritePrivateProfileString (szp, s_lineaddr, line.lineaddr, s_telephon_ini);
  1433.  
  1434.             // Initialisation String
  1435.  
  1436.             SendDlgItemMessage (hDlg, ID_INITSTR, WM_GETTEXT, 
  1437.                                     sizeof (line.initstr), (LPARAM) (LPSTR) line.initstr);
  1438.             AnsiUpper (line.initstr);
  1439.             WritePrivateProfileString (szp, s_initstr, line.initstr, s_telephon_ini);
  1440.  
  1441.             // "Don't use internal string" checkbox
  1442.  
  1443.             line.ignore = (int) SendDlgItemMessage (hDlg, ID_IGNORE, BM_GETCHECK, 0, 0);
  1444.             _itoa(line.ignore, Buffer, 10);
  1445.             WritePrivateProfileString (szp, s_ignore, Buffer, s_telephon_ini);
  1446.  
  1447.             // "Use pulse dialing"
  1448.  
  1449.             line.pulse = (int) SendDlgItemMessage(hDlg, ID_PULSE, BM_GETCHECK, 0, 0);
  1450.             _itoa(line.pulse, Buffer, 10);
  1451.             WritePrivateProfileString (szp, s_pulse, Buffer, s_telephon_ini);
  1452.  
  1453.             // Flush the ini file cache
  1454.  
  1455.             WritePrivateProfileString (0, 0, 0, s_telephon_ini);
  1456.             EndDialog (hDlg, 0);
  1457.         }
  1458.         break;
  1459.      
  1460.         case IDCANCEL:
  1461.             EndDialog (hDlg, -1);
  1462.             break;
  1463.  
  1464.         case IDHELP:
  1465.             WinHelp (hDlg, HELP_FILE, HELP_CONTEXT, hidConfiguration);
  1466.             break;
  1467.       }
  1468.     }
  1469.     break;
  1470.  
  1471.     default:
  1472.         return FALSE;
  1473.   }
  1474.  
  1475.   return TRUE;
  1476. }
  1477.  
  1478.  
  1479. #ifdef DEBUG
  1480. void CDECL SPTrace(LPCSTR pszFormat, ...)
  1481. {
  1482.     static char szBuffer[512];
  1483.     static char fmtBuffer[1024];
  1484.     static char szModuleBuffer[_MAX_PATH];
  1485.     static char szTemp[_MAX_PATH];
  1486.     static char szFName[_MAX_FNAME];
  1487.     const char* pszLocalFormat;
  1488.     
  1489.     int nBuf, count, localCount;
  1490.     va_list args;
  1491.   
  1492.     pszLocalFormat = pszFormat;
  1493.   
  1494.     va_start (args, pszFormat);
  1495.   
  1496.     nBuf = wvsprintf (szBuffer, pszLocalFormat, args);
  1497.   
  1498.     // Convert formatting to readable format.
  1499.     for (count = 0, localCount = 0; count < nBuf; count++, localCount++)
  1500.     {
  1501.         if (szBuffer[count] == '\r')
  1502.         {
  1503.             fmtBuffer[localCount++] = '\\';
  1504.             fmtBuffer[localCount] = 'r';
  1505.         }
  1506.         else if (szBuffer[count] == '\n')
  1507.         {
  1508.             fmtBuffer[localCount++] = '\\';
  1509.             fmtBuffer[localCount] = 'n';
  1510.         }
  1511.         else
  1512.             fmtBuffer[localCount] = szBuffer[count];
  1513.     }
  1514.  
  1515.     fmtBuffer[localCount] = '\0';
  1516.  
  1517.     GetModuleFileName (hInst, szModuleBuffer, sizeof (szModuleBuffer));
  1518.     _splitpath (szModuleBuffer, szTemp, szTemp, szFName, szTemp);
  1519.     wsprintf (szBuffer, "%s: %s\n\r", (LPSTR) szFName, (LPSTR) fmtBuffer);
  1520.   
  1521.     OutputDebugString (szBuffer);
  1522. }
  1523. #endif
  1524.