Microsoft/NT4
Microsoft/NT4
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
ce47f986d8
NT4/private/windows/media/dplay/serial/tapicode.cpp

4897 lines
145 KiB
C++
Raw Normal View History

First commit
2001-01-01 00:00:00 +01:00
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
//
// Copyright (C) 1995 Microsoft Corporation. All Rights Reserved.
//
// MODULE: TapiCode.c
//
// PURPOSE: Handles all the TAPI routines for TapiComm.
//
//
// EXPORTED FUNCTIONS: These functions are for use by other modules.
//
// InitializeTAPI - Initialize this app with TAPI.
// ShutdownTAPI - Shutdown this app from TAPI.
// DialCall - Dial a Call.
// HangupCall - Hangup an existing Call.
// PostHangupCall - Posts a HangupCall message to the main window.
//
// INTERNAL FUNCTIONS: These functions are for this module only.
//
// DialCallInParts - Actually Dial the call.
//
// lineCallbackFunc - TAPI callback for async messages.
//
// CheckAndReAllocBuffer - Helper function for I_ wrappers functions.
//
// I_lineNegotiateAPIVersion - Wrapper for lineNegotiateAPIVersion.
// I_lineGetDevCaps - Wrapper for lineGetDevCaps.
// I_lineGetAddressStatus - Wrapper for lineGetAddressStatus.
// I_lineTranslateAddress - Wrapper for lineTranslateAddress.
// I_lineGetCallStatus - Wrapper for lineGetCallStatus.
// I_lineGetAddressCaps - Wrapper for lineGetAddressCaps.
//
// WaitForCallState - Resynchronize by Waiting for a CallState.
// WaitForReply - Resynchronize by Waiting for a LINE_REPLY.
//
// DoLineReply - Handle asynchronous LINE_REPLY.
// DoLineClose - Handle asynchronous LINE_CLOSE.
// DoLineDevState - Handle asynchronous LINE_LINEDEVSTATE.
// DoLineCallState - Handle asynchronous LINE_CALLSTATE.
// DoLineCreate - Handle asynchronous LINE_CREATE.
//
// HandleLineErr - Handler for most LINEERR errors.
//
// HandleIniFileCorrupt - LINEERR handler for INIFILECORRUPT.
// HandleNoDriver - LINEERR handler for NODRIVER.
// HandleNoDevicesInstalled - LINEERR handler for NODEVICE.
// HandleReInit - LINEERR handler for REINIT.
// HandleNoMultipleInstance - LINEERR handler for NOMULTIPLEINSTANCE.
// HandleNoMem - LINEERR handler for NOMEM.
// HandleOperationFailed - LINEERR handler for OPERATIONFAILED.
// HandleResourceUnavail - LINEERR handler for RESOURCEUNAVAIL.
//
// LaunchModemControlPanelAdd - Launches the Modem Control Panel.
//
// GetAddressToDial - Launches a GetAddressToDial dialog.
// DialDialogProc - Dialog Proc for the GetAddressToDial API.
//
// I_lineNegotiateLegacyAPIVersion - Wrapper to negoitiate with legacy TSPs
// VerifyUsableLine - Verify that a line device is usable
// FillTAPILine - Fill a combobox with TAPI Device names
// VerifyAndWarnUsableLine - Verify and warn if a line device is usable
// FillCountryCodeList - Fill a combobox with country codes
// FillLocationInfo - Fill a combobox with current TAPI locations
// UseDialingRules - Enable/Disable dialing rules controls
// DisplayPhoneNumber - Create and display a valid phone number
// PreConfigureDevice - Preconfigure a device line
#include <tapi.h>
#include <windows.h>
#include <string.h>
#include "globals.h"
#include "TapiInfo.h"
#include "TapiCode.h"
#include "CommCode.h"
#include "resource.h"
// #include "statbar.h"
// #include "toolbar.h"
#include <logit.h>
HANDLE g_hConnectionEvent = NULL;
extern "C" HINSTANCE hInst;
// All TAPI line functions return 0 for SUCCESS, so define it.
#define SUCCESS 0
// Possible return error for resynchronization functions.
#define WAITERR_WAITABORTED 1
#define WAITERR_WAITTIMEDOUT 2
// Reasons why a line device might not be usable by TapiComm.
#define LINENOTUSEABLE_ERROR 1
#define LINENOTUSEABLE_NOVOICE 2
#define LINENOTUSEABLE_NODATAMODEM 3
#define LINENOTUSEABLE_NOMAKECALL 4
#define LINENOTUSEABLE_ALLOCATED 5
#define LINENOTUSEABLE_INUSE 6
#define LINENOTUSEABLE_NOCOMMDATAMODEM 7
// Constant used in WaitForCallState when any new
// callstate message is acceptable.
#define I_LINECALLSTATE_ANY 0
// Wait up to 30 seconds for an async completion.
#define WAITTIMEOUT 30000
// TAPI version that this sample is designed to use.
#define SAMPLE_TAPI_VERSION 0x00010004
// Global TAPI variables.
HWND g_hWndMainWindow = NULL; // Apps main window.
HWND g_hDlgParentWindow = NULL; // This will be the parent of all dialogs.
HLINEAPP g_hLineApp = NULL;
DWORD g_dwNumDevs = 0;
// Global variable that holds the handle to a TAPI dialog
// that needs to be dismissed if line conditions change.
HWND g_hDialog = NULL;
// Global flags to prevent re-entrancy problems.
BOOL g_bShuttingDown = FALSE;
BOOL g_bStoppingCall = FALSE;
BOOL g_bInitializing = FALSE;
// This sample only supports one call in progress at a time.
BOOL g_bTapiInUse = FALSE;
// Data needed per call. This sample only supports one call.
HCALL g_hCall = NULL;
HLINE g_hLine = NULL;
DWORD g_dwDeviceID = 0;
DWORD g_dwAPIVersion = 0;
DWORD g_dwCallState = 0;
char g_szTranslatedNumber[128] = "";
char g_szDisplayableAddress[128] = "";
char g_szDialableAddress[128] = "";
BOOL g_bConnected = FALSE;
LPVOID g_lpDeviceConfig = NULL;
DWORD g_dwSizeDeviceConfig;
// Global variables to allow us to do various waits.
BOOL g_bReplyRecieved;
DWORD g_dwRequestedID;
long g_lAsyncReply;
BOOL g_bCallStateReceived;
// Structures needed to handle special non-dialable characters.
#define g_sizeofNonDialable (sizeof(g_sNonDialable)/sizeof(g_sNonDialable[0]))
typedef struct {
LONG lError;
DWORD dwDevCapFlag;
LPSTR szToken;
LPSTR szMsg;
} NONDIALTOKENS;
NONDIALTOKENS g_sNonDialable[] = {
{LINEERR_DIALBILLING, LINEDEVCAPFLAGS_DIALBILLING, "$",
"Wait for the credit card bong tone" },
{LINEERR_DIALDIALTONE, LINEDEVCAPFLAGS_DIALDIALTONE, "W",
"Wait for the second dial tone" },
{LINEERR_DIALDIALTONE, LINEDEVCAPFLAGS_DIALDIALTONE, "w",
"Wait for the second dial tone" },
{LINEERR_DIALQUIET, LINEDEVCAPFLAGS_DIALQUIET, "@",
"Wait for the remote end to answer" },
{LINEERR_DIALPROMPT, 0, "?",
"Press OK when you are ready to continue dialing"},
};
// "Dial" dialog controls and their associated help page IDs
DWORD g_adwSampleMenuHelpIDs[] =
{
IDC_COUNTRYCODE , IDC_COUNTRYCODE,
IDC_STATICCOUNTRYCODE , IDC_COUNTRYCODE,
IDC_AREACODE , IDC_AREACODE,
IDC_STATICAREACODE , IDC_AREACODE,
IDC_PHONENUMBER , IDC_PHONENUMBER,
IDC_STATICPHONENUMBER , IDC_PHONENUMBER,
IDC_USEDIALINGRULES , IDC_USEDIALINGRULES,
IDC_LOCATION , IDC_LOCATION,
IDC_STATICLOCATION , IDC_LOCATION,
IDC_CALLINGCARD , IDC_CALLINGCARD,
IDC_STATICCALLINGCARD , IDC_CALLINGCARD,
IDC_DIALINGPROPERTIES , IDC_DIALINGPROPERTIES,
IDC_TAPILINE , IDC_TAPILINE,
IDC_STATICTAPILINE , IDC_TAPILINE,
IDC_CONFIGURELINE , IDC_CONFIGURELINE,
IDC_DIAL , IDC_DIAL,
IDC_LINEICON , IDC_LINEICON,
//IDC_STATICWHERETODIAL , IDC_STATICWHERETODIAL,
//IDC_STATICHOWTODIAL , IDC_STATICHOWTODIAL,
//IDC_STATICCONNECTUSING , IDC_STATICCONNECTUSING,
//IDC_STATICPHONENUMBER , IDC_PHONENUMBER,
0,0
};
//**************************************************
// Prototypes for functions used only in this module.
//**************************************************
BOOL DialCallInParts (
LPLINEDEVCAPS lpLineDevCaps,
LPCSTR lpszAddress,
LPCSTR lpszDisplayableAddress);
LPLINECALLPARAMS CreateCallParams (
LPLINECALLPARAMS lpCallParams,
LPCSTR lpszDisplayableAddress);
DWORD I_lineNegotiateAPIVersion (
DWORD dwDeviceID);
LPLINECALLINFO I_lineGetCallInfo(LPLINECALLINFO lpLineCallInfo);
volatile DWORD g_dwRate = 0;
BOOL g_bCallCancel = FALSE;
LPVOID CheckAndReAllocBuffer(
LPVOID lpBuffer, size_t sizeBufferMinimum,
LPTCH szApiPhrase);
LPLINEDEVCAPS I_lineGetDevCaps (
LPLINEDEVCAPS lpLineDevCaps,
DWORD dwDeviceID,
DWORD dwAPIVersion);
LPLINEADDRESSSTATUS I_lineGetAddressStatus (
LPLINEADDRESSSTATUS lpLineAddressStatus,
HLINE hLine,
DWORD dwAddressID);
LPLINETRANSLATEOUTPUT I_lineTranslateAddress (
LPLINETRANSLATEOUTPUT lpLineTranslateOutput,
DWORD dwDeviceID,
DWORD dwAPIVersion,
LPCSTR lpszDialAddress);
LPLINECALLSTATUS I_lineGetCallStatus (
LPLINECALLSTATUS lpLineCallStatus,
HCALL hCall);
LPLINEADDRESSCAPS I_lineGetAddressCaps (
LPLINEADDRESSCAPS lpLineAddressCaps,
DWORD dwDeviceID, DWORD dwAddressID,
DWORD dwAPIVersion, DWORD dwExtVersion);
long WaitForCallState (DWORD dwNewCallState);
long WaitForReply (long lRequestID);
void CALLBACK lineCallbackFunc(
DWORD hDevice, DWORD dwMsg, DWORD dwCallbackInstance,
DWORD dwParam1, DWORD dwParam2, DWORD dwParam3);
void DoLineReply(
DWORD dwDevice, DWORD dwMsg, DWORD dwCallbackInstance,
DWORD dwParam1, DWORD dwParam2, DWORD dwParam3);
void DoLineClose(
DWORD dwDevice, DWORD dwMsg, DWORD dwCallbackInstance,
DWORD dwParam1, DWORD dwParam2, DWORD dwParam3);
void DoLineDevState(
DWORD dwDevice, DWORD dwsg, DWORD dwCallbackInstance,
DWORD dwParam1, DWORD dwParam2, DWORD dwParam3);
void DoLineCallState(
DWORD dwDevice, DWORD dwMsg, DWORD dwCallbackInstance,
DWORD dwParam1, DWORD dwParam2, DWORD dwParam3);
void DoLineCreate(
DWORD dwDevice, DWORD dwMessage, DWORD dwCallbackInstance,
DWORD dwParam1, DWORD dwParam2, DWORD dwParam3);
BOOL HandleLineErr(long lLineErr);
BOOL HandleIniFileCorrupt();
BOOL HandleNoDriver();
BOOL HandleNoDevicesInstalled();
BOOL HandleReInit();
BOOL HandleNoMultipleInstance();
BOOL HandleNoMem();
BOOL HandleOperationFailed();
BOOL HandleResourceUnavail();
BOOL LaunchModemControlPanelAdd();
BOOL CALLBACK DialDialogProc(
HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
BOOL GetAddressToDial();
DWORD I_lineNegotiateLegacyAPIVersion(DWORD dwDeviceID);
long VerifyUsableLine(DWORD dwDeviceID);
void FillTAPILine(HWND hwndDlg);
BOOL VerifyAndWarnUsableLine(HWND hwndDlg);
void FillCountryCodeList(HWND hwndDlg, DWORD dwDefaultCountryID);
void FillLocationInfo(HWND hwndDlg, LPSTR lpszCurrentLocation,
LPDWORD lpdwCountryID, LPSTR lpszAreaCode);
void UseDialingRules(HWND hwndDlg);
void DisplayPhoneNumber(HWND hwndDlg);
void PreConfigureDevice(HWND hwndDlg, DWORD dwDeviceID);
//**************************************************
// Entry points from the UI
//**************************************************
//
// FUNCTION: BOOL InitializeTAPI(HWND)
//
// PURPOSE: Initializes TAPI
//
// PARAMETERS:
// hWndParent - Window to use as parent of any dialogs.
//
// RETURN VALUE:
// Always returns 0 - command handled.
//
// COMMENTS:
//
// This is the API that initializes the app with TAPI.
// If NULL is passed for the hWndParent, then its assumed
// that re-initialization has occurred and the previous hWnd
// is used.
//
//
BOOL InitializeTAPI(HWND hWndParent)
{
long lReturn;
BOOL bTryReInit = TRUE;
// If we're already initialized, then initialization succeeds.
if (g_hLineApp)
return TRUE;
// If we're in the middle of initializing, then fail, we're not done.
if (g_bInitializing)
return FALSE;
g_bInitializing = TRUE;
// Initialize TAPI
do
{
lReturn = lineInitialize(&g_hLineApp, hInst,
lineCallbackFunc, "DPlayComm", &g_dwNumDevs);
// If we get this error, its because some other app has yet
// to respond to the REINIT message. Wait 5 seconds and try
// again. If it still doesn't respond, tell the user.
if (lReturn == LINEERR_REINIT)
{
if (bTryReInit)
{
MSG msg;
DWORD dwTimeStarted;
dwTimeStarted = GetTickCount();
while(GetTickCount() - dwTimeStarted < 5000)
{
if (PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
bTryReInit = FALSE;
continue;
}
else
{
g_bInitializing = FALSE;
return FALSE;
}
}
if (lReturn == LINEERR_NODEVICE)
{
if (HandleNoDevicesInstalled())
continue;
else
{
TSHELL_INFO(TEXT("No devices installed."));
g_bInitializing = FALSE;
return FALSE;
}
}
if (HandleLineErr(lReturn))
continue;
else
{
DBG_INFO((DBGARG, TEXT("lineInitialize unhandled error: %x"), lReturn));
g_bInitializing = FALSE;
return FALSE;
}
}
while(lReturn != SUCCESS);
g_hDlgParentWindow = g_hWndMainWindow = NULL;
g_hCall = NULL;
g_hLine = NULL;
TSHELL_INFO(TEXT("Tapi initialized."));
g_bInitializing = FALSE;
return TRUE;
}
//
// FUNCTION: BOOL ShutdownTAPI()
//
// PURPOSE: Shuts down all use of TAPI
//
// PARAMETERS:
// None
//
// RETURN VALUE:
// True if TAPI successfully shut down.
//
// COMMENTS:
//
// If ShutdownTAPI fails, then its likely either a problem
// with the service provider (and might require a system
// reboot to correct) or the application ran out of memory.
//
//
BOOL ShutdownTAPI()
{
long lReturn;
// If we aren't initialized, then Shutdown is unnecessary.
if (g_hLineApp == NULL)
return TRUE;
// Prevent ShutdownTAPI re-entrancy problems.
if (g_bShuttingDown)
return TRUE;
g_bShuttingDown = TRUE;
HangupCall(__LINE__);
do
{
lReturn = lineShutdown(g_hLineApp);
if (HandleLineErr(lReturn))
continue;
else
{
DBG_INFO((DBGARG, TEXT("lineShutdown unhandled error: %x"), lReturn));
break;
}
}
while(lReturn != SUCCESS);
g_bTapiInUse = FALSE;
g_bConnected = FALSE;
g_hLineApp = NULL;
g_hCall = NULL;
g_hLine = NULL;
g_bShuttingDown = FALSE;
TSHELL_INFO(TEXT("TAPI uninitialized."));
return TRUE;
}
//
// FUNCTION: BOOL HangupCall()
//
// PURPOSE: Hangup the call in progress if it exists.
//
// PARAMETERS:
// none
//
// RETURN VALUE:
// TRUE if call hung up successfully.
//
// COMMENTS:
//
// If HangupCall fails, then its likely either a problem
// with the service provider (and might require a system
// reboot to correct) or the application ran out of memory.
//
//
extern BOOL g_bPostHangup;
BOOL HangupCall(DWORD dwCallLine)
{
DBG_INFO((DBGARG, TEXT("HangupCall was called from %d"), dwCallLine));
if (g_hConnectionEvent)
SetEvent(g_hConnectionEvent);
if (g_bPostHangup)
return(TRUE);
else
return(HangupCallI());
}
BOOL HangupCallI()
{
LPLINECALLSTATUS pLineCallStatus = NULL;
long lReturn;
// Prevent HangupCall re-entrancy problems.
if (g_bStoppingCall)
return TRUE;
// if the 'Call' dialog is up, dismiss it.
if (g_hDialog)
PostMessage(g_hDialog, WM_COMMAND, IDCANCEL, 0);
// If Tapi is not being used right now, then the call is hung up.
if (!g_bTapiInUse)
return TRUE;
g_bStoppingCall = TRUE;
TSHELL_INFO(TEXT("Stopping Call in progress"));
// Stop any data communications on the comm port.
StopComm(g_hConnectionEvent);
// If there is a call in progress, drop and deallocate it.
if (g_hCall)
{
TSHELL_INFO(TEXT("Calling lineGetCallStatus"));
// I_lineGetCallStatus returns a LocalAlloc()d buffer
pLineCallStatus = I_lineGetCallStatus(pLineCallStatus, g_hCall);
if (pLineCallStatus == NULL)
{
ShutdownTAPI();
g_bStoppingCall = FALSE;
return FALSE;
}
// Only drop the call when the line is not IDLE.
if (!((pLineCallStatus -> dwCallState) & LINECALLSTATE_IDLE))
{
TSHELL_INFO(TEXT("Line isn't idle, call lineDrop"));
do
{
lReturn = WaitForReply(lineDrop(g_hCall, NULL, 0));
if (lReturn == WAITERR_WAITTIMEDOUT)
{
TSHELL_INFO(TEXT("Call timed out in WaitForReply."));
break;
}
if (lReturn == WAITERR_WAITABORTED)
{
TSHELL_INFO(TEXT("lineDrop: WAITERR_WAITABORTED."));
break;
}
// Was the call already in IDLE?
if (lReturn == LINEERR_INVALCALLSTATE)
break;
if (HandleLineErr(lReturn))
continue;
else
{
DBG_INFO((DBGARG, TEXT("lineDrop unhandled error: %x"), lReturn));
break;
}
}
while(lReturn != SUCCESS);
// Wait for the dropped call to go IDLE before continuing.
lReturn = WaitForCallState(LINECALLSTATE_IDLE);
#ifdef DEBUG
if (lReturn == WAITERR_WAITTIMEDOUT)
TSHELL_INFO(TEXT("Call timed out waiting for IDLE state."));
if (lReturn == WAITERR_WAITABORTED)
TSHELL_INFO(TEXT("WAITERR_WAITABORTED while waiting for IDLE state."));
#endif
TSHELL_INFO(TEXT("Call Dropped."));
}
// The call is now idle. Deallocate it!
do
{
lReturn = lineDeallocateCall(g_hCall);
if (HandleLineErr(lReturn))
continue;
else
{
DBG_INFO((DBGARG, TEXT("lineDeallocateCall unhandled error: %x"), lReturn));
break;
}
}
while(lReturn != SUCCESS);
TSHELL_INFO(TEXT("Call Deallocated."));
}
else
{
TSHELL_INFO(TEXT("g_hCall is NULL."));
}
// if we have a line open, close it.
if (g_hLine)
{
do
{
lReturn = lineClose(g_hLine);
if (HandleLineErr(lReturn))
continue;
else
{
DBG_INFO((DBGARG, TEXT("lineClose unhandled error: %x"), lReturn));
break;
}
}
while(lReturn != SUCCESS);
TSHELL_INFO(TEXT("Line Closed."));
}
else
{
TSHELL_INFO(TEXT("g_hLine is NULL."));
}
// Call and Line are taken care of. Finish cleaning up.
// If there is device configuration information, free the memory.
if (g_lpDeviceConfig)
LocalFree(g_lpDeviceConfig);
g_lpDeviceConfig = NULL;
g_hCall = NULL;
g_hLine = NULL;
g_bConnected = FALSE;
g_bTapiInUse = FALSE;
g_bStoppingCall = FALSE; // allow HangupCall to be called again.
TSHELL_INFO(TEXT("Call stopped"));
// Need to free LocalAlloc()d buffer returned from I_lineGetCallStatus
if (pLineCallStatus)
LocalFree(pLineCallStatus);
return TRUE;
}
//
// FUNCTION: LONG GetDefaultLine()
//
// PURPOSE: Get Default line device.
//
LONG GetDefaultLine()
{
DWORD dwDeviceID;
DWORD dwAPIVersion;
LPLINEDEVCAPS lpLineDevCaps = NULL;
DWORD dwDefaultDevice = MAXDWORD;
TSHELL_INFO(TEXT("GetDefaultLine"));
for (dwDeviceID = 0; dwDeviceID < g_dwNumDevs
&& dwDefaultDevice == MAXDWORD; dwDeviceID ++)
{
dwAPIVersion = I_lineNegotiateLegacyAPIVersion(dwDeviceID);
if (dwAPIVersion)
{
lpLineDevCaps = I_lineGetDevCaps(lpLineDevCaps,
dwDeviceID, dwAPIVersion);
if (lpLineDevCaps)
{
if ( (lpLineDevCaps->dwMediaModes & LINEMEDIAMODE_DATAMODEM)
&& VerifyUsableLine(dwDeviceID) == SUCCESS)
{
dwDefaultDevice = dwDeviceID;
}
else; // Line isn't valid, unuseable.
}
else; // Couldn't GetDevCaps. Line is unavail.
}
else; // Couldn't NegotiateAPIVersion. Line is unavail.
}
if (lpLineDevCaps)
LocalFree(lpLineDevCaps);
if (dwDefaultDevice == MAXDWORD)
return(-1);
else
return((LONG) dwDefaultDevice);
}
//
// FUNCTION: ReceiveCall()
//
// PURPOSE: Wait for someone to call us.
//
// PARAMETERS:
// none
//
// RETURN VALUE:
// TRUE if able to find a line.
//
// COMMENTS:
//
// This function makes several assumptions:
//
BOOL ReceiveCall()
{
long lReturn;
LPLINEADDRESSSTATUS lpLineAddressStatus = NULL;
LPLINEDEVCAPS lpLineDevCaps = NULL;
TSHELL_INFO(TEXT("Receive Call"));
if (g_bTapiInUse)
{
TSHELL_INFO(TEXT("A call is already being handled"));
return FALSE;
}
// If TAPI isn't initialized, its either because we couldn't initialize
// at startup (and this might have been corrected by now), or because
// a REINIT event was received. In either case, try to init now.
if (!g_hLineApp)
{
if (!InitializeTAPI(NULL))
return FALSE;
}
// If there are no line devices installed on the machine, lets give
// the user the opportunity to install one.
if (g_dwNumDevs < 1)
{
if (!HandleNoDevicesInstalled())
return FALSE;
}
// We now have a call active. Prevent future calls.
g_bTapiInUse = TRUE;
if ((lReturn = GetDefaultLine()) < 0)
return(FALSE);
g_dwDeviceID = (DWORD) lReturn;
// Negotiate the API version to use for this device.
g_dwAPIVersion = I_lineNegotiateAPIVersion(g_dwDeviceID);
if (g_dwAPIVersion == 0)
{
TSHELL_INFO(TEXT("Line Version problem."));
HangupCall(__LINE__);
goto DeleteBuffers;
}
// Open the Line for an incomming DATAMODEM call.
do
{
lReturn = lineOpen(g_hLineApp, g_dwDeviceID, &g_hLine,
g_dwAPIVersion, 0, 0,
LINECALLPRIVILEGE_OWNER, LINEMEDIAMODE_DATAMODEM,
0);
if(lReturn == LINEERR_ALLOCATED)
{
TSHELL_INFO(TEXT("Fatal Error"));
HangupCall(__LINE__);
goto DeleteBuffers;
}
if (HandleLineErr(lReturn))
continue;
else
{
DBG_INFO((DBGARG, TEXT("lineOpen unhandled error: %x"), lReturn));
HangupCall(__LINE__);
goto DeleteBuffers;
}
}
while(lReturn != SUCCESS);
// Tell the service provider that we want all notifications that
// have anything to do with this line.
do
{
// Set the messages we are interested in.
// Note that while most applications aren't really interested
// in dealing with all of the possible messages, its interesting
// to see which come through the callback for testing purposes.
lReturn = lineSetStatusMessages(g_hLine,
LINEDEVSTATE_OTHER |
LINEDEVSTATE_RINGING | // Important state!
LINEDEVSTATE_CONNECTED | // Important state!
LINEDEVSTATE_DISCONNECTED | // Important state!
LINEDEVSTATE_MSGWAITON |
LINEDEVSTATE_MSGWAITOFF |
LINEDEVSTATE_INSERVICE |
LINEDEVSTATE_OUTOFSERVICE | // Important state!
LINEDEVSTATE_MAINTENANCE | // Important state!
LINEDEVSTATE_OPEN |
LINEDEVSTATE_CLOSE |
LINEDEVSTATE_NUMCALLS |
LINEDEVSTATE_NUMCOMPLETIONS |
LINEDEVSTATE_TERMINALS |
LINEDEVSTATE_ROAMMODE |
LINEDEVSTATE_BATTERY |
LINEDEVSTATE_SIGNAL |
LINEDEVSTATE_DEVSPECIFIC |
LINEDEVSTATE_REINIT | // Not allowed to disable this.
LINEDEVSTATE_LOCK |
LINEDEVSTATE_CAPSCHANGE |
LINEDEVSTATE_CONFIGCHANGE |
LINEDEVSTATE_COMPLCANCEL ,
LINEADDRESSSTATE_OTHER |
LINEADDRESSSTATE_DEVSPECIFIC|
LINEADDRESSSTATE_INUSEZERO |
LINEADDRESSSTATE_INUSEONE |
LINEADDRESSSTATE_INUSEMANY |
LINEADDRESSSTATE_NUMCALLS |
LINEADDRESSSTATE_FORWARD |
LINEADDRESSSTATE_TERMINALS |
LINEADDRESSSTATE_CAPSCHANGE);
if (HandleLineErr(lReturn))
continue;
else
{
// If we do get an unhandled problem, we don't care.
// We just won't get notifications.
DBG_INFO((DBGARG, TEXT("lineSetStatusMessages unhandled error: %x"), lReturn));
break;
}
}
while(lReturn != SUCCESS);
return(TRUE);
DeleteBuffers:
if (lpLineAddressStatus)
LocalFree(lpLineAddressStatus);
if (lpLineDevCaps)
LocalFree(lpLineDevCaps);
return g_bTapiInUse;
}
//
// FUNCTION: DialCall(LPSTR lpDisplay, LPSTR lpDialable, DWORD dwDeviceID, HANDLE hEvent)
//
// PURPOSE: Get a number from the user and dial it.
//
// PARAMETERS:
// none
//
// RETURN VALUE:
// TRUE if able to get a number, find a line, and dial successfully.
//
// COMMENTS:
//
// This function makes several assumptions:
// - The number dialed will always explicitly come from the user.
// - There will only be one outgoing address per line.
//
BOOL DialCall(LPSTR lpDisplay, LPSTR lpDialable, LPDWORD pdwDeviceID, HANDLE hEvent)
{
long lReturn;
LPLINEADDRESSSTATUS lpLineAddressStatus = NULL;
LPLINEDEVCAPS lpLineDevCaps = NULL;
g_bCallCancel = FALSE;
if (g_bTapiInUse)
{
TSHELL_INFO(TEXT("A call is already being handled"));
return FALSE;
}
g_hConnectionEvent = hEvent;
// If TAPI isn't initialized, its either because we couldn't initialize
// at startup (and this might have been corrected by now), or because
// a REINIT event was received. In either case, try to init now.
if (!g_hLineApp)
{
if (!InitializeTAPI(NULL))
return FALSE;
}
// If there are no line devices installed on the machine, lets give
// the user the opportunity to install one.
if (g_dwNumDevs < 1)
{
if (!HandleNoDevicesInstalled())
return FALSE;
}
// We now have a call active. Prevent future calls.
g_bTapiInUse = TRUE;
//
// See if we can find the users Window.
//
{
HWND hWndTop;
DWORD dwWindowProcId;
DWORD dwMyProcId;
hWndTop = GetActiveWindow();
dwMyProcId = GetCurrentProcessId();
GetWindowThreadProcessId( hWndTop, &dwWindowProcId);
DBG_INFO((DBGARG, TEXT("My process is %8x and the active window proc is %8x"),
dwMyProcId, dwWindowProcId));
if (dwMyProcId == dwWindowProcId)
g_hDlgParentWindow = hWndTop;
else
{
hWndTop = GetTopWindow(NULL);
GetWindowThreadProcessId( hWndTop, &dwWindowProcId);
if (dwMyProcId == dwWindowProcId)
g_hDlgParentWindow = hWndTop;
DBG_INFO((DBGARG, TEXT("My process is %8x and the top window proc is %8x"),
dwMyProcId, dwWindowProcId));
}
}
if (lpDialable[0])
{
DBG_INFO((DBGARG, TEXT("Dialing with old data (%s)\r\n"), lpDialable));
//
// We were supplied with remembered data. Use that.
//
lstrcpy( g_szDialableAddress, lpDialable);
if ((lReturn = GetDefaultLine()) < 0)
return(FALSE);
g_dwDeviceID = (DWORD) lReturn;
}
else
{
TSHELL_INFO( TEXT("Get number from user"));
// Get a phone number from the user.
// Phone number will be placed in global variables if successful
if (!GetAddressToDial())
{
g_bCallCancel = TRUE;
HangupCall(__LINE__);
TSHELL_INFO(TEXT("User didn't cooperate, bailing out."));
goto DeleteBuffers;
}
lstrcpy( lpDisplay , g_szDisplayableAddress);
lstrcpy( lpDialable, g_szDialableAddress );
*pdwDeviceID = g_dwDeviceID;
}
// Negotiate the API version to use for this device.
g_dwAPIVersion = I_lineNegotiateAPIVersion(g_dwDeviceID);
if (g_dwAPIVersion == 0)
{
HangupCall(__LINE__);
TSHELL_INFO(TEXT("Line Version problem."));
goto DeleteBuffers;
}
// Need to check the DevCaps to make sure this line is usable.
// The 'Dial' dialog checks also, but better safe than sorry.
lpLineDevCaps = I_lineGetDevCaps(lpLineDevCaps,
g_dwDeviceID, g_dwAPIVersion);
if (lpLineDevCaps == NULL)
{
HangupCall(__LINE__);
TSHELL_INFO(TEXT("No useable line."));
goto DeleteBuffers;
}
if (!(lpLineDevCaps->dwBearerModes & LINEBEARERMODE_VOICE ))
{
HangupCall(__LINE__);
goto DeleteBuffers;
}
if (!(lpLineDevCaps->dwMediaModes & LINEMEDIAMODE_DATAMODEM))
{
HangupCall(__LINE__);
TSHELL_INFO(TEXT("No Datamodem capacity."));
goto DeleteBuffers;
}
// Does this line have the capability to make calls?
// It is possible that some lines can't make outbound calls.
if (!(lpLineDevCaps->dwLineFeatures & LINEFEATURE_MAKECALL))
{
HangupCall(__LINE__);
TSHELL_INFO(TEXT("Can't make calls on the device."));
goto DeleteBuffers;
}
// Open the Line for an outgoing DATAMODEM call.
do
{
TSHELL_INFO(TEXT("Opening line for Datamodem service."));
lReturn = lineOpen(g_hLineApp, g_dwDeviceID, &g_hLine,
g_dwAPIVersion, 0, 0,
LINECALLPRIVILEGE_NONE, LINEMEDIAMODE_DATAMODEM,
0);
if(lReturn == LINEERR_ALLOCATED)
{
HangupCall(__LINE__);
TSHELL_INFO(TEXT("Fatal Error"));
goto DeleteBuffers;
}
if (HandleLineErr(lReturn))
continue;
else
{
DBG_INFO((DBGARG, TEXT("lineOpen unhandled error: %x"), lReturn));
HangupCall(__LINE__);
goto DeleteBuffers;
}
}
while(lReturn != SUCCESS);
TSHELL_INFO(TEXT("Line is OPEN."));
// Tell the service provider that we want all notifications that
// have anything to do with this line.
do
{
// Set the messages we are interested in.
// Note that while most applications aren't really interested
// in dealing with all of the possible messages, its interesting
// to see which come through the callback for testing purposes.
lReturn = lineSetStatusMessages(g_hLine,
LINEDEVSTATE_OTHER |
LINEDEVSTATE_RINGING |
LINEDEVSTATE_CONNECTED | // Important state!
LINEDEVSTATE_DISCONNECTED | // Important state!
LINEDEVSTATE_MSGWAITON |
LINEDEVSTATE_MSGWAITOFF |
LINEDEVSTATE_INSERVICE |
LINEDEVSTATE_OUTOFSERVICE | // Important state!
LINEDEVSTATE_MAINTENANCE | // Important state!
LINEDEVSTATE_OPEN |
LINEDEVSTATE_CLOSE |
LINEDEVSTATE_NUMCALLS |
LINEDEVSTATE_NUMCOMPLETIONS |
LINEDEVSTATE_TERMINALS |
LINEDEVSTATE_ROAMMODE |
LINEDEVSTATE_BATTERY |
LINEDEVSTATE_SIGNAL |
LINEDEVSTATE_DEVSPECIFIC |
LINEDEVSTATE_REINIT | // Not allowed to disable this.
LINEDEVSTATE_LOCK |
LINEDEVSTATE_CAPSCHANGE |
LINEDEVSTATE_CONFIGCHANGE |
LINEDEVSTATE_COMPLCANCEL ,
LINEADDRESSSTATE_OTHER |
LINEADDRESSSTATE_DEVSPECIFIC|
LINEADDRESSSTATE_INUSEZERO |
LINEADDRESSSTATE_INUSEONE |
LINEADDRESSSTATE_INUSEMANY |
LINEADDRESSSTATE_NUMCALLS |
LINEADDRESSSTATE_FORWARD |
LINEADDRESSSTATE_TERMINALS |
LINEADDRESSSTATE_CAPSCHANGE);
if (HandleLineErr(lReturn))
continue;
else
{
// If we do get an unhandled problem, we don't care.
// We just won't get notifications.
DBG_INFO((DBGARG, TEXT("lineSetStatusMessages unhandled error: %x"), lReturn));
break;
}
}
while(lReturn != SUCCESS);
// Get LineAddressStatus so we can make sure the line
// isn't already in use by a TAPI application.
lpLineAddressStatus =
I_lineGetAddressStatus(lpLineAddressStatus, g_hLine, 0);
if (lpLineAddressStatus == NULL)
{
TSHELL_INFO(TEXT("Fatal Error"));
HangupCall(__LINE__);
goto DeleteBuffers;
}
// MAKECALL will be set if there are any available call appearances
if ( ! ((lpLineAddressStatus -> dwAddressFeatures) &
LINEADDRFEATURE_MAKECALL) )
{
TSHELL_INFO(TEXT("This line is not available to place a call."));
HangupCall(__LINE__);
goto DeleteBuffers;
}
// If the line was configured in the 'Dial' dialog, then
// we need to actually complete the configuration.
if (g_lpDeviceConfig)
lineSetDevConfig(g_dwDeviceID, g_lpDeviceConfig,
g_dwSizeDeviceConfig, "comm/datamodem");
// Start dialing the number
if (DialCallInParts(lpLineDevCaps, g_szDialableAddress,
g_szDisplayableAddress))
{
TSHELL_INFO(TEXT("DialCallInParts succeeded."));
}
else
{
TSHELL_INFO(TEXT("DialCallInParts failed."));
HangupCall(__LINE__);
goto DeleteBuffers;
}
DeleteBuffers:
if (lpLineAddressStatus)
LocalFree(lpLineAddressStatus);
if (lpLineDevCaps)
LocalFree(lpLineDevCaps);
return g_bTapiInUse;
}
//**************************************************
// These APIs are specific to this module
//**************************************************
//
// FUNCTION: DialCallInParts(LPLINEDEVCAPS, LPCSTR, LPCSTR)
//
// PURPOSE: Dials the call, handling special characters.
//
// PARAMETERS:
// lpLineDevCaps - LINEDEVCAPS for the line to be used.
// lpszAddress - Address to Dial.
// lpszDisplayableAddress - Displayable Address.
//
// RETURN VALUE:
// Returns TRUE if we successfully Dial.
//
// COMMENTS:
//
// This function dials the Address and handles any
// special characters in the address that the service provider
// can't handle. It requires input from the user to handle
// these characters; this can cause problems for fully automated
// dialing.
//
// Note that we can return TRUE, even if we don't reach a
// CONNECTED state. DIalCallInParts returns as soon as the
// Address is fully dialed or when an error occurs.
//
//
#ifdef WINNT
#define Xstrcspn strcspn
#else
//
// Source for strcspn here because it isn't in C10 std lib.
//
static size_t __cdecl Xstrcspn (
const char * string,
const char * control
)
{
const unsigned char *str = (const unsigned char *) string;
const unsigned char *ctrl = (const unsigned char *) control;
unsigned char map[32];
int count;
/* Clear out bit map */
for (count=0; count<32; count++)
map[count] = 0;
/* Set bits in control map */
while (*ctrl)
{
map[*ctrl >> 3] |= (1 << (*ctrl & 7));
ctrl++;
}
/* 1st char in control map stops search */
count=0;
map[0] |= 1; /* null chars not considered */
while (!(map[*str >> 3] & (1 << (*str & 7))))
{
count++;
str++;
}
return(count);
}
#endif
BOOL DialCallInParts(LPLINEDEVCAPS lpLineDevCaps,
LPCSTR lpszAddress, LPCSTR lpszDisplayableAddress)
{
LPLINECALLPARAMS lpCallParams = NULL;
LPLINEADDRESSCAPS lpAddressCaps = NULL;
LPLINECALLSTATUS lpLineCallStatus = NULL;
long lReturn;
int i;
DWORD dwDevCapFlags;
char szFilter[1+sizeof(g_sNonDialable)] = "";
BOOL bFirstDial = TRUE;
// Variables to handle Dialable Substring dialing.
LPSTR lpDS; // This is just so we can free lpszDialableSubstring later.
LPSTR lpszDialableSubstring;
int nAddressLength = 0;
int nCurrentAddress = 0;
char chUnhandledCharacter;
// Get the capabilities for the line device we're going to use.
lpAddressCaps = I_lineGetAddressCaps(lpAddressCaps,
g_dwDeviceID, 0, g_dwAPIVersion, 0);
if (lpAddressCaps == NULL)
return FALSE;
// Setup our CallParams for DATAMODEM settings.
lpCallParams = CreateCallParams (lpCallParams, lpszDisplayableAddress);
if (lpCallParams == NULL)
return FALSE;
// Determine which special characters the service provider
// does *not* handle so we can handle them manually.
// Keep list of unhandled characters in szFilter.
dwDevCapFlags = lpLineDevCaps -> dwDevCapFlags; // SP handled characters.
for (i = 0; i < g_sizeofNonDialable ; i++)
{
if ((dwDevCapFlags & g_sNonDialable[i].dwDevCapFlag) == 0)
{
strcat(szFilter, g_sNonDialable[i].szToken);
}
}
// szFilter now contains the set of tokens which delimit dialable substrings
// Setup the strings for substring dialing.
nAddressLength = strlen(lpszAddress);
lpDS = lpszDialableSubstring = (LPSTR) LocalAlloc(LPTR, nAddressLength + 1);
if (lpszDialableSubstring == NULL)
{
DBG_INFO((DBGARG, TEXT("LocalAlloc failed: %x"), GetLastError()));
HandleNoMem();
goto errExit;
}
// Lets start dialing substrings!
while (nCurrentAddress < nAddressLength)
{
retryAfterError:
// Find the next undialable character
i = Xstrcspn(&lpszAddress[nCurrentAddress], szFilter);
// Was there one before the end of the Address string?
if (i + nCurrentAddress < nAddressLength)
{
// Make sure this device can handle partial dial.
if (! (lpAddressCaps -> dwAddrCapFlags &
LINEADDRCAPFLAGS_PARTIALDIAL))
{
goto errExit;
}
// Remember what the unhandled character is so we can handle it.
chUnhandledCharacter = lpszAddress[nCurrentAddress+i];
// Copy the dialable string to the Substring.
memcpy(lpszDialableSubstring, &lpszAddress[nCurrentAddress], i);
// Terminate the substring with a ';' to signify the partial dial.
lpszDialableSubstring[i] = ';';
lpszDialableSubstring[i+1] = '\0';
// Increment the address for next iteration.
nCurrentAddress += i + 1;
}
else // No more partial dials. Dial the rest of the Address.
{
lpszDialableSubstring = (LPSTR) &lpszAddress[nCurrentAddress];
chUnhandledCharacter = 0;
nCurrentAddress = nAddressLength;
}
do
{
if (bFirstDial)
{
DBG_INFO((DBGARG, TEXT("lineMakeCall %8s %8x"), lpszDialableSubstring, lpCallParams));
lReturn = WaitForReply(
lineMakeCall(g_hLine, &g_hCall, lpszDialableSubstring,
0, lpCallParams) );
}
else
{
DBG_INFO((DBGARG, TEXT("lineDial %8x %8s"), g_hCall, lpszDialableSubstring));
lReturn = WaitForReply(
lineDial(g_hCall, lpszDialableSubstring, 0) );
}
DBG_INFO((DBGARG, TEXT("LineDial return %8x"), lReturn));
switch(lReturn)
{
// We should not have received these errors because of the
// prefiltering strategy, but there may be some ill-behaved
// service providers which do not correctly set their
// devcapflags. Add the character corresponding to the error
// to the filter set and retry dialing.
//
case LINEERR_DIALBILLING:
case LINEERR_DIALDIALTONE:
case LINEERR_DIALQUIET:
case LINEERR_DIALPROMPT:
{
TSHELL_INFO(TEXT("Service Provider incorrectly sets dwDevCapFlags"));
for (i = 0; i < g_sizeofNonDialable; i++)
if (lReturn == g_sNonDialable[i].lError)
{
strcat(szFilter, g_sNonDialable[i].szToken);
}
goto retryAfterError;
}
case WAITERR_WAITABORTED:
TSHELL_INFO(TEXT("While Dialing, WaitForReply aborted."));
goto errExit;
}
if (HandleLineErr(lReturn))
continue;
else
{
#ifdef DEBUG
if (bFirstDial)
DBG_INFO((DBGARG, TEXT("lineMakeCall unhandled error: %x"), lReturn));
else
DBG_INFO((DBGARG, TEXT("lineDial unhandled error: %x"), lReturn));
#endif
TSHELL_INFO(TEXT("Error Exit!"));
goto errExit;
}
}
while (lReturn != SUCCESS);
bFirstDial = FALSE;
// The dial was successful; now handle characters the service
// provider didn't (if any).
if (chUnhandledCharacter)
{
LPSTR lpMsg = "";
// First, wait until we know we can continue dialing. While the
// last string is still pending to be dialed, we can't dial another.
while(TRUE)
{
lpLineCallStatus = I_lineGetCallStatus(lpLineCallStatus, g_hCall);
if (lpLineCallStatus == NULL)
goto errExit;
// Does CallStatus say we can dial now?
if ((lpLineCallStatus->dwCallFeatures) & LINECALLFEATURE_DIAL)
{
TSHELL_INFO(TEXT("Ok to continue dialing."));
break;
}
// We can't dial yet, so wait for a CALLSTATE message
TSHELL_INFO(TEXT("Waiting for dialing to be enabled."));
if (WaitForCallState(I_LINECALLSTATE_ANY) != SUCCESS)
goto errExit;
}
for (i = 0; i < g_sizeofNonDialable; i++)
if (chUnhandledCharacter == g_sNonDialable[i].szToken[0])
lpMsg = g_sNonDialable[i].szMsg;
TCHAR achTitle[MAX_PATH];
LoadString(hInst, IDS_DIALDIALOG, achTitle, MAX_PATH);
MessageBox(g_hDlgParentWindow, lpMsg, achTitle, MB_OK);
}
} // continue dialing until we dial all Dialable Substrings.
LocalFree(lpCallParams);
LocalFree(lpDS);
LocalFree(lpAddressCaps);
if (lpLineCallStatus)
LocalFree(lpLineCallStatus);
return TRUE;
errExit:
// if lineMakeCall has already been successfully called, there's a call in progress.
// let the invoking routine shut down the call.
// if the invoker did not clean up the call, it should be done here.
if (lpLineCallStatus)
LocalFree(lpLineCallStatus);
if (lpDS)
LocalFree(lpDS);
if (lpCallParams)
LocalFree(lpCallParams);
if (lpAddressCaps)
LocalFree(lpAddressCaps);
return FALSE;
}
//
// FUNCTION: CreateCallParams(LPLINECALLPARAMS, LPCSTR)
//
// PURPOSE: Allocates and fills a LINECALLPARAMS structure
//
// PARAMETERS:
// lpCallParams -
// lpszDisplayableAddress -
//
// RETURN VALUE:
// Returns a LPLINECALLPARAMS ready to use for dialing DATAMODEM calls.
// Returns NULL if unable to allocate the structure.
//
// COMMENTS:
//
// If a non-NULL lpCallParams is passed in, it must have been allocated
// with LocalAlloc, and can potentially be freed and reallocated. It must
// also have the dwTotalSize field correctly set.
//
//
LPLINECALLPARAMS CreateCallParams (
LPLINECALLPARAMS lpCallParams, LPCSTR lpszDisplayableAddress)
{
size_t sizeDisplayableAddress;
if (lpszDisplayableAddress == NULL)
lpszDisplayableAddress = "";
sizeDisplayableAddress = strlen(lpszDisplayableAddress) + 1;
lpCallParams = (LPLINECALLPARAMS) CheckAndReAllocBuffer(
(LPVOID) lpCallParams,
sizeof(LINECALLPARAMS) + sizeDisplayableAddress,
TEXT("CreateCallParams: "));
if (lpCallParams == NULL)
return NULL;
// This is where we configure the line for DATAMODEM usage.
lpCallParams -> dwBearerMode = LINEBEARERMODE_VOICE;
lpCallParams -> dwMediaMode = LINEMEDIAMODE_DATAMODEM;
// This specifies that we want to use only IDLE calls and
// don't want to cut into a call that might not be IDLE (ie, in use).
lpCallParams -> dwCallParamFlags = LINECALLPARAMFLAGS_IDLE;
// if there are multiple addresses on line, use first anyway.
// It will take a more complex application than a simple tty app
// to use multiple addresses on a line anyway.
lpCallParams -> dwAddressMode = LINEADDRESSMODE_ADDRESSID;
lpCallParams -> dwAddressID = 0;
// Since we don't know where we originated, leave these blank.
lpCallParams -> dwOrigAddressSize = 0;
lpCallParams -> dwOrigAddressOffset = 0;
// Unimodem ignores these values.
(lpCallParams -> DialParams) . dwDialSpeed = 0;
(lpCallParams -> DialParams) . dwDigitDuration = 0;
(lpCallParams -> DialParams) . dwDialPause = 0;
(lpCallParams -> DialParams) . dwWaitForDialtone = 0;
// Address we are dialing.
lpCallParams -> dwDisplayableAddressOffset = sizeof(LINECALLPARAMS);
lpCallParams -> dwDisplayableAddressSize = sizeDisplayableAddress;
strcpy((LPSTR)lpCallParams + sizeof(LINECALLPARAMS),
lpszDisplayableAddress);
return lpCallParams;
}
//
// FUNCTION: long WaitForReply(long)
//
// PURPOSE: Resynchronize by waiting for a LINE_REPLY
//
// PARAMETERS:
// lRequestID - The asynchronous request ID that we're
// on a LINE_REPLY for.
//
// RETURN VALUE:
// - 0 if LINE_REPLY responded with a success.
// - LINEERR constant if LINE_REPLY responded with a LINEERR
// - 1 if the line was shut down before LINE_REPLY is received.
//
// COMMENTS:
//
// This function allows us to resynchronize an asynchronous
// TAPI line call by waiting for the LINE_REPLY message. It
// waits until a LINE_REPLY is received or the line is shut down.
//
// Note that this could cause re-entrancy problems as
// well as mess with any message preprocessing that might
// occur on this thread (such as TranslateAccelerator).
//
// This function should to be called from the thread that did
// lineInitialize, or the PeekMessage is on the wrong thread
// and the synchronization is not guaranteed to work. Also note
// that if another PeekMessage loop is entered while waiting,
// this could also cause synchronization problems.
//
// One more note. This function can potentially be re-entered
// if the call is dropped for any reason while waiting. If this
// happens, just drop out and assume the wait has been canceled.
// This is signaled by setting bReentered to FALSE when the function
// is entered and TRUE when it is left. If bReentered is ever TRUE
// during the function, then the function was re-entered.
//
// This function times out and returns WAITERR_WAITTIMEDOUT
// after WAITTIMEOUT milliseconds have elapsed.
//
//
long WaitForReply (long lRequestID)
{
static BOOL bReentered;
bReentered = FALSE;
if (lRequestID > SUCCESS)
{
MSG msg;
DWORD dwTimeStarted;
g_bReplyRecieved = FALSE;
g_dwRequestedID = (DWORD) lRequestID;
// Initializing this just in case there is a bug
// that sets g_bReplyRecieved without setting the reply value.
g_lAsyncReply = LINEERR_OPERATIONFAILED;
dwTimeStarted = GetTickCount();
while(!g_bReplyRecieved)
{
if (PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
// This should only occur if the line is shut down while waiting.
if (!g_bTapiInUse || bReentered)
{
bReentered = TRUE;
return WAITERR_WAITABORTED;
}
// Its a really bad idea to timeout a wait for a LINE_REPLY.
// If we are execting a LINE_REPLY, we should wait till we get
// it; it might take a long time to dial (for example).
// If 5 seconds go by without a reply, it might be a good idea
// to display a dialog box to tell the user that a
// wait is in progress and to give the user the capability to
// abort the wait.
}
bReentered = TRUE;
return g_lAsyncReply;
}
bReentered = TRUE;
return lRequestID;
}
//
// FUNCTION: long WaitForCallState(DWORD)
//
// PURPOSE: Wait for the line to reach a specific CallState.
//
// PARAMETERS:
// dwDesiredCallState - specific CallState to wait for.
//
// RETURN VALUE:
// Returns 0 (SUCCESS) when we reach the Desired CallState.
// Returns WAITERR_WAITTIMEDOUT if timed out.
// Returns WAITERR_WAITABORTED if call was closed while waiting.
//
// COMMENTS:
//
// This function allows us to synchronously wait for a line
// to reach a specific LINESTATE or until the line is shut down.
//
// Note that this could cause re-entrancy problems as
// well as mess with any message preprocessing that might
// occur on this thread (such as TranslateAccelerator).
//
// One more note. This function can potentially be re-entered
// if the call is dropped for any reason while waiting. If this
// happens, just drop out and assume the wait has been canceled.
// This is signaled by setting bReentered to FALSE when the function
// is entered and TRUE when it is left. If bReentered is ever TRUE
// during the function, then the function was re-entered.
//
// This function should to be called from the thread that did
// lineInitialize, or the PeekMessage is on the wrong thread
// and the synchronization is not guaranteed to work. Also note
// that if another PeekMessage loop is entered while waiting,
// this could also cause synchronization problems.
//
// If the constant value I_LINECALLSTATE_ANY is used for the
// dwDesiredCallState, then WaitForCallState will return SUCCESS
// upon receiving any CALLSTATE messages.
//
//
//
long WaitForCallState(DWORD dwDesiredCallState)
{
MSG msg;
DWORD dwTimeStarted;
static BOOL bReentered;
bReentered = FALSE;
dwTimeStarted = GetTickCount();
g_bCallStateReceived = FALSE;
while ((dwDesiredCallState == I_LINECALLSTATE_ANY) ||
(g_dwCallState != dwDesiredCallState))
{
if (PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
// If we are waiting for any call state and get one, succeed.
if ((dwDesiredCallState == I_LINECALLSTATE_ANY) &&
g_bCallStateReceived)
{
break;
}
// This should only occur if the line is shut down while waiting.
if (!g_bTapiInUse || bReentered)
{
bReentered = TRUE;
TSHELL_INFO(TEXT("WAITABORTED"));
return WAITERR_WAITABORTED;
}
// If we don't get the reply in a reasonable time, we time out.
if (GetTickCount() - dwTimeStarted > WAITTIMEOUT)
{
bReentered = TRUE;
TSHELL_INFO(TEXT("WAITTIMEDOUT"));
return WAITERR_WAITTIMEDOUT;
}
}
bReentered = TRUE;
return SUCCESS;
}
//**************************************************
// lineCallback Function and Handlers.
//**************************************************
//
// FUNCTION: lineCallbackFunc(..)
//
// PURPOSE: Receive asynchronous TAPI events
//
// PARAMETERS:
// dwDevice - Device associated with the event, if any
// dwMsg - TAPI event that occurred.
// dwCallbackInstance - User defined data supplied when opening the line.
// dwParam1 - dwMsg specific information
// dwParam2 - dwMsg specific information
// dwParam3 - dwMsg specific information
//
// RETURN VALUE:
// none
//
// COMMENTS:
// This is the function where all asynchronous events will come.
// Almost all events will be specific to an open line, but a few
// will be general TAPI events (such as LINE_REINIT).
//
// Its important to note that this callback will *ALWAYS* be
// called in the context of the thread that does the lineInitialize.
// Even if another thread (such as the COMM threads) calls the API
// that would result in the callback being called, it will be called
// in the context of the main thread (since in this sample, the main
// thread does the lineInitialize).
//
//
void CALLBACK lineCallbackFunc(
DWORD dwDevice, DWORD dwMsg, DWORD dwCallbackInstance,
DWORD dwParam1, DWORD dwParam2, DWORD dwParam3)
{
#ifdef DEBUG
OutputDebugLineCallback(
dwDevice, dwMsg, dwCallbackInstance,
dwParam1, dwParam2, dwParam3);
#endif
// All we do is dispatch the dwMsg to the correct handler.
switch(dwMsg)
{
case LINE_CALLSTATE:
DoLineCallState(dwDevice, dwMsg, dwCallbackInstance,
dwParam1, dwParam2, dwParam3);
break;
case LINE_CLOSE:
DoLineClose(dwDevice, dwMsg, dwCallbackInstance,
dwParam1, dwParam2, dwParam3);
break;
case LINE_LINEDEVSTATE:
DoLineDevState(dwDevice, dwMsg, dwCallbackInstance,
dwParam1, dwParam2, dwParam3);
break;
case LINE_REPLY:
DoLineReply(dwDevice, dwMsg, dwCallbackInstance,
dwParam1, dwParam2, dwParam3);
break;
case LINE_CREATE:
DoLineCreate(dwDevice, dwMsg, dwCallbackInstance,
dwParam1, dwParam2, dwParam3);
break;
default:
TSHELL_INFO(TEXT("lineCallbackFunc message ignored"));
break;
}
return;
}
//
// FUNCTION: DoLineReply(..)
//
// PURPOSE: Handle LINE_REPLY asynchronous messages.
//
// PARAMETERS:
// dwDevice - Line Handle associated with this LINE_REPLY.
// dwMsg - Should always be LINE_REPLY.
// dwCallbackInstance - Unused by this sample.
// dwParam1 - Asynchronous request ID.
// dwParam2 - success or LINEERR error value.
// dwParam3 - Unused.
//
// RETURN VALUE:
// none
//
// COMMENTS:
//
// All line API calls that return an asynchronous request ID
// will eventually cause a LINE_REPLY message. Handle it.
//
// This sample assumes only one call at time, and that we wait
// for a LINE_REPLY before making any other line API calls.
//
// The only exception to the above is that we might shut down
// the line before receiving a LINE_REPLY.
//
//
void DoLineReply(
DWORD dwDevice, DWORD dwMessage, DWORD dwCallbackInstance,
DWORD dwParam1, DWORD dwParam2, DWORD dwParam3)
{
#ifdef DEBUG
if ((long) dwParam2 != SUCCESS)
DBG_INFO((DBGARG, TEXT("LINE_REPLY error: %x"), (long) dwParam2));
else
TSHELL_INFO(TEXT("LINE_REPLY: successfully replied."));
#endif
// If we are currently waiting for this async Request ID
// then set the global variables to acknowledge it.
if (g_dwRequestedID == dwParam1)
{
g_bReplyRecieved = TRUE;
g_lAsyncReply = (long) dwParam2;
}
}
//
// FUNCTION: DoLineClose(..)
//
// PURPOSE: Handle LINE_CLOSE asynchronous messages.
//
// PARAMETERS:
// dwDevice - Line Handle that was closed.
// dwMsg - Should always be LINE_CLOSE.
// dwCallbackInstance - Unused by this sample.
// dwParam1 - Unused.
// dwParam2 - Unused.
// dwParam3 - Unused.
//
// RETURN VALUE:
// none
//
// COMMENTS:
//
// This message is sent when something outside our app shuts
// down a line in use.
//
// The hLine (and any hCall on this line) are no longer valid.
//
//
void DoLineClose(
DWORD dwDevice, DWORD dwMessage, DWORD dwCallbackInstance,
DWORD dwParam1, DWORD dwParam2, DWORD dwParam3)
{
// Line has been shut down. Clean up our internal variables.
g_hLine = NULL;
g_hCall = NULL;
HangupCall(__LINE__);
}
//
// FUNCTION: DoLineDevState(..)
//
// PURPOSE: Handle LINE_LINEDEVSTATE asynchronous messages.
//
// PARAMETERS:
// dwDevice - Line Handle that was closed.
// dwMsg - Should always be LINE_LINEDEVSTATE.
// dwCallbackInstance - Unused by this sample.
// dwParam1 - LINEDEVSTATE constant.
// dwParam2 - Depends on dwParam1.
// dwParam3 - Depends on dwParam1.
//
// RETURN VALUE:
// none
//
// COMMENTS:
//
// The LINE_LINEDEVSTATE message is received if the state of the line
// changes. Examples are RINGING, MAINTENANCE, MSGWAITON. Very few of
// these are relevant to this sample.
//
// Assuming that any LINEDEVSTATE that removes the line from use by TAPI
// will also send a LINE_CLOSE message.
//
//
void DoLineDevState(
DWORD dwDevice, DWORD dwMessage, DWORD dwCallbackInstance,
DWORD dwParam1, DWORD dwParam2, DWORD dwParam3)
{
switch(dwParam1)
{
case LINEDEVSTATE_RINGING:
TSHELL_INFO(TEXT("Line Ringing."));
break;
case LINEDEVSTATE_REINIT:
// This is an important case! Usually means that a service provider
// has changed in such a way that requires TAPI to REINIT.
// Note that there are both 'soft' REINITs and 'hard' REINITs.
// Soft REINITs don't actually require a full shutdown but is instead
// just an informational change that historically required a REINIT
// to force the application to deal with. TAPI API Version 1.3 apps
// will still need to do a full REINIT for both hard and soft REINITs.
switch(dwParam2)
{
// This is the hard REINIT. No reason given, just REINIT.
// TAPI is waiting for everyone to shutdown.
// Our response is to immediately shutdown any calls,
// shutdown our use of TAPI and notify the user.
case 0:
ShutdownTAPI();
TSHELL_INFO(TEXT("Tapi line configuration has changed."));
break;
case LINE_CREATE:
TSHELL_INFO(TEXT("Soft REINIT: LINE_CREATE."));
DoLineCreate(dwDevice, dwParam2, dwCallbackInstance,
dwParam3, 0, 0);
break;
case LINE_LINEDEVSTATE:
TSHELL_INFO(TEXT("Soft REINIT: LINE_LINEDEVSTATE."));
DoLineDevState(dwDevice, dwParam2, dwCallbackInstance,
dwParam3, 0, 0);
break;
// There might be other reasons to send a soft reinit.
// No need to to shutdown for these.
default:
TSHELL_INFO(TEXT("Ignoring soft REINIT"));
break;
}
break;
case LINEDEVSTATE_OUTOFSERVICE:
TSHELL_INFO(TEXT("Line selected is now Out of Service."));
HangupCall(__LINE__);
break;
case LINEDEVSTATE_DISCONNECTED:
TSHELL_INFO(TEXT("Line selected is now disconnected."));
HangupCall(__LINE__);
break;
case LINEDEVSTATE_MAINTENANCE:
TSHELL_INFO(TEXT("Line selected is now out for maintenance."));
HangupCall(__LINE__);
break;
case LINEDEVSTATE_TRANSLATECHANGE:
if (g_hDialog)
PostMessage(g_hDialog, WM_COMMAND, IDC_CONFIGURATIONCHANGED, 0);
break;
case LINEDEVSTATE_REMOVED:
TSHELL_INFO(TEXT("A Line device has been removed;")
" no action taken.");
break;
default:
TSHELL_INFO(TEXT("Unhandled LINEDEVSTATE message"));
}
}
//
// FUNCTION: DoLineCreate(..)
//
// PURPOSE: Handle LINE_LINECREATE asynchronous messages.
//
// PARAMETERS:
// dwDevice - Unused.
// dwMsg - Should always be LINE_CREATE.
// dwCallbackInstance - Unused.
// dwParam1 - dwDeviceID of new Line created.
// dwParam2 - Unused.
// dwParam3 - Unused.
//
// RETURN VALUE:
// none
//
// COMMENTS:
//
// This message is new for Windows 95. It is sent when a new line is
// added to the system. This allows us to handle new lines without having
// to REINIT. This allows for much more graceful Plug and Play.
//
// This sample just changes the number of devices available and can use
// it next time a call is made. It also tells the "Dial" dialog.
//
//
void DoLineCreate(
DWORD dwDevice, DWORD dwMessage, DWORD dwCallbackInstance,
DWORD dwParam1, DWORD dwParam2, DWORD dwParam3)
{
// dwParam1 is the Device ID of the new line.
// Add one to get the number of total devices.
if (g_dwNumDevs <= dwParam1)
g_dwNumDevs = dwParam1+1;
if (g_hDialog)
PostMessage(g_hDialog, WM_COMMAND, IDC_LINECREATE, 0);
}
//
// FUNCTION: DoLineCallState(..)
//
// PURPOSE: Handle LINE_CALLSTATE asynchronous messages.
//
// PARAMETERS:
// dwDevice - Handle to Call who's state is changing.
// dwMsg - Should always be LINE_CALLSTATE.
// dwCallbackInstance - Unused by this sample.
// dwParam1 - LINECALLSTATE constant specifying state change.
// dwParam2 - Specific to dwParam1.
// dwParam3 - LINECALLPRIVILEGE change, if any.
//
// RETURN VALUE:
// none
//
// COMMENTS:
//
// This message is received whenever a call changes state. Lots of
// things we do, ranging from notifying the user to closing the line
// to actually connecting to the target of our phone call.
//
// What we do is usually obvious based on the call state change.
//
void DoLineCallState(
DWORD dwDevice, DWORD dwMessage, DWORD dwCallbackInstance,
DWORD dwParam1, DWORD dwParam2, DWORD dwParam3)
{
LONG lErr;
// This sets the global g_dwCallState variable so if we are waiting
// for a specific call state change, we will know when it happens.
g_dwCallState = dwParam1;
g_bCallStateReceived = TRUE;
// dwParam3 contains changes to LINECALLPRIVILEGE, if there are any.
switch (dwParam3)
{
case 0:
break; // no change to call state
// close line if we are made monitor. Shouldn't happen!
case LINECALLPRIVILEGE_MONITOR:
TSHELL_INFO(TEXT("line given monitor privilege; closing"));
HangupCall(__LINE__);
return;
// close line if we are made owner. Shouldn't happen!
case LINECALLPRIVILEGE_OWNER:
TSHELL_INFO(TEXT("line given owner privilege; Ready to Answer"));
break;
default: // Shouldn't happen! All cases handled.
TSHELL_INFO(TEXT("Unknown LINECALLPRIVILEGE message: closing"));
HangupCall(__LINE__);
return;
}
// dwParam1 is the specific CALLSTATE change that is occurring.
switch (dwParam1)
{
case LINECALLSTATE_OFFERING:
TSHELL_INFO(TEXT("Line Offered"));
g_hCall = (HCALL) dwDevice;
lErr = lineAccept(g_hCall, NULL, 0);
#ifdef DEBUG
if (lErr < 0)
TSHELL_INFO(TEXT("lineAccept in Offering failed."));
#endif
lErr = lineAnswer(g_hCall, NULL, 0);
#ifdef DEBUG
if (lErr < 0)
TSHELL_INFO(TEXT("lineAnswer in Offering failed."));
#endif
break;
case LINECALLSTATE_ACCEPTED:
TSHELL_INFO(TEXT("Line Accepted"));
g_hCall = (HCALL) dwDevice;
lErr = lineAnswer(g_hCall, NULL, 0);
#ifdef DEBUG
if (lErr < 0)
TSHELL_INFO(TEXT("lineAnswer in Accepted failed."));
#endif
break;
case LINECALLSTATE_DIALTONE:
TSHELL_INFO(TEXT("Dial Tone"));
break;
case LINECALLSTATE_DIALING:
TSHELL_INFO(TEXT("Dialing"));
break;
case LINECALLSTATE_PROCEEDING:
TSHELL_INFO(TEXT("Proceeding"));
break;
case LINECALLSTATE_RINGBACK:
TSHELL_INFO(TEXT("RingBack"));
break;
case LINECALLSTATE_BUSY:
TSHELL_INFO(TEXT("Line busy, shutting down"));
HangupCall(__LINE__);
if (g_hConnectionEvent)
SetEvent(g_hConnectionEvent);
break;
case LINECALLSTATE_IDLE:
TSHELL_INFO(TEXT("Line idle"));
HangupCall(__LINE__);
if (g_hConnectionEvent)
SetEvent(g_hConnectionEvent);
break;
case LINECALLSTATE_SPECIALINFO:
TSHELL_INFO(
TEXT("Special Info, probably couldn't dial number"));
HangupCall(__LINE__);
if (g_hConnectionEvent)
SetEvent(g_hConnectionEvent);
break;
case LINECALLSTATE_DISCONNECTED:
{
LPTSTR pszReasonDisconnected;
switch (dwParam2)
{
case LINEDISCONNECTMODE_NORMAL:
pszReasonDisconnected = TEXT("Remote Party Disconnected");
break;
case LINEDISCONNECTMODE_UNKNOWN:
pszReasonDisconnected = TEXT("Disconnected: Unknown reason");
break;
case LINEDISCONNECTMODE_REJECT:
pszReasonDisconnected = TEXT("Remote Party rejected call");
break;
case LINEDISCONNECTMODE_PICKUP:
pszReasonDisconnected =
TEXT("Disconnected: Local phone picked up");
break;
case LINEDISCONNECTMODE_FORWARDED:
pszReasonDisconnected = TEXT("Disconnected: Forwarded");
break;
case LINEDISCONNECTMODE_BUSY:
pszReasonDisconnected = TEXT("Disconnected: Busy");
break;
case LINEDISCONNECTMODE_NOANSWER:
pszReasonDisconnected = TEXT("Disconnected: No Answer");
break;
case LINEDISCONNECTMODE_BADADDRESS:
pszReasonDisconnected = TEXT("Disconnected: Bad Address");
break;
case LINEDISCONNECTMODE_UNREACHABLE:
pszReasonDisconnected = TEXT("Disconnected: Unreachable");
break;
case LINEDISCONNECTMODE_CONGESTION:
pszReasonDisconnected = TEXT("Disconnected: Congestion");
break;
case LINEDISCONNECTMODE_INCOMPATIBLE:
pszReasonDisconnected = TEXT("Disconnected: Incompatible");
break;
case LINEDISCONNECTMODE_UNAVAIL:
pszReasonDisconnected = TEXT("Disconnected: Unavail");
break;
case LINEDISCONNECTMODE_NODIALTONE:
pszReasonDisconnected = TEXT("Disconnected: No Dial Tone");
break;
default:
pszReasonDisconnected =
TEXT("Disconnected: LINECALLSTATE; Bad Reason");
break;
}
TSHELL_INFO(pszReasonDisconnected);
PostHangupCall();
if (g_hConnectionEvent)
SetEvent(g_hConnectionEvent);
break;
}
case LINECALLSTATE_CONNECTED: // CONNECTED!!!
{
LPVARSTRING lpVarString = NULL;
DWORD dwSizeofVarString = sizeof(VARSTRING) + 128;
HANDLE hCommFile = NULL;
long lReturn;
// Very first, make sure this isn't a duplicated message.
// A CALLSTATE message can be sent whenever there is a
// change to the capabilities of a line, meaning that it is
// possible to receive multiple CONNECTED messages per call.
// The CONNECTED CALLSTATE message is the only one in TapiComm
// where it would cause problems if it where sent more
// than once.
if (g_bConnected)
break;
g_bConnected = TRUE;
// Get the handle to the comm port from the driver so we can start
// communicating. This is returned in a LPVARSTRING structure.
do
{
// Allocate the VARSTRING structure
lpVarString = (LPVARSTRING) CheckAndReAllocBuffer((LPVOID) lpVarString,
dwSizeofVarString, TEXT("lineGetID: "));
if (lpVarString == NULL)
goto ErrorConnecting;
// Fill the VARSTRING structure
lReturn = lineGetID(0, 0, g_hCall, LINECALLSELECT_CALL,
lpVarString, "comm/datamodem");
if (HandleLineErr(lReturn))
; // Still need to check if structure was big enough.
else
{
DBG_INFO((DBGARG, TEXT("lineGetID unhandled error: %x"), lReturn));
goto ErrorConnecting;
}
// If the VARSTRING wasn't big enough, loop again.
if ((lpVarString -> dwNeededSize) > (lpVarString -> dwTotalSize))
{
dwSizeofVarString = lpVarString -> dwNeededSize;
lReturn = -1; // Lets loop again.
}
}
while(lReturn != SUCCESS);
TSHELL_INFO(TEXT("Connected! Starting communications!"));
// Again, the handle to the comm port is contained in a
// LPVARSTRING structure. Thus, the handle is the very first
// thing after the end of the structure. Note that the name of
// the comm port is right after the handle, but I don't want it.
hCommFile =
*((LPHANDLE)((LPBYTE)lpVarString +
lpVarString -> dwStringOffset));
// Started communications!
LPLINECALLINFO lpCInfo;
lpCInfo = NULL;
lpCInfo = I_lineGetCallInfo(lpCInfo);
if (lpCInfo)
{
g_dwRate = lpCInfo->dwRate;
LocalFree(lpCInfo);
}
if (StartComm(hCommFile, g_hConnectionEvent))
{
LocalFree(lpVarString);
break;
}
// Couldn't start communications. Clean up instead.
ErrorConnecting:
// Its very important that we close all Win32 handles.
// The CommCode module is responsible for closing the hCommFile
// handle if it succeeds in starting communications.
if (hCommFile)
CloseHandle(hCommFile);
HangupCall(__LINE__);
if (lpVarString)
LocalFree(lpVarString);
break;
}
default:
TSHELL_INFO(TEXT("Unhandled LINECALLSTATE message"));
break;
}
}
//**************************************************
// line API Wrapper Functions.
//**************************************************
//
// FUNCTION: LPVOID CheckAndReAllocBuffer(LPVOID, size_t, LPCSTR)
//
// PURPOSE: Checks and ReAllocates a buffer if necessary.
//
// PARAMETERS:
// lpBuffer - Pointer to buffer to be checked. Can be NULL.
// sizeBufferMinimum - Minimum size that lpBuffer should be.
// szApiPhrase - Phrase to print if an error occurs.
//
// RETURN VALUE:
// Returns a pointer to a valid buffer that is guarenteed to be
// at least sizeBufferMinimum size.
// Returns NULL if an error occured.
//
// COMMENTS:
//
// This function is a helper function intended to make all of the
// line API Wrapper Functions much simplier. It allocates (or
// reallocates) a buffer of the requested size.
//
// The returned pointer has been allocated with LocalAlloc,
// so LocalFree has to be called on it when you're finished with it,
// or there will be a memory leak.
//
// Similarly, if a pointer is passed in, it *must* have been allocated
// with LocalAlloc and it could potentially be LocalFree()d.
//
// If lpBuffer == NULL, then a new buffer is allocated. It is
// normal to pass in NULL for this parameter the first time and only
// pass in a pointer if the buffer needs to be reallocated.
//
// szApiPhrase is used only for debugging purposes.
//
// It is assumed that the buffer returned from this function will be used
// to contain a variable sized structure. Thus, the dwTotalSize field
// is always filled in before returning the pointer.
//
//
LPVOID CheckAndReAllocBuffer(
LPVOID lpBuffer, size_t sizeBufferMinimum, LPTCH szApiPhrase)
{
size_t sizeBuffer;
if (lpBuffer == NULL) // Allocate the buffer if necessary.
{
sizeBuffer = sizeBufferMinimum;
lpBuffer = (LPVOID) LocalAlloc(LPTR, sizeBuffer);
if (lpBuffer == NULL)
{
DBG_INFO((DBGARG, TEXT("%s, LocalAlloc : %x"), szApiPhrase, GetLastError()));
HandleNoMem();
return NULL;
}
}
else // If the structure already exists, make sure its good.
{
sizeBuffer = LocalSize((HLOCAL) lpBuffer);
if (sizeBuffer == 0) // Bad pointer?
{
DBG_INFO((DBGARG, TEXT("%s, LocalSize : %x"), szApiPhrase, GetLastError()));
return NULL;
}
// Was the buffer big enough for the structure?
if (sizeBuffer < sizeBufferMinimum)
{
DBG_INFO((DBGARG, TEXT("%s, Reallocating structure"), szApiPhrase));
LocalFree(lpBuffer);
return CheckAndReAllocBuffer(NULL, sizeBufferMinimum, szApiPhrase);
}
// Lets zero the buffer out.
memset(lpBuffer, 0, sizeBuffer);
}
((LPVARSTRING) lpBuffer ) -> dwTotalSize = (DWORD) sizeBuffer;
return lpBuffer;
}
//
// FUNCTION: DWORD I_lineNegotiateAPIVersion(DWORD)
//
// PURPOSE: Negotiate an API Version to use for a specific device.
//
// PARAMETERS:
// dwDeviceID - device to negotiate an API Version for.
//
// RETURN VALUE:
// Returns the API Version to use for this line if successful.
// Returns 0 if negotiations fall through.
//
// COMMENTS:
//
// This wrapper function not only negotiates the API, but handles
// LINEERR errors that can occur while negotiating.
//
//
DWORD I_lineNegotiateAPIVersion(DWORD dwDeviceID)
{
LINEEXTENSIONID LineExtensionID;
long lReturn;
DWORD dwLocalAPIVersion;
do
{
lReturn = lineNegotiateAPIVersion(g_hLineApp, dwDeviceID,
SAMPLE_TAPI_VERSION, SAMPLE_TAPI_VERSION,
&dwLocalAPIVersion, &LineExtensionID);
// DBG_INFO((DBGARG, TEXT("version %8x, %8x, %8x %8x return %8x"),
// SAMPLE_TAPI_VERSION, SAMPLE_TAPI_VERSION,
// dwLocalAPIVersion, LineExtensionID, lReturn));
if (lReturn == LINEERR_INCOMPATIBLEAPIVERSION)
{
TSHELL_INFO(TEXT("lineNegotiateAPIVersion, INCOMPATIBLEAPIVERSION."));
return 0;
}
if (HandleLineErr(lReturn))
continue;
else
{
DBG_INFO((DBGARG, TEXT("lineNegotiateAPIVersion unhandled error: %x"), lReturn));
return 0;
}
}
while(lReturn != SUCCESS);
return dwLocalAPIVersion;
}
//
// FUNCTION: I_lineGetDevCaps(LPLINEDEVCAPS, DWORD , DWORD)
//
// PURPOSE: Retrieve a LINEDEVCAPS structure for the specified line.
//
// PARAMETERS:
// lpLineDevCaps - Pointer to a LINEDEVCAPS structure to use.
// dwDeviceID - device to get the DevCaps for.
// dwAPIVersion - API Version to use while getting DevCaps.
//
// RETURN VALUE:
// Returns a pointer to a LINEDEVCAPS structure if successful.
// Returns NULL if unsuccessful.
//
// COMMENTS:
//
// This function is a wrapper around lineGetDevCaps to make it easy
// to handle the variable sized structure and any errors received.
//
// The returned structure has been allocated with LocalAlloc,
// so LocalFree has to be called on it when you're finished with it,
// or there will be a memory leak.
//
// Similarly, if a lpLineDevCaps structure is passed in, it *must*
// have been allocated with LocalAlloc and it could potentially be
// LocalFree()d.
//
// If lpLineDevCaps == NULL, then a new structure is allocated. It is
// normal to pass in NULL for this parameter unless you want to use a
// lpLineDevCaps that has been returned by a previous I_lineGetDevCaps
// call.
//
//
LPLINECALLINFO I_lineGetCallInfo(LPLINECALLINFO lpLineCallInfo)
{
size_t sizeofLineCallInfo = sizeof(LINECALLINFO) + 128;
long lReturn;
// Continue this loop until the structure is big enough.
while(TRUE)
{
// Make sure the buffer exists, is valid and big enough.
lpLineCallInfo =
(LPLINECALLINFO) CheckAndReAllocBuffer(
(LPVOID) lpLineCallInfo, // Pointer to existing buffer, if any
sizeofLineCallInfo, // Minimum size the buffer should be
TEXT("lineCallInfo")); // Phrase to tag errors, if any.
if (lpLineCallInfo == NULL)
return NULL;
// Make the call to fill the structure.
do
{
lReturn =
lineGetCallInfo(g_hCall, lpLineCallInfo);
if (HandleLineErr(lReturn))
continue;
else
{
DBG_INFO((DBGARG, TEXT("lineGetCallInfo unhandled error: %x"), lReturn));
LocalFree(lpLineCallInfo);
return NULL;
}
}
while (lReturn != SUCCESS);
// If the buffer was big enough, then succeed.
if ((lpLineCallInfo -> dwNeededSize) <= (lpLineCallInfo -> dwTotalSize))
return lpLineCallInfo;
// Buffer wasn't big enough. Make it bigger and try again.
sizeofLineCallInfo = lpLineCallInfo->dwNeededSize;
}
}
LPLINEDEVCAPS I_lineGetDevCaps(
LPLINEDEVCAPS lpLineDevCaps,
DWORD dwDeviceID, DWORD dwAPIVersion)
{
size_t sizeofLineDevCaps = sizeof(LINEDEVCAPS) + 128;
long lReturn;
// Continue this loop until the structure is big enough.
while(TRUE)
{
// Make sure the buffer exists, is valid and big enough.
lpLineDevCaps =
(LPLINEDEVCAPS) CheckAndReAllocBuffer(
(LPVOID) lpLineDevCaps, // Pointer to existing buffer, if any
sizeofLineDevCaps, // Minimum size the buffer should be
TEXT("lineGetDevCaps")); // Phrase to tag errors, if any.
if (lpLineDevCaps == NULL)
return NULL;
// Make the call to fill the structure.
do
{
lReturn =
lineGetDevCaps(g_hLineApp,
dwDeviceID, dwAPIVersion, 0, lpLineDevCaps);
if (HandleLineErr(lReturn))
continue;
else
{
DBG_INFO((DBGARG, TEXT("lineGetDevCaps unhandled error: %x"), lReturn));
LocalFree(lpLineDevCaps);
return NULL;
}
}
while (lReturn != SUCCESS);
// If the buffer was big enough, then succeed.
if ((lpLineDevCaps -> dwNeededSize) <= (lpLineDevCaps -> dwTotalSize))
return lpLineDevCaps;
// Buffer wasn't big enough. Make it bigger and try again.
sizeofLineDevCaps = lpLineDevCaps -> dwNeededSize;
}
}
//
// FUNCTION: I_lineGetAddressStatus(LPLINEADDRESSSTATUS, HLINE, DWORD)
//
// PURPOSE: Retrieve a LINEADDRESSSTATUS structure for the specified line.
//
// PARAMETERS:
// lpLineAddressStatus - Pointer to a LINEADDRESSSTATUS structure to use.
// hLine - Handle of line to get the AddressStatus of.
// dwAddressID - Address ID on the hLine to be used.
//
// RETURN VALUE:
// Returns a pointer to a LINEADDRESSSTATUS structure if successful.
// Returns NULL if unsuccessful.
//
// COMMENTS:
//
// This function is a wrapper around lineGetAddressStatus to make it easy
// to handle the variable sized structure and any errors received.
//
// The returned structure has been allocated with LocalAlloc,
// so LocalFree has to be called on it when you're finished with it,
// or there will be a memory leak.
//
// Similarly, if a lpLineAddressStatus structure is passed in, it *must*
// have been allocated with LocalAlloc and it could potentially be
// LocalFree()d.
//
// If lpLineAddressStatus == NULL, then a new structure is allocated. It
// is normal to pass in NULL for this parameter unless you want to use a
// lpLineAddressStatus that has been returned by previous
// I_lineGetAddressStatus call.
//
//
LPLINEADDRESSSTATUS I_lineGetAddressStatus(
LPLINEADDRESSSTATUS lpLineAddressStatus,
HLINE hLine, DWORD dwAddressID)
{
size_t sizeofLineAddressStatus = sizeof(LINEADDRESSSTATUS) + 128;
long lReturn;
// Continue this loop until the structure is big enough.
while(TRUE)
{
// Make sure the buffer exists, is valid and big enough.
lpLineAddressStatus =
(LPLINEADDRESSSTATUS) CheckAndReAllocBuffer(
(LPVOID) lpLineAddressStatus,
sizeofLineAddressStatus,
TEXT("lineGetAddressStatus"));
if (lpLineAddressStatus == NULL)
return NULL;
// Make the call to fill the structure.
do
{
lReturn =
lineGetAddressStatus(hLine, dwAddressID, lpLineAddressStatus);
if (HandleLineErr(lReturn))
continue;
else
{
DBG_INFO((DBGARG, TEXT("lineGetAddressStatus unhandled error: %x"), lReturn));
LocalFree(lpLineAddressStatus);
return NULL;
}
}
while (lReturn != SUCCESS);
// If the buffer was big enough, then succeed.
if ((lpLineAddressStatus -> dwNeededSize) <=
(lpLineAddressStatus -> dwTotalSize))
{
return lpLineAddressStatus;
}
// Buffer wasn't big enough. Make it bigger and try again.
sizeofLineAddressStatus = lpLineAddressStatus -> dwNeededSize;
}
}
//
// FUNCTION: I_lineGetCallStatus(LPLINECALLSTATUS, HCALL)
//
// PURPOSE: Retrieve a LINECALLSTATUS structure for the specified line.
//
// PARAMETERS:
// lpLineCallStatus - Pointer to a LINECALLSTATUS structure to use.
// hCall - Handle of call to get the CallStatus of.
//
// RETURN VALUE:
// Returns a pointer to a LINECALLSTATUS structure if successful.
// Returns NULL if unsuccessful.
//
// COMMENTS:
//
// This function is a wrapper around lineGetCallStatus to make it easy
// to handle the variable sized structure and any errors received.
//
// The returned structure has been allocated with LocalAlloc,
// so LocalFree has to be called on it when you're finished with it,
// or there will be a memory leak.
//
// Similarly, if a lpLineCallStatus structure is passed in, it *must*
// have been allocated with LocalAlloc and it could potentially be
// LocalFree()d.
//
// If lpLineCallStatus == NULL, then a new structure is allocated. It
// is normal to pass in NULL for this parameter unless you want to use a
// lpLineCallStatus that has been returned by previous I_lineGetCallStatus
// call.
//
//
LPLINECALLSTATUS I_lineGetCallStatus(
LPLINECALLSTATUS lpLineCallStatus,
HCALL hCall)
{
size_t sizeofLineCallStatus = sizeof(LINECALLSTATUS) + 128;
long lReturn;
// Continue this loop until the structure is big enough.
while(TRUE)
{
// Make sure the buffer exists, is valid and big enough.
lpLineCallStatus =
(LPLINECALLSTATUS) CheckAndReAllocBuffer(
(LPVOID) lpLineCallStatus,
sizeofLineCallStatus,
TEXT("lineGetCallStatus"));
if (lpLineCallStatus == NULL)
return NULL;
// Make the call to fill the structure.
do
{
lReturn =
lineGetCallStatus(hCall, lpLineCallStatus);
if (HandleLineErr(lReturn))
continue;
else
{
DBG_INFO((DBGARG, TEXT("lineGetCallStatus unhandled error: %x"), lReturn));
LocalFree(lpLineCallStatus);
return NULL;
}
}
while (lReturn != SUCCESS);
// If the buffer was big enough, then succeed.
if ((lpLineCallStatus -> dwNeededSize) <=
(lpLineCallStatus -> dwTotalSize))
{
return lpLineCallStatus;
}
// Buffer wasn't big enough. Make it bigger and try again.
sizeofLineCallStatus = lpLineCallStatus -> dwNeededSize;
}
}
//
// FUNCTION: I_lineTranslateAddress
// (LPLINETRANSLATEOUTPUT, DWORD, DWORD, LPCSTR)
//
// PURPOSE: Retrieve a LINECALLSTATUS structure for the specified line.
//
// PARAMETERS:
// lpLineTranslateOutput - Pointer to a LINETRANSLATEOUTPUT structure.
// dwDeviceID - Device that we're translating for.
// dwAPIVersion - API Version to use.
// lpszDialAddress - pointer to the DialAddress string to translate.
//
// RETURN VALUE:
// Returns a pointer to a LINETRANSLATEOUTPUT structure if successful.
// Returns NULL if unsuccessful.
//
// COMMENTS:
//
// This function is a wrapper around lineGetTranslateOutput to make it
// easy to handle the variable sized structure and any errors received.
//
// The returned structure has been allocated with LocalAlloc,
// so LocalFree has to be called on it when you're finished with it,
// or there will be a memory leak.
//
// Similarly, if a lpLineTranslateOutput structure is passed in, it
// *must* have been allocated with LocalAlloc and it could potentially be
// LocalFree()d.
//
// If lpLineTranslateOutput == NULL, then a new structure is allocated.
// It is normal to pass in NULL for this parameter unless you want to use
// a lpLineTranslateOutput that has been returned by previous
// I_lineTranslateOutput call.
//
//
LPLINETRANSLATEOUTPUT I_lineTranslateAddress(
LPLINETRANSLATEOUTPUT lpLineTranslateOutput,
DWORD dwDeviceID, DWORD dwAPIVersion,
LPCSTR lpszDialAddress)
{
size_t sizeofLineTranslateOutput = sizeof(LINETRANSLATEOUTPUT) + 128;
long lReturn;
// Continue this loop until the structure is big enough.
while(TRUE)
{
// Make sure the buffer exists, is valid and big enough.
lpLineTranslateOutput =
(LPLINETRANSLATEOUTPUT) CheckAndReAllocBuffer(
(LPVOID) lpLineTranslateOutput,
sizeofLineTranslateOutput,
TEXT("lineTranslateOutput"));
if (lpLineTranslateOutput == NULL)
return NULL;
// Make the call to fill the structure.
do
{
// Note that CALLWAITING is disabled
// (assuming the service provider can disable it)
lReturn =
lineTranslateAddress(g_hLineApp, dwDeviceID, dwAPIVersion,
lpszDialAddress, 0,
LINETRANSLATEOPTION_CANCELCALLWAITING,
lpLineTranslateOutput);
// If the address isn't translatable, notify the user.
if (lReturn == LINEERR_INVALADDRESS)
{
TCHAR achTitle[MAX_PATH];
TCHAR achMsg[MAX_PATH];
LoadString(hInst, IDS_WARNING, achTitle, MAX_PATH);
LoadString(hInst, IDS_BADTRANSLATE, achMsg, MAX_PATH);
MessageBox(g_hDlgParentWindow, achMsg, achTitle, MB_OK);
}
if (HandleLineErr(lReturn))
continue;
else
{
DBG_INFO((DBGARG, TEXT("lineTranslateOutput unhandled error: %x"), lReturn));
LocalFree(lpLineTranslateOutput);
return NULL;
}
}
while (lReturn != SUCCESS);
// If the buffer was big enough, then succeed.
if ((lpLineTranslateOutput -> dwNeededSize) <=
(lpLineTranslateOutput -> dwTotalSize))
{
return lpLineTranslateOutput;
}
// Buffer wasn't big enough. Make it bigger and try again.
sizeofLineTranslateOutput = lpLineTranslateOutput -> dwNeededSize;
}
}
//
// FUNCTION: I_lineGetAddressCaps(LPLINEADDRESSCAPS, ..)
//
// PURPOSE: Retrieve a LINEADDRESSCAPS structure for the specified line.
//
// PARAMETERS:
// lpLineAddressCaps - Pointer to a LINEADDRESSCAPS, or NULL.
// dwDeviceID - Device to get the address caps for.
// dwAddressID - This sample always assumes the first address.
// dwAPIVersion - API version negotiated for the device.
// dwExtVersion - Always 0 for this sample.
//
// RETURN VALUE:
// Returns a pointer to a LINEADDRESSCAPS structure if successful.
// Returns NULL if unsuccessful.
//
// COMMENTS:
//
// This function is a wrapper around lineGetAddressCaps to make it easy
// to handle the variable sized structure and any errors received.
//
// The returned structure has been allocated with LocalAlloc,
// so LocalFree has to be called on it when you're finished with it,
// or there will be a memory leak.
//
// Similarly, if a lpLineAddressCaps structure is passed in, it *must*
// have been allocated with LocalAlloc and it could potentially be
// LocalFree()d. It also *must* have the dwTotalSize field set.
//
// If lpLineAddressCaps == NULL, then a new structure is allocated. It
// is normal to pass in NULL for this parameter unless you want to use a
// lpLineCallStatus that has been returned by previous I_lineGetAddressCaps
// call.
//
//
LPLINEADDRESSCAPS I_lineGetAddressCaps (
LPLINEADDRESSCAPS lpLineAddressCaps,
DWORD dwDeviceID, DWORD dwAddressID,
DWORD dwAPIVersion, DWORD dwExtVersion)
{
size_t sizeofLineAddressCaps = sizeof(LINEADDRESSCAPS) + 128;
long lReturn;
// Continue this loop until the structure is big enough.
while(TRUE)
{
// Make sure the buffer exists, is valid and big enough.
lpLineAddressCaps =
(LPLINEADDRESSCAPS) CheckAndReAllocBuffer(
(LPVOID) lpLineAddressCaps,
sizeofLineAddressCaps,
TEXT("lineGetAddressCaps"));
if (lpLineAddressCaps == NULL)
return NULL;
// Make the call to fill the structure.
do
{
lReturn =
lineGetAddressCaps(g_hLineApp,
dwDeviceID, dwAddressID, dwAPIVersion, dwExtVersion,
lpLineAddressCaps);
if (HandleLineErr(lReturn))
continue;
else
{
DBG_INFO((DBGARG, TEXT("lineGetAddressCaps unhandled error: %x"), lReturn));
LocalFree(lpLineAddressCaps);
return NULL;
}
}
while (lReturn != SUCCESS);
// If the buffer was big enough, then succeed.
if ((lpLineAddressCaps -> dwNeededSize) <=
(lpLineAddressCaps -> dwTotalSize))
{
return lpLineAddressCaps;
}
// Buffer wasn't big enough. Make it bigger and try again.
sizeofLineAddressCaps = lpLineAddressCaps -> dwNeededSize;
}
}
//**************************************************
// LINEERR Error Handlers
//**************************************************
//
// FUNCTION: HandleLineErr(long)
//
// PURPOSE: Handle several standard LINEERR errors
//
// PARAMETERS:
// lLineErr - Error code to be handled.
//
// RETURN VALUE:
// Return TRUE if lLineErr wasn't an error, or if the
// error was successfully handled and cleared up.
// Return FALSE if lLineErr was an unhandled error.
//
// COMMENTS:
//
// This is the main error handler for all TAPI line APIs.
// It handles (by correcting or just notifying the user)
// most of the errors that can occur while using TAPI line APIs.
//
// Note that many errors still return FALSE (unhandled) even
// if a dialog is displayed. Often, the dialog is just notifying
// the user why the action was canceled.
//
//
//
BOOL HandleLineErr(long lLineErr)
{
// lLineErr is really an async request ID, not an error.
if (lLineErr > SUCCESS)
return FALSE;
// All we do is dispatch the correct error handler.
switch(lLineErr)
{
case SUCCESS:
return TRUE;
case LINEERR_INVALCARD:
case LINEERR_INVALLOCATION:
case LINEERR_INIFILECORRUPT:
return HandleIniFileCorrupt();
case LINEERR_NODRIVER:
return HandleNoDriver();
case LINEERR_REINIT:
return HandleReInit();
case LINEERR_NOMULTIPLEINSTANCE:
return HandleNoMultipleInstance();
case LINEERR_NOMEM:
return HandleNoMem();
case LINEERR_OPERATIONFAILED:
return HandleOperationFailed();
case LINEERR_RESOURCEUNAVAIL:
return HandleResourceUnavail();
// Unhandled errors fail.
default:
return FALSE;
}
}
//
// FUNCTION: HandleIniFileCorrupt
//
// PURPOSE: Handle INIFILECORRUPT error.
//
// PARAMETERS:
// none
//
// RETURN VALUE:
// TRUE - error was corrected.
// FALSE - error was not corrected.
//
// COMMENTS:
//
// This error shouldn't happen under Windows 95 anymore. The TAPI.DLL
// takes care of correcting this problem. If it does happen, just
// notify the user.
//
BOOL HandleIniFileCorrupt()
{
lineTranslateDialog(g_hLineApp, 0, SAMPLE_TAPI_VERSION,
g_hDlgParentWindow, NULL);
return TRUE;
}
//
// FUNCTION: HandleNoDriver
//
// PURPOSE: Handle NODRIVER error.
//
// PARAMETERS:
// none
//
// RETURN VALUE:
// TRUE - error was corrected.
// FALSE - error was not corrected.
//
// COMMENTS:
//
//
BOOL HandleNoDriver()
{
return FALSE;
}
//
// FUNCTION: HandleNoMultipleInstance
//
// PURPOSE: Handle NOMULTIPLEINSTANCE error.
//
// PARAMETERS:
// none
//
// RETURN VALUE:
// TRUE - error was corrected.
// FALSE - error was not corrected.
//
// COMMENTS:
//
//
BOOL HandleNoMultipleInstance()
{
return FALSE;
}
//
// FUNCTION: HandleReInit
//
// PURPOSE: Handle REINIT error.
//
// PARAMETERS:
// none
//
// RETURN VALUE:
// TRUE - error was corrected.
// FALSE - error was not corrected.
//
// COMMENTS:
//
//
BOOL HandleReInit()
{
ShutdownTAPI();
return FALSE;
}
//
// FUNCTION: HandleNoMem
//
// PURPOSE: Handle NOMEM error.
//
// PARAMETERS:
// none
//
// RETURN VALUE:
// TRUE - error was corrected.
// FALSE - error was not corrected.
//
// COMMENTS:
// This is also called if I run out of memory for LocalAlloc()s
//
//
BOOL HandleNoMem()
{
return FALSE;
}
//
// FUNCTION: HandleOperationFailed
//
// PURPOSE: Handle OPERATIONFAILED error.
//
// PARAMETERS:
// none
//
// RETURN VALUE:
// TRUE - error was corrected.
// FALSE - error was not corrected.
//
// COMMENTS:
//
//
BOOL HandleOperationFailed()
{
TSHELL_INFO(TEXT("TAPI Operation Failed for unknown reasons."));
return FALSE;
}
//
// FUNCTION: HandleResourceUnavail
//
// PURPOSE: Handle RESOURCEUNAVAIL error.
//
// PARAMETERS:
// none
//
// RETURN VALUE:
// TRUE - error was corrected.
// FALSE - error was not corrected.
//
// COMMENTS:
//
//
BOOL HandleResourceUnavail()
{
return FALSE;
}
//
// FUNCTION: HandleNoDevicesInstalled
//
// PURPOSE: Handle cases when we know NODEVICE error
// is returned because there are no devices installed.
//
// PARAMETERS:
// none
//
// RETURN VALUE:
// TRUE - error was corrected.
// FALSE - error was not corrected.
//
// COMMENTS:
//
// This function is not part of standard error handling
// but is only used when we know that the NODEVICE error
// means that no devices are installed.
//
//
BOOL HandleNoDevicesInstalled()
{
if (LaunchModemControlPanelAdd())
return TRUE;
return FALSE;
}
//
// FUNCTION: LaunchModemControlPanelAdd
//
// PURPOSE: Launch Add Modem Control Panel applet.
//
// PARAMETERS:
// none
//
// RETURN VALUE:
// TRUE - Control Panel launched successfully.
// FALSE - It didn't.
//
// COMMENTS:
//
//
BOOL LaunchModemControlPanelAdd()
{
PROCESS_INFORMATION piProcInfo;
STARTUPINFO siStartupInfo;
siStartupInfo.cb = sizeof(STARTUPINFO);
siStartupInfo.lpReserved = NULL;
siStartupInfo.lpDesktop = NULL;
siStartupInfo.lpTitle = NULL;
siStartupInfo.dwFlags = STARTF_USESHOWWINDOW;
siStartupInfo.wShowWindow = SW_SHOWNORMAL;
siStartupInfo.cbReserved2 = 0;
siStartupInfo.lpReserved2 = NULL;
// The string to launch the modem control panel is *VERY* likely
// to change on NT. If nothing else, this is 'contrl32' on NT
// instead of 'control'.
if (CreateProcess(
NULL,
"CONTROL.EXE MODEM.CPL,,ADD",
NULL, NULL, FALSE,
NORMAL_PRIORITY_CLASS,
NULL, NULL,
&siStartupInfo,
&piProcInfo))
{
CloseHandle(piProcInfo.hThread);
// Control panel 'Add New Modem' has been launched. Now we should
// wait for it to go away before continueing.
// If we WaitForSingleObject for the control panel to exit, then we
// get into a deadlock situation if we need to respond to any messages
// from the control panel.
// If we use a PeekMessage loop to wait, we run into
// message re-entrancy problems. (The user can get back to our UI
// and click 'dial' again).
// Instead, we take the easy way out and return FALSE to abort
// the current operation.
CloseHandle(piProcInfo.hProcess);
}
else
{
DBG_INFO((DBGARG, TEXT("Unable to LaunchModemControlPanelAdd: %x"), GetLastError()));
}
return FALSE;
}
//**************************************************
//
// All the functions from this point on are used solely by the "Dial" dialog.
// This dialog is used to get both the 'phone number' address,
// the line device to be used as well as allow the user to configure
// dialing properties and the line device.
//
//**************************************************
//
// FUNCTION: DWORD I_lineNegotiateLegacyAPIVersion(DWORD)
//
// PURPOSE: Negotiate an API Version to use for a specific device.
//
// PARAMETERS:
// dwDeviceID - device to negotiate an API Version for.
//
// RETURN VALUE:
// Returns the API Version to use for this line if successful.
// Returns 0 if negotiations fall through.
//
// COMMENTS:
//
// This wrapper is slightly different from the I_lineNegotiateAPIVersion.
// This wrapper allows TapiComm to negotiate an API version between
// 1.3 and SAMPLE_TAPI_VERSION. Normally, this sample is specific to
// API Version SAMPLE_TAPI_VERSION. However, there are a few times when
// TapiComm needs to get information from a service provider, but also knows
// that a lower API Version would be ok. This allows TapiComm to recognize
// legacy service providers even though it can't use them. 1.3 is the
// lowest API Version a legacy service provider should support.
//
//
DWORD I_lineNegotiateLegacyAPIVersion(DWORD dwDeviceID)
{
LINEEXTENSIONID LineExtensionID;
long lReturn;
DWORD dwLocalAPIVersion;
do
{
lReturn = lineNegotiateAPIVersion(g_hLineApp, dwDeviceID,
0x00010003, SAMPLE_TAPI_VERSION,
&dwLocalAPIVersion, &LineExtensionID);
if (lReturn == LINEERR_INCOMPATIBLEAPIVERSION)
{
TSHELL_INFO(TEXT("INCOMPATIBLEAPIVERSION in Dial Dialog."));
return 0;
}
if (HandleLineErr(lReturn))
continue;
else
{
DBG_INFO((DBGARG, TEXT("lineNegotiateAPIVersion in Dial Dialog unhandled error: %x"), lReturn));
return 0;
}
}
while(lReturn != SUCCESS);
return dwLocalAPIVersion;
}
//
// FUNCTION: long VerifyUsableLine(DWORD)
//
// PURPOSE: Verifies that a specific line device is useable by TapiComm.
//
// PARAMETERS:
// dwDeviceID - The ID of the line device to be verified
//
// RETURN VALUE:
// Returns SUCCESS if dwDeviceID is a usable line device.
// Returns a LINENOTUSEABLE_ constant otherwise.
//
// COMMENTS:
//
// VerifyUsableLine takes the give device ID and verifies step by step
// that the device supports all the features that TapiComm requires.
//
//
long VerifyUsableLine(DWORD dwDeviceID)
{
LPLINEDEVCAPS lpLineDevCaps = NULL;
LPLINEADDRESSSTATUS lpLineAddressStatus = NULL;
LPVARSTRING lpVarString = NULL;
DWORD dwAPIVersion;
long lReturn;
long lUsableLine = SUCCESS;
HLINE hLine = 0;
DBG_INFO((DBGARG, TEXT("Testing Line ID '0x%lx'"),dwDeviceID));
// The line device must support an API Version that TapiComm does.
dwAPIVersion = I_lineNegotiateAPIVersion(dwDeviceID);
if (dwAPIVersion == 0)
return LINENOTUSEABLE_ERROR;
lpLineDevCaps = I_lineGetDevCaps(lpLineDevCaps,
dwDeviceID, dwAPIVersion);
if (lpLineDevCaps == NULL)
return LINENOTUSEABLE_ERROR;
// Must support LINEBEARERMODE_VOICE
if (!(lpLineDevCaps->dwBearerModes & LINEBEARERMODE_VOICE ))
{
lUsableLine = LINENOTUSEABLE_NOVOICE;
TSHELL_INFO(TEXT("LINEBEARERMODE_VOICE not supported"));
goto DeleteBuffers;
}
// Must support LINEMEDIAMODE_DATAMODEM
if (!(lpLineDevCaps->dwMediaModes & LINEMEDIAMODE_DATAMODEM))
{
lUsableLine = LINENOTUSEABLE_NODATAMODEM;
TSHELL_INFO(TEXT("LINEMEDIAMODE_DATAMODEM not supported"));
goto DeleteBuffers;
}
// Must be able to make calls
if (!(lpLineDevCaps->dwLineFeatures & LINEFEATURE_MAKECALL))
{
lUsableLine = LINENOTUSEABLE_NOMAKECALL;
TSHELL_INFO(TEXT("LINEFEATURE_MAKECALL not supported"));
goto DeleteBuffers;
}
// It is necessary to open the line so we can check if
// there are any call appearances available. Other TAPI
// applications could be using all call appearances.
// Opening the line also checks for other possible problems.
do
{
lReturn = lineOpen(g_hLineApp, dwDeviceID, &hLine,
dwAPIVersion, 0, 0,
LINECALLPRIVILEGE_NONE, LINEMEDIAMODE_DATAMODEM,
0);
if(lReturn == LINEERR_ALLOCATED)
{
TSHELL_INFO(TEXT("Line is already in use by a non-TAPI app or another Service Provider."));
lUsableLine = LINENOTUSEABLE_ALLOCATED;
goto DeleteBuffers;
}
if (HandleLineErr(lReturn))
continue;
else
{
DBG_INFO((DBGARG, TEXT("lineOpen unhandled error: %x"), lReturn));
lUsableLine = LINENOTUSEABLE_ERROR;
goto DeleteBuffers;
}
}
while(lReturn != SUCCESS);
// Get LineAddressStatus to make sure the line isn't already in use.
lpLineAddressStatus =
I_lineGetAddressStatus(lpLineAddressStatus, hLine, 0);
if (lpLineAddressStatus == NULL)
{
lUsableLine = LINENOTUSEABLE_ERROR;
goto DeleteBuffers;
}
// Are there any available call appearances (ie: is it in use)?
if ( !((lpLineAddressStatus -> dwAddressFeatures) &
LINEADDRFEATURE_MAKECALL) )
{
TSHELL_INFO(TEXT("LINEADDRFEATURE_MAKECALL not available"));
lUsableLine = LINENOTUSEABLE_INUSE;
goto DeleteBuffers;
}
// Make sure the "comm/datamodem" device class is supported
// Note that we don't want any of the 'extra' information
// normally returned in the VARSTRING structure. All we care
// about is if lineGetID succeeds.
do
{
lpVarString = (LPVARSTRING) CheckAndReAllocBuffer((LPVOID) lpVarString,
sizeof(VARSTRING),TEXT("VerifyUsableLine:lineGetID: "));
if (lpVarString == NULL)
{
lUsableLine = LINENOTUSEABLE_ERROR;
goto DeleteBuffers;
}
lReturn = lineGetID(hLine, 0, 0, LINECALLSELECT_LINE,
lpVarString, "comm/datamodem");
if (HandleLineErr(lReturn))
continue;
else
{
DBG_INFO((DBGARG, TEXT("lineGetID unhandled error: %x"), lReturn));
lUsableLine = LINENOTUSEABLE_NOCOMMDATAMODEM;
goto DeleteBuffers;
}
}
while(lReturn != SUCCESS);
TSHELL_INFO(TEXT("Line is suitable and available for use."));
DeleteBuffers:
if (hLine)
lineClose(hLine);
if (lpLineAddressStatus)
LocalFree(lpLineAddressStatus);
if (lpLineDevCaps)
LocalFree(lpLineDevCaps);
if (lpVarString)
LocalFree(lpVarString);
hLine = NULL;
lpLineAddressStatus = NULL;
lpLineDevCaps = NULL;
lpVarString = NULL;
return lUsableLine;
}
//
// FUNCTION: void FillTAPILine(HWND)
//
// PURPOSE: Fills the 'TAPI Line' control with the available line devices.
//
// PARAMETERS:
// hwndDlg - handle to the current "Dial" dialog
//
// RETURN VALUE:
// none
//
// COMMENTS:
//
// This function enumerates through all the TAPI line devices and
// queries each for the device name. The device name is then put into
// the 'TAPI Line' control. These device names are kept in order rather
// than sorted. This allows "Dial" to know which device ID the user
// selected just by the knowing the index of the selected string.
//
// There are default values if there isn't a device name, if there is
// an error on the device, or if the device name is an empty string.
// The device name is also checked to make sure it is null terminated.
//
// Note that a Legacy API Version is negotiated. Since the fields in
// the LINEDEVCAPS structure that we are interested in haven't moved, we
// can negotiate a lower API Version than this sample is designed for
// and still be able to access the necessary structure members.
//
// The first line that is usable by TapiComm is selected as the 'default'
// line. Also note that if there was a previously selected line, this
// remains the default line. This would likely only occur if this
// function is called after the dialog has initialized once; for example,
// if a new line is added.
//
//
void FillTAPILine(HWND hwndDlg)
{
DWORD dwDeviceID;
DWORD dwAPIVersion;
LPLINEDEVCAPS lpLineDevCaps = NULL;
char szLineUnavail[] = "Line Unavailable";
char szLineUnnamed[] = "Line Unnamed";
char szLineNameEmpty[] = "Line Name is Empty";
LPSTR lpszLineName;
long lReturn;
DWORD dwDefaultDevice = MAXDWORD;
// Make sure the control is empty. If it isn't,
// hold onto the currently selected ID and then reset it.
if (SendDlgItemMessage(hwndDlg, IDC_TAPILINE, CB_GETCOUNT, 0, 0))
{
dwDefaultDevice = SendDlgItemMessage(hwndDlg, IDC_TAPILINE,
CB_GETCURSEL, 0, 0);
SendDlgItemMessage(hwndDlg, IDC_TAPILINE, CB_RESETCONTENT, 0, 0);
}
for (dwDeviceID = 0; dwDeviceID < g_dwNumDevs; dwDeviceID ++)
{
dwAPIVersion = I_lineNegotiateLegacyAPIVersion(dwDeviceID);
if (dwAPIVersion)
{
lpLineDevCaps = I_lineGetDevCaps(lpLineDevCaps,
dwDeviceID, dwAPIVersion);
if (lpLineDevCaps)
{
if ((lpLineDevCaps -> dwLineNameSize) &&
(lpLineDevCaps -> dwLineNameOffset) &&
(lpLineDevCaps -> dwStringFormat == STRINGFORMAT_ASCII))
{
// This is the name of the device.
lpszLineName = ((char *) lpLineDevCaps) +
lpLineDevCaps -> dwLineNameOffset;
if (lpszLineName[0] != '\0')
{
// Reverse indented to make this fit
// Make sure the device name is null terminated.
if (lpszLineName[lpLineDevCaps->dwLineNameSize -1] != '\0')
{
// If the device name is not null terminated, null
// terminate it. Yes, this looses the end character.
// Its a bug in the service provider.
lpszLineName[lpLineDevCaps->dwLineNameSize-1] = '\0';
DBG_INFO((DBGARG, TEXT("Device name for device 0x%lx is not null terminated."),
dwDeviceID));
}
}
else // Line name started with a NULL.
lpszLineName = szLineNameEmpty;
}
else // DevCaps doesn't have a valid line name. Unnamed.
lpszLineName = szLineUnnamed;
}
else // Couldn't GetDevCaps. Line is unavail.
lpszLineName = szLineUnavail;
}
else // Couldn't NegotiateAPIVersion. Line is unavail.
lpszLineName = szLineUnavail;
// Put the device name into the control
lReturn = SendDlgItemMessage(hwndDlg, IDC_TAPILINE,
CB_ADDSTRING, 0, (LPARAM) (LPCTSTR) lpszLineName);
// If this line is usable and we don't have a default initial
// line yet, make this the initial line.
if ((lpszLineName != szLineUnavail) &&
(dwDefaultDevice == MAXDWORD) &&
(VerifyUsableLine(dwDeviceID) == SUCCESS))
{
dwDefaultDevice = dwDeviceID;
}
}
if (lpLineDevCaps)
LocalFree(lpLineDevCaps);
if (dwDefaultDevice == MAXDWORD)
dwDefaultDevice = 0;
// Set the initial default line
SendDlgItemMessage(hwndDlg, IDC_TAPILINE,
CB_SETCURSEL, dwDefaultDevice, 0);
}
//
// FUNCTION: BOOL VerifyAndWarnUsableLine(HWND)
//
// PURPOSE: Verifies the line device selected by the user.
//
// PARAMETERS:
// hwndDlg - The handle to the current "Dial" dialog.
//
// RETURN VALUE:
// Returns TRUE if the currently selected line device is useable
// by TapiComm. Returns FALSE if it isn't.
//
// COMMENTS:
//
// This function is very specific to the "Dial" dialog. It gets
// the device selected by the user from the 'TAPI Line' control and
// VerifyUsableLine to make sure this line device is usable. If the
// line isn't useable, it notifies the user and disables the 'Dial'
// button so that the user can't initiate a call with this line.
//
// This function is also responsible for filling in the line specific
// icon found on the "Dial" dialog.
//
//
BOOL VerifyAndWarnUsableLine(HWND hwndDlg)
{
DWORD dwDeviceID;
long lReturn;
HICON hIcon = 0;
HWND hControlWnd;
// Get the selected line device.
dwDeviceID = SendDlgItemMessage(hwndDlg, IDC_TAPILINE,
CB_GETCURSEL, 0, 0);
// Get the "comm" device icon associated with this line device.
lReturn = lineGetIcon(dwDeviceID, "comm", &hIcon);
if (lReturn == SUCCESS)
SendDlgItemMessage(hwndDlg, IDC_LINEICON, STM_SETICON,
(WPARAM) hIcon, 0);
else
// Any failure to get an icon makes us use the default icon.
SendDlgItemMessage(hwndDlg, IDC_LINEICON, WM_SETTEXT,
0, (LPARAM) (LPCTSTR) "TapiComm");
/* // It turns out that TAPI will always return an icon, even if
// the device class isn't supported by the TSP or even if the TSP
// doesn't return any icons at all. This code is unnecessary.
// The only reason lineGetIcon would fail is due to resource problems.
else
{
// If the line doesn't have a "comm" device icon, use its default one.
lReturn = lineGetIcon(dwDeviceID, NULL, &hIcon);
if (lReturn == SUCCESS)
{
TSHELL_INFO(TEXT("Line doesn't support a \"comm\" icon."));
SendDlgItemMessage(hwndDlg, IDC_LINEICON, STM_SETICON,
(WPARAM) hIcon, 0);
}
else
{
// If lineGetIcon fails, just use TapiComms icon.
DBG_INFO((DBGARG, TEXT("lineGetIcon: %x"), lReturn));
SendDlgItemMessage(hwndDlg, IDC_LINEICON, WM_SETTEXT,
0, (LPARAM) (LPCTSTR) "TapiComm");
}
}
*/
// Verify if the device is usable by TapiComm.
lReturn = VerifyUsableLine(dwDeviceID);
// Enable or disable the 'Dial' button, depending on if the line is ok.
// Make sure there is a number to dial before enabling the button.
hControlWnd = GetDlgItem(hwndDlg, IDC_DIAL);
//
// Store Canon
//
if (g_szTranslatedNumber[0] = 0x00)
{
EnableWindow(hControlWnd, FALSE);
}
else
EnableWindow(hControlWnd, (lReturn == SUCCESS));
// Any errors on this line prevent us from configuring it
// or using dialing properties.
if (lReturn == LINENOTUSEABLE_ERROR)
{
EnableWindow(GetDlgItem(hwndDlg, IDC_CONFIGURELINE), FALSE);
EnableWindow(GetDlgItem(hwndDlg, IDC_DIALINGPROPERTIES), FALSE);
}
else
{
EnableWindow(GetDlgItem(hwndDlg, IDC_CONFIGURELINE), TRUE);
if (SendDlgItemMessage(hwndDlg, IDC_USEDIALINGRULES, BM_GETCHECK, 0, 0))
EnableWindow(GetDlgItem(hwndDlg, IDC_DIALINGPROPERTIES), TRUE);
}
switch(lReturn)
{
case SUCCESS:
g_dwDeviceID = dwDeviceID;
return TRUE;
case LINENOTUSEABLE_ERROR:
TSHELL_INFO(TEXT("The selected line is incompatible with DirectPlay"));
break;
case LINENOTUSEABLE_NOVOICE:
TSHELL_INFO(TEXT("The selected line doesn't support VOICE capabilities",));
break;
case LINENOTUSEABLE_NODATAMODEM:
TSHELL_INFO(TEXT("The selected line doesn't support DATAMODEM capabilities",));
break;
case LINENOTUSEABLE_NOMAKECALL:
TSHELL_INFO(TEXT("The selected line doesn't support MAKECALL capabilities",));
break;
case LINENOTUSEABLE_ALLOCATED:
TSHELL_INFO(TEXT("The selected line is already in use by a non-TAPI application",));
break;
case LINENOTUSEABLE_INUSE:
TSHELL_INFO(TEXT("The selected line is already in use by a TAPI application",));
break;
case LINENOTUSEABLE_NOCOMMDATAMODEM:
TSHELL_INFO(TEXT("The selected line doesn't support the COMM/DATAMODEM device class",));
break;
}
// g_dwDeviceID == MAXDWORD mean the selected device isn't usable.
g_dwDeviceID = MAXDWORD;
return FALSE;
}
//
// FUNCTION: void FillCountryCodeList(HWND, DWORD)
//
// PURPOSE: Fill the 'Country Code' control
//
// PARAMETERS:
// hwndDlg - handle to the current "Dial" dialog
// dwDefaultCountryID - ID of the 'default' country to be selected
//
// RETURN VALUE:
// none
//
// COMMENTS:
//
// This function fills the 'Country Code' control with country names.
// The country code is appended to the end of the name and the names
// are added to the control sorted. Because the country code is
// embedded in the string along with the country name, there is no need
// for any of the country information structures to be kept around. The
// country code can be extracted from the selected string at any time.
//
//
void FillCountryCodeList(HWND hwndDlg, DWORD dwDefaultCountryID)
{
LPLINECOUNTRYLIST lpLineCountryList = NULL;
DWORD dwSizeofCountryList = sizeof(LINECOUNTRYLIST);
long lReturn;
DWORD dwCountry;
LPLINECOUNTRYENTRY lpLineCountryEntries;
char szRenamedCountry[256];
// Get the country information stored in TAPI
do
{
lpLineCountryList = (LPLINECOUNTRYLIST) CheckAndReAllocBuffer(
(LPVOID) lpLineCountryList, dwSizeofCountryList,
TEXT("FillCountryCodeList"));
if (lpLineCountryList == NULL)
return;
lReturn = lineGetCountry (0, SAMPLE_TAPI_VERSION, lpLineCountryList);
if (HandleLineErr(lReturn))
;
else
{
DBG_INFO((DBGARG, TEXT("lineGetCountry unhandled error: %x"), lReturn));
LocalFree(lpLineCountryList);
return;
}
if ((lpLineCountryList -> dwNeededSize) >
(lpLineCountryList -> dwTotalSize))
{
dwSizeofCountryList = lpLineCountryList ->dwNeededSize;
lReturn = -1; // Lets loop again.
}
}
while (lReturn != SUCCESS);
// Find the first country entry
lpLineCountryEntries = (LPLINECOUNTRYENTRY)
(((LPBYTE) lpLineCountryList)
+ lpLineCountryList -> dwCountryListOffset);
// Now enumerate through all the countries
for (dwCountry = 0;
dwCountry < lpLineCountryList -> dwNumCountries;
dwCountry++)
{
// append the country code to the country name
wsprintf(szRenamedCountry,"%s (%lu)",
(((LPSTR) lpLineCountryList) +
lpLineCountryEntries[dwCountry].dwCountryNameOffset),
lpLineCountryEntries[dwCountry].dwCountryCode);
// Now put this country name / code string into the combobox
lReturn = SendDlgItemMessage(hwndDlg, IDC_COUNTRYCODE, CB_ADDSTRING,
0, (LPARAM) (LPCTSTR) szRenamedCountry);
// If this country is the default country, select it.
if (lpLineCountryEntries[dwCountry].dwCountryID
== dwDefaultCountryID)
{
SendDlgItemMessage(hwndDlg, IDC_COUNTRYCODE, CB_SETCURSEL, lReturn, 0);
}
}
LocalFree(lpLineCountryList);
return;
}
//
// FUNCTION: void FillLocationInfo(HWND, LPSTR, LPDWORD, LPSTR)
//
// PURPOSE: Fill (or refill) the 'Your Location' control
//
// PARAMETERS:
// hwndDlg - handle to the current "Dial" dialog
// lpszCurrentLocation - Name of current location, or NULL
// lpdwCountryID - location to store the current country ID or NULL
// lpszAreaCode - location to store the current area code or NULL
//
// RETURN VALUE:
// none
//
// COMMENTS:
//
// This function is moderately multipurpose.
//
// If lpszCurrentLocation is NULL, then the 'Your Location' control
// is filled with all the locations stored in TAPI and the TAPI 'default'
// location is selected. This is done during initialization and
// also after the 'Dialing Properties' dialog has been displayed.
// This last is done because the user can change the current location
// or add and delete locations while in the 'Dialing Properties' dialog.
//
// If lpszCurrentLocation is a valid string pointer, then it is assumed
// that the 'Your Location' control is already filled and that the user
// is selecting a specific location. In this case, all of the existing
// TAPI locations are enumerated until the specified location is found.
// At this point, the specified location is set to the current location.
//
// In either case, if lpdwCountryID is not NULL, it is filled with the
// country ID for the current location. If lpszAreaCode is not NULL, it
// is filled with the area code defined for the current location. These
// values can be used later to initialize other "Dial" controls.
//
// This function also fills the 'Calling Card' control based on
// the information stored in the current location.
//
//
void FillLocationInfo(HWND hwndDlg, LPSTR lpszCurrentLocation,
LPDWORD lpdwCountryID, LPSTR lpszAreaCode)
{
LPLINETRANSLATECAPS lpTranslateCaps = NULL;
DWORD dwSizeofTranslateCaps = sizeof(LINETRANSLATECAPS);
long lReturn;
DWORD dwCounter;
LPLINELOCATIONENTRY lpLocationEntry;
LPLINECARDENTRY lpLineCardEntry = NULL;
DWORD dwPreferredCardID = MAXDWORD;
TCHAR achMsg[MAX_PATH];
// First, get the TRANSLATECAPS
do
{
lpTranslateCaps = (LPLINETRANSLATECAPS) CheckAndReAllocBuffer(
(LPVOID) lpTranslateCaps, dwSizeofTranslateCaps,
TEXT(TEXT("FillLocationInfo")));
if (lpTranslateCaps == NULL)
return;
lReturn = lineGetTranslateCaps(g_hLineApp, SAMPLE_TAPI_VERSION,
lpTranslateCaps);
if (HandleLineErr(lReturn))
;
else
{
DBG_INFO((DBGARG, TEXT("lineGetTranslateCaps unhandled error: %x"), lReturn));
LocalFree(lpTranslateCaps);
return;
}
if ((lpTranslateCaps -> dwNeededSize) >
(lpTranslateCaps -> dwTotalSize))
{
dwSizeofTranslateCaps = lpTranslateCaps ->dwNeededSize;
lReturn = -1; // Lets loop again.
}
}
while(lReturn != SUCCESS);
// Find the location information in the TRANSLATECAPS
lpLocationEntry = (LPLINELOCATIONENTRY)
(((LPBYTE) lpTranslateCaps) + lpTranslateCaps->dwLocationListOffset);
// If lpszCurrentLocation, then make that location 'current'
if (lpszCurrentLocation)
{
// loop through all locations, looking for a location match
for(dwCounter = 0;
dwCounter < lpTranslateCaps -> dwNumLocations;
dwCounter++)
{
if (strcmp((((LPSTR) lpTranslateCaps) +
lpLocationEntry[dwCounter].dwLocationNameOffset),
lpszCurrentLocation)
== 0)
{
// Found it! Set the current location.
lineSetCurrentLocation(g_hLineApp,
lpLocationEntry[dwCounter].dwPermanentLocationID);
// Set the return values.
if (lpdwCountryID)
*lpdwCountryID = lpLocationEntry[dwCounter].dwCountryID;
if (lpszAreaCode)
strcpy(lpszAreaCode, (((LPSTR) lpTranslateCaps) +
lpLocationEntry[dwCounter].dwCityCodeOffset));
// Store the preferred card ID for later use.
dwPreferredCardID = lpLocationEntry[dwCounter].dwPreferredCardID;
break;
}
}
// Was a match for lpszCurrentLocation found?
if (dwPreferredCardID == MAXDWORD)
{
TSHELL_INFO(TEXT("lpszCurrentLocation not found"));
LoadString( hInst, IDS_LOCATIONERR, achMsg, sizeof(achMsg));
SendDlgItemMessage(hwndDlg, IDC_CALLINGCARD, WM_SETTEXT, 0,
(LPARAM) achMsg);
LocalFree(lpTranslateCaps);
return;
}
}
else // fill the combobox and use the TAPI 'current' location.
{
// First empty the combobox
SendDlgItemMessage(hwndDlg, IDC_LOCATION, CB_RESETCONTENT, 0, 0);
// enumerate all the locations
for(dwCounter = 0;
dwCounter < lpTranslateCaps -> dwNumLocations;
dwCounter++)
{
// Put each one into the combobox
lReturn = SendDlgItemMessage(hwndDlg, IDC_LOCATION, CB_ADDSTRING,
0, (LPARAM) (((LPBYTE) lpTranslateCaps) +
lpLocationEntry[dwCounter].dwLocationNameOffset));
// Is this location the 'current' location?
if (lpLocationEntry[dwCounter].dwPermanentLocationID ==
lpTranslateCaps->dwCurrentLocationID)
{
// Return the requested information
if (lpdwCountryID)
*lpdwCountryID = lpLocationEntry[dwCounter].dwCountryID;
if (lpszAreaCode)
strcpy(lpszAreaCode, (((LPSTR) lpTranslateCaps) +
lpLocationEntry[dwCounter].dwCityCodeOffset));
// Set this to be the active location.
SendDlgItemMessage(hwndDlg, IDC_LOCATION, CB_SETCURSEL, lReturn, 0);
dwPreferredCardID = lpLocationEntry[dwCounter].dwPreferredCardID;
}
}
}
// Now locate the prefered card and display it.
lpLineCardEntry = (LPLINECARDENTRY)
(((LPBYTE) lpTranslateCaps) + lpTranslateCaps->dwCardListOffset);
for(dwCounter = 0;
dwCounter < lpTranslateCaps -> dwNumCards;
dwCounter++)
{
if (lpLineCardEntry[dwCounter].dwPermanentCardID == dwPreferredCardID)
{
SendDlgItemMessage(hwndDlg, IDC_CALLINGCARD, WM_SETTEXT, 0,
(LPARAM) (((LPBYTE) lpTranslateCaps) +
lpLineCardEntry[dwCounter].dwCardNameOffset));
break;
}
}
LocalFree(lpTranslateCaps);
}
//
// FUNCTION: void UseDialingRules(HWND)
//
// PURPOSE: Enable/disable Dialing Rule controls
//
// PARAMETERS:
// hwndDlg - handle to the current "Dial" dialog
//
// RETURN VALUE:
// none
//
// COMMENTS:
//
// The sole purpose of this function is to enable or disable
// the controls that apply to dialing rules if the
// "Use Country Code and Area Code" checkbox is checked or unchecked,
// as appropriate.
//
//
void UseDialingRules(HWND hwndDlg)
{
HWND hControl;
BOOL bEnableWindow;
bEnableWindow = SendDlgItemMessage(hwndDlg,
IDC_USEDIALINGRULES, BM_GETCHECK, 0, 0);
hControl = GetDlgItem(hwndDlg, IDC_STATICCOUNTRYCODE);
EnableWindow(hControl, bEnableWindow);
hControl = GetDlgItem(hwndDlg, IDC_COUNTRYCODE);
EnableWindow(hControl, bEnableWindow);
hControl = GetDlgItem(hwndDlg, IDC_STATICAREACODE);
EnableWindow(hControl, bEnableWindow);
hControl = GetDlgItem(hwndDlg, IDC_AREACODE);
EnableWindow(hControl, bEnableWindow);
hControl = GetDlgItem(hwndDlg, IDC_STATICLOCATION);
EnableWindow(hControl, bEnableWindow);
hControl = GetDlgItem(hwndDlg, IDC_LOCATION);
EnableWindow(hControl, bEnableWindow);
hControl = GetDlgItem(hwndDlg, IDC_STATICCALLINGCARD);
EnableWindow(hControl, bEnableWindow);
hControl = GetDlgItem(hwndDlg, IDC_CALLINGCARD);
EnableWindow(hControl, bEnableWindow);
if (IsWindowEnabled(GetDlgItem(hwndDlg, IDC_CONFIGURELINE)))
{
hControl = GetDlgItem(hwndDlg, IDC_DIALINGPROPERTIES);
EnableWindow(hControl, bEnableWindow);
}
}
//
// FUNCTION: void DisplayPhoneNumber(HWND)
//
// PURPOSE: Create, Translate and Display the Phone Number
//
// PARAMETERS:
// hwndDlg - handle to the current "Dial" dialog
//
// RETURN VALUE:
// none
//
// COMMENTS:
//
// This function uses the information stored in many other controls
// to build the phone number, translate it, and display it. Also
// makes sure the Dial button is enabled or disabled, based on if the
// number can be dialed or not.
//
// There are actually three phone numbers generated during this
// process: canonical, dialable and displayable. Normally, only the
// displayable number is shown to the user; the other two numbers are
// to be used by the program internally. However, for demonstration
// purposes (and because it is cool for developers to see these numbers),
// all three numbers are displayed.
//
void DisplayPhoneNumber(HWND hwndDlg)
{
char szPreTranslatedNumber[128] = "";
int nPreTranslatedSize = 0;
char szTempBuffer[512];
int i;
DWORD dwDeviceID;
LPLINETRANSLATEOUTPUT lpLineTranslateOutput = NULL;
// Disable the 'dial' button if there isn't a number to dial
if (0 == SendDlgItemMessage(hwndDlg, IDC_PHONENUMBER,
WM_GETTEXTLENGTH, 0, 0))
{
EnableWindow(GetDlgItem(hwndDlg, IDC_DIAL), FALSE);
return;
}
// If we use the dialing rules, lets make canonical format.
// Canonical format is explained in the TAPI documentation and the
// string format needs to be followed very strictly.
if (SendDlgItemMessage(hwndDlg, IDC_USEDIALINGRULES,
BM_GETCHECK, 0, 0))
{
// First character *has* to be the plus sign.
szPreTranslatedNumber[0] = '+';
nPreTranslatedSize = 1;
// The country code *has* to be next.
// Country code was stored in the string with the country
// name and needs to be extracted at this point.
i = SendDlgItemMessage(hwndDlg, IDC_COUNTRYCODE,
CB_GETCURSEL, 0, 0);
SendDlgItemMessage(hwndDlg, IDC_COUNTRYCODE,
CB_GETLBTEXT, (WPARAM) i, (LPARAM) (LPCTSTR) szTempBuffer);
// Country code is at the end of the string, surounded by parens.
// This makes it easy to identify the country code.
i = strlen(szTempBuffer);
while(szTempBuffer[--i] != '(');
while(szTempBuffer[++i] != ')')
szPreTranslatedNumber[nPreTranslatedSize++] = szTempBuffer[i];
// Next is the area code.
i = SendDlgItemMessage(hwndDlg, IDC_AREACODE, WM_GETTEXT,
510, (LPARAM) (LPCTSTR) szTempBuffer);
// Note that the area code is optional. If it is included,
// then it has to be preceeded by *exactly* one space and it
// *has* to be surrounded by parens.
if (i)
nPreTranslatedSize +=
wsprintf(&szPreTranslatedNumber[nPreTranslatedSize],
" (%s)", szTempBuffer);
// There has to be *exactly* one space before the rest of the number.
szPreTranslatedNumber[nPreTranslatedSize++] = ' ';
// At this point, the phone number is appended to the
// canonical number. The next step is the same whether canonical
// format is used or not; just the prepended area code and
// country code are different.
}
SendDlgItemMessage(hwndDlg, IDC_PHONENUMBER, WM_GETTEXT,
510, (LPARAM) (LPCTSTR) szTempBuffer);
strcat(&szPreTranslatedNumber[nPreTranslatedSize], szTempBuffer);
dwDeviceID = SendDlgItemMessage(hwndDlg, IDC_TAPILINE,
CB_GETCURSEL, 0, 0);
// Translate the address!
lpLineTranslateOutput = I_lineTranslateAddress(
lpLineTranslateOutput, dwDeviceID, SAMPLE_TAPI_VERSION,
szPreTranslatedNumber);
// Unable to translate it?
if (lpLineTranslateOutput == NULL)
{
g_szTranslatedNumber[0] = 0x00;
g_szDisplayableAddress[0] = 0x00;
g_szDialableAddress[0] = 0x00;
EnableWindow(GetDlgItem(hwndDlg, IDC_DIAL), FALSE);
return;
}
// Is the selected device useable with TapiComm?
if (g_dwDeviceID != MAXDWORD)
EnableWindow(GetDlgItem(hwndDlg, IDC_DIAL), TRUE);
// Fill the appropriate phone number controls.
strcpy( g_szTranslatedNumber, szPreTranslatedNumber);
strcpy( g_szDialableAddress, ((LPSTR) lpLineTranslateOutput +
lpLineTranslateOutput -> dwDialableStringOffset));
strcpy( g_szDisplayableAddress, ((LPSTR) lpLineTranslateOutput +
lpLineTranslateOutput -> dwDisplayableStringOffset));
LocalFree(lpLineTranslateOutput);
}
//
// FUNCTION: void PreConfigureDevice(HWND, DWORD)
//
// PURPOSE:
//
// PARAMETERS:
// hwndDlg - handle to the current "Dial" dialog
// dwDeviceID - line device to be configured
//
// RETURN VALUE:
// none
//
// COMMENTS:
//
// At one point, PreConfigureDevice used lineConfigDialog to
// configure the device. This has the unfortunate effect of configuring
// the device immediately, even if it is in use by another TAPI app.
// This can be really bad if data communications are already in
// progress (like with RAS).
//
// Now, PreConfigureDevice uses lineConfigDialogEdit to give the
// user the configuration UI, but it doesn't actually do anything to
// the line device. TapiComm stores the configuration information so
// that it can be set later, just before making the call.
//
//
void PreConfigureDevice(HWND hwndDlg, DWORD dwDeviceID)
{
long lReturn;
LPVARSTRING lpVarString = NULL;
DWORD dwSizeofVarString = sizeof(VARSTRING);
// If there isn't already any device configuration information,
// then we need to get some.
if (g_lpDeviceConfig == NULL)
{
do
{
lpVarString = (LPVARSTRING) CheckAndReAllocBuffer(
(LPVOID) lpVarString, dwSizeofVarString,
TEXT("PreConfigureDevice - lineGetDevConfig: "));
if (lpVarString == NULL)
return;
lReturn = lineGetDevConfig(dwDeviceID, lpVarString,
"comm/datamodem");
if (HandleLineErr(lReturn))
;
else
{
DBG_INFO((DBGARG, TEXT("lineGetDevCaps unhandled error: %x"), lReturn));
LocalFree(lpVarString);
return;
}
if ((lpVarString -> dwNeededSize) > (lpVarString -> dwTotalSize))
{
dwSizeofVarString = lpVarString -> dwNeededSize;
lReturn = -1; // Lets loop again.
}
}
while (lReturn != SUCCESS);
g_dwSizeDeviceConfig = lpVarString -> dwStringSize;
// The extra byte allocated is in case dwStringSize is 0.
g_lpDeviceConfig = CheckAndReAllocBuffer(
g_lpDeviceConfig, g_dwSizeDeviceConfig+1,
TEXT("PreConfigureDevice - Allocate device config: "));
if (!g_lpDeviceConfig)
{
LocalFree(lpVarString);
return;
}
memcpy(g_lpDeviceConfig,
((LPBYTE) lpVarString + lpVarString -> dwStringOffset),
g_dwSizeDeviceConfig);
}
// Next make the lineConfigDialogEdit call.
// Note that we determine the initial size of the VARSTRING
// structure based on the known size of the existing configuration
// information. I make the assumption that this configuration
// information is very unlikely to grow by more than 5K or by
// more than 5 times. This is a *very* conservative number.
// We do *not* want lineConfigDialogEdit to fail just because there
// wasn't enough room to stored the data. This would require the user
// to go through configuration again and that would be annoying.
dwSizeofVarString = 5 * g_dwSizeDeviceConfig + 5000;
do
{
lpVarString = (LPVARSTRING) CheckAndReAllocBuffer(
(LPVOID) lpVarString, dwSizeofVarString,
TEXT("PreConfigureDevice - lineConfigDialogEdit: "));
if (lpVarString == NULL)
return;
lReturn = lineConfigDialogEdit(dwDeviceID, hwndDlg, "comm/datamodem",
g_lpDeviceConfig, g_dwSizeDeviceConfig, lpVarString);
if (HandleLineErr(lReturn))
;
else
{
DBG_INFO((DBGARG, TEXT("lineConfigDialogEdit unhandled error: %x"), lReturn));
LocalFree(lpVarString);
return;
}
if ((lpVarString -> dwNeededSize) > (lpVarString -> dwTotalSize))
{
// We had been conservative about making sure the structure was
// big enough. Unfortunately, not conservative enough. Hopefully,
// this will not happen a second time because we are *DOUBLING*
// the NeededSize.
dwSizeofVarString = (lpVarString -> dwNeededSize) * 2;
lReturn = -1; // Lets loop again.
}
}
while (lReturn != SUCCESS);
// Store the configuration information into a global structure
// so it can be set at a later time.
g_dwSizeDeviceConfig = lpVarString -> dwStringSize;
g_lpDeviceConfig = CheckAndReAllocBuffer(
g_lpDeviceConfig, g_dwSizeDeviceConfig+1,
TEXT("PreConfigureDevice - Reallocate device config: "));
if (!g_lpDeviceConfig)
{
LocalFree(lpVarString);
return;
}
memcpy(g_lpDeviceConfig,
((LPBYTE) lpVarString + lpVarString -> dwStringOffset),
g_dwSizeDeviceConfig);
LocalFree(lpVarString);
}
//
// FUNCTION: BOOL GetAddressToDial
//
// PURPOSE: Get an address to dial from the user.
//
// PARAMETERS:
// none
//
// RETURN VALUE:
// TRUE if a valid device and phone number have been entered by
// the user. FALSE if the user canceled the dialing process.
//
// COMMENTS:
//
// All this function does is launch the "Dial" dialog.
//
//
BOOL GetAddressToDial()
{
BOOL bRet;
bRet = DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_DIALDIALOG), g_hDlgParentWindow,
(DLGPROC) DialDialogProc, 0);
g_hDialog = NULL;
g_hDlgParentWindow = g_hWndMainWindow;
return bRet;
}
//
// FUNCTION: DialDialogProc(HWND, UINT, WPARAM, LPARAM)
//
// PURPOSE: Dialog callback procedure for the dialing dialog
//
// PARAMETERS:
// hwndDlg - Dialog calling the callback.
// uMsg - Dialog message.
// wParam - uMsg specific.
// lParam - uMsg specific.
//
// RETURN VALUE:
// returns 0 - command handled.
// returns non-0 - command unhandled
//
// COMMENTS:
//
// This is the dialog to get the phone number and line device
// from the user. All the relavent information is stored in global
// variables to be used later if the dialog returns successfully.
//
//
BOOL CALLBACK DialDialogProc(
HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
// Static variables to store the information from last time the
// "Dial" dialog was displayed. That way the phone number can be
// typed once but used several times.
static TCHAR szCountryName[512] = TEXT("");
static TCHAR szAreaCode[256] = TEXT("");
static TCHAR szPhoneNumber[512] = TEXT("");
static DWORD dwUsedDeviceID = MAXDWORD;
static BOOL bUsedCountryAndArea = FALSE;
static BOOL bHistoryValid = FALSE;
switch(uMsg)
{
case WM_INITDIALOG:
{
DWORD dwCountryID = 0;
// Store the Dialog Window so it can be dismissed if necessary
g_hDialog = hwndDlg;
// This dialog should be parent to all dialogs.
g_hDlgParentWindow = hwndDlg;
// Initialize the Dialog Box. Lots to do here.
FillTAPILine(hwndDlg);
if (g_lpDeviceConfig)
{
LocalFree(g_lpDeviceConfig);
g_lpDeviceConfig = NULL;
}
// If there is a valid history, use it to initialize the controls.
if (bHistoryValid)
{
FillLocationInfo(hwndDlg, NULL, NULL, NULL);
FillCountryCodeList(hwndDlg, 0);
SendDlgItemMessage(hwndDlg, IDC_COUNTRYCODE, CB_SELECTSTRING,
(WPARAM) -1, (LPARAM) (LPCTSTR) szCountryName);
SendDlgItemMessage(hwndDlg, IDC_PHONENUMBER, WM_SETTEXT, 0,
(LPARAM) (LPCTSTR) szPhoneNumber);
SendDlgItemMessage(hwndDlg, IDC_USEDIALINGRULES,
BM_SETCHECK, (WPARAM) bUsedCountryAndArea, 0);
SendDlgItemMessage(hwndDlg, IDC_TAPILINE, CB_SETCURSEL,
g_dwDeviceID, 0);
}
else
{
FillLocationInfo(hwndDlg, NULL, &dwCountryID, szAreaCode);
FillCountryCodeList(hwndDlg, dwCountryID);
SendDlgItemMessage(hwndDlg, IDC_USEDIALINGRULES,
BM_SETCHECK, 1, 0);
}
SendDlgItemMessage(hwndDlg, IDC_AREACODE, WM_SETTEXT,
0, (LPARAM) (LPCTSTR) szAreaCode);
UseDialingRules(hwndDlg);
DisplayPhoneNumber(hwndDlg);
VerifyAndWarnUsableLine(hwndDlg);
return TRUE;
}
case WM_COMMAND:
{
switch(LOWORD(wParam))
{
case IDC_TAPILINE:
if (HIWORD(wParam) == CBN_SELENDOK)
{
if (g_lpDeviceConfig)
{
LocalFree(g_lpDeviceConfig);
g_lpDeviceConfig = NULL;
}
DisplayPhoneNumber(hwndDlg);
VerifyAndWarnUsableLine(hwndDlg);
}
return TRUE;
case IDC_CONFIGURELINE:
{
DWORD dwDeviceID;
dwDeviceID = SendDlgItemMessage(hwndDlg, IDC_TAPILINE,
CB_GETCURSEL, 0, 0);
PreConfigureDevice(hwndDlg, dwDeviceID);
DisplayPhoneNumber(hwndDlg);
return TRUE;
}
case IDC_COUNTRYCODE:
if (HIWORD(wParam) == CBN_SELENDOK)
DisplayPhoneNumber(hwndDlg);
return TRUE;
case IDC_AREACODE:
case IDC_PHONENUMBER:
if (HIWORD(wParam) == EN_CHANGE)
DisplayPhoneNumber(hwndDlg);
return TRUE;
case IDC_USEDIALINGRULES:
if (HIWORD(wParam) == BN_CLICKED)
{
UseDialingRules(hwndDlg);
DisplayPhoneNumber(hwndDlg);
}
return TRUE;
case IDC_LOCATION:
if (HIWORD(wParam) == CBN_CLOSEUP)
{
char szCurrentLocation[128];
int nCurrentSelection;
nCurrentSelection = SendDlgItemMessage(hwndDlg,
IDC_LOCATION, CB_GETCURSEL, 0, 0);
SendDlgItemMessage(hwndDlg, IDC_LOCATION,
CB_GETLBTEXT, nCurrentSelection,
(LPARAM) (LPCTSTR) szCurrentLocation);
// If the user selected a 'location', make it current.
FillLocationInfo(hwndDlg, szCurrentLocation, NULL, NULL);
DisplayPhoneNumber(hwndDlg);
}
return TRUE;
case IDC_DIALINGPROPERTIES:
{
DWORD dwDeviceID;
long lReturn;
dwDeviceID = SendDlgItemMessage(hwndDlg, IDC_TAPILINE,
CB_GETCURSEL, 0, 0);
lReturn = lineTranslateDialog(g_hLineApp, dwDeviceID,
SAMPLE_TAPI_VERSION, hwndDlg, g_szTranslatedNumber);
#ifdef DEBUG
if (lReturn != SUCCESS)
DBG_INFO((DBGARG, TEXT("lineTranslateDialog: %x"), lReturn));
#endif
// The user could have changed the default location, or
// added or removed a location while in the 'Dialing
// Properties' dialog. Refill the Location Info.
FillLocationInfo(hwndDlg, NULL, NULL, NULL);
DisplayPhoneNumber(hwndDlg);
return TRUE;
}
case IDCANCEL:
EndDialog(hwndDlg, FALSE);
return TRUE;
case IDC_DIAL:
{
// The Dial button has to be enabled and the line has
// to be currently usable to continue.
if (!(IsWindowEnabled((HWND)lParam) &&
VerifyAndWarnUsableLine(hwndDlg)))
return TRUE;
DisplayPhoneNumber(hwndDlg);
// Store all the relavent information in static
// variables so they will be available the next time a
// number is dialed.
SendDlgItemMessage(hwndDlg, IDC_COUNTRYCODE,
WM_GETTEXT, 511, (LPARAM) (LPCTSTR) szCountryName);
SendDlgItemMessage(hwndDlg, IDC_AREACODE,
WM_GETTEXT, 255, (LPARAM) (LPCTSTR) szAreaCode);
SendDlgItemMessage(hwndDlg, IDC_PHONENUMBER,
WM_GETTEXT, 511, (LPARAM) (LPCTSTR) szPhoneNumber);
bUsedCountryAndArea = (BOOL) SendDlgItemMessage(hwndDlg,
IDC_USEDIALINGRULES, BM_GETCHECK, 0, 0);
bHistoryValid = TRUE;
EndDialog(hwndDlg, TRUE);
return TRUE;
}
// This message is actually posted to the dialog from the
// lineCallbackFunc when it receives a
// LINEDEVSTATE_TRANSLATECHANGE message. Notify the user and
// retranslate the number. Also refill the Location Info
// since this could have been generated by a location change.
case IDC_CONFIGURATIONCHANGED:
{
FillLocationInfo(hwndDlg, NULL, NULL, NULL);
DisplayPhoneNumber(hwndDlg);
return TRUE;
}
// If we get a LINE_CREATE message, all that needs to be done
// is to reset this controls contents. The selected line
// won't change and no lines will be removed.
case IDC_LINECREATE:
{
FillTAPILine(hwndDlg);
return TRUE;
}
default:
break;
}
break;
}
default:
break;
}
return FALSE;
}
Reference in New Issue Copy Permalink