1095 lines
29 KiB
C++
1095 lines
29 KiB
C++
/*++
|
|
|
|
Copyright (c) 1999 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
provider.cpp
|
|
|
|
Abstract:
|
|
|
|
TAPI Service Provider functions related to provider info.
|
|
|
|
TSPI_providerConfig
|
|
TSPI_providerEnumDevices
|
|
TSPI_providerFreeDialogInstance
|
|
TSPI_providerGenericDialogData
|
|
TSPI_providerInit
|
|
TSPI_providerInstall
|
|
TSPI_providerRemove
|
|
TSPI_providerShutdown
|
|
TSPI_providerUIIdentify
|
|
|
|
TUISPI_providerConfig
|
|
TUISPI_providerInstall
|
|
TUISPI_providerRemove
|
|
|
|
Author:
|
|
Nikhil Bobde (NikhilB)
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
|
|
//
|
|
// Include files
|
|
//
|
|
|
|
|
|
#include "globals.h"
|
|
#include "line.h"
|
|
#include "config.h"
|
|
#include "q931obj.h"
|
|
#include "ras.h"
|
|
|
|
|
|
//
|
|
// Global variables
|
|
//
|
|
|
|
|
|
DWORD g_dwLineDeviceIDBase = -1;
|
|
DWORD g_dwPermanentProviderID = -1;
|
|
LINEEVENT g_pfnLineEventProc = NULL;
|
|
HANDLE g_hCanUnloadDll = NULL;
|
|
HANDLE g_hEventLogSource = NULL;
|
|
static HPROVIDER g_hProvider = NULL;
|
|
ASYNC_COMPLETION g_pfnCompletionProc = NULL;
|
|
|
|
|
|
|
|
// //
|
|
// Public procedures //
|
|
// //
|
|
|
|
BOOL
|
|
H323IsTSPAlreadyInstalled(void)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Searchs registry for previous instance of H323.TSP.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Values:
|
|
|
|
Returns true if TSP already installed.
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD i;
|
|
HKEY hKey;
|
|
LONG lStatus;
|
|
DWORD dwNumProviders = 0;
|
|
DWORD dwDataSize = sizeof(DWORD);
|
|
DWORD dwDataType = REG_DWORD;
|
|
LPTSTR pszProvidersKey = TAPI_REGKEY_PROVIDERS;
|
|
LPTSTR pszNumProvidersValue = TAPI_REGVAL_NUMPROVIDERS;
|
|
TCHAR szName[H323_MAXPATHNAMELEN+1];
|
|
TCHAR szPath[H323_MAXPATHNAMELEN+1];
|
|
|
|
// attempt to open key
|
|
lStatus = RegOpenKeyEx(
|
|
HKEY_LOCAL_MACHINE,
|
|
pszProvidersKey,
|
|
0,
|
|
KEY_READ,
|
|
&hKey
|
|
);
|
|
|
|
// validate status
|
|
if (lStatus != NOERROR)
|
|
{
|
|
H323DBG(( DEBUG_LEVEL_WARNING,
|
|
"error 0x%08lx opening tapi providers key.", lStatus ));
|
|
|
|
// done
|
|
return FALSE;
|
|
}
|
|
|
|
// see if installed bit set
|
|
lStatus = RegQueryValueEx(
|
|
hKey,
|
|
pszNumProvidersValue,
|
|
0,
|
|
&dwDataType,
|
|
(LPBYTE) &dwNumProviders,
|
|
&dwDataSize
|
|
);
|
|
|
|
// validate status
|
|
if( lStatus != NOERROR )
|
|
{
|
|
H323DBG(( DEBUG_LEVEL_WARNING,
|
|
"error 0x%08lx determining number of providers.", lStatus ));
|
|
|
|
// release handle
|
|
RegCloseKey(hKey);
|
|
|
|
// done
|
|
return FALSE;
|
|
}
|
|
|
|
// loop through each provider
|
|
for (i = 0; i < dwNumProviders; i++)
|
|
{
|
|
// construct path to provider name
|
|
wsprintf(szName, _T("ProviderFileName%d"), i);
|
|
|
|
// reinitialize size
|
|
dwDataSize = sizeof(szPath);
|
|
|
|
// query the next name
|
|
lStatus = RegQueryValueEx(
|
|
hKey,
|
|
szName,
|
|
0,
|
|
&dwDataType,
|
|
(unsigned char*)szPath,
|
|
&dwDataSize
|
|
);
|
|
|
|
// validate status
|
|
if (lStatus == NOERROR)
|
|
{
|
|
// upper case
|
|
_tcsupr(szPath);
|
|
|
|
// compare path string to h323 provider
|
|
if (_tcsstr(szPath, H323_TSPDLL) != NULL)
|
|
{
|
|
// release handle
|
|
RegCloseKey(hKey);
|
|
|
|
// done
|
|
return TRUE;
|
|
}
|
|
|
|
} else {
|
|
|
|
H323DBG((
|
|
DEBUG_LEVEL_WARNING,
|
|
"error 0x%08lx loading %s.",
|
|
lStatus,
|
|
szName
|
|
));
|
|
}
|
|
}
|
|
|
|
// release handle
|
|
RegCloseKey(hKey);
|
|
|
|
// done
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// TSPI procedures
|
|
//
|
|
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
This function is called by TAPI in response to receipt of a LINE_CREATE
|
|
message from the service provider, which allows the dynamic creation of
|
|
a new line device.
|
|
|
|
Arguments:
|
|
|
|
dwTempID - The temporary device identifier that the service provider
|
|
passed to TAPI in the LINE_CREATE message.
|
|
|
|
dwDeviceID - The device identifier that TAPI assigns to this device if
|
|
this function succeeds.
|
|
|
|
Return Values:
|
|
|
|
Returns zero if the request is successful or a negative error number if
|
|
an error has occurred. Possible return values are:
|
|
|
|
LINEERR_BADDEVICEID - The specified line device ID is out of range.
|
|
|
|
LINEERR_NOMEM - Unable to allocate or lock memory.
|
|
|
|
LINEERR_OPERATIONFAILED - The specified operation failed for unknown
|
|
reasons.
|
|
|
|
--*/
|
|
|
|
LONG
|
|
TSPIAPI
|
|
TSPI_providerCreateLineDevice(
|
|
DWORD_PTR dwTempID,
|
|
DWORD dwDeviceID
|
|
)
|
|
{
|
|
//in the new TSP we don't support creating multiple H323 lines.
|
|
//So return success silently but assert in the debug version
|
|
_ASSERTE(0);
|
|
|
|
/*H323DBG(( DEBUG_LEVEL_TRACE,
|
|
"creating new device %d (hdLine=0x%08lx).",
|
|
dwDeviceID, dwTempID ));
|
|
|
|
// lock line device using temporary device id
|
|
if (!H323GetLineFromIDAndLock(&pLine, (DWORD)dwTempID))
|
|
{
|
|
H323DBG(( DEBUG_LEVEL_ERROR,
|
|
"invalid temp device id 0x%08lx.", dwTempID ));
|
|
|
|
// failure
|
|
return LINEERR_BADDEVICEID;
|
|
}
|
|
|
|
// initialize new line device
|
|
H323InitializeLine(pLine, dwDeviceID);
|
|
|
|
// unlock line
|
|
H323UnlockLine(pLine);*/
|
|
|
|
// success
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
TAPI.DLL calls this function before TSPI_providerInit to determine the
|
|
number of line and phone devices supported by the service provider.
|
|
|
|
Arguments:
|
|
|
|
dwPermanentProviderID - Specifies the permanent ID, unique within the
|
|
service providers on this system, of the service provider being
|
|
initialized.
|
|
|
|
pdwNumLines - Specifies a far pointer to a DWORD-sized memory location
|
|
into which the service provider must write the number of line devices
|
|
it is configured to support. TAPI.DLL initializes the value to zero,
|
|
so if the service provider fails to write a different value, the
|
|
value 0 is assumed.
|
|
|
|
pdwNumPhones - Specifies a far pointer to a DWORD-sized memory location
|
|
into which the service provider must write the number of phone devices
|
|
it is configured to support. TAPI.DLL initializes the value to zero,
|
|
so if the service provider fails to write a different value, the
|
|
value 0 is assumed.
|
|
|
|
hProvider - Specifies an opaque DWORD-sized value which uniquely identifies
|
|
this instance of this service provider during this execution of the
|
|
Windows Telephony environment.
|
|
|
|
pfnLineCreateProc - Specifies a far pointer to the LINEEVENT callback
|
|
procedure supplied by TAPI.DLL. The service provider will use this
|
|
function to send LINE_CREATE messages when a new line device needs to
|
|
be created. This function should not be called to send a LINE_CREATE
|
|
message until after the service provider has returned from the
|
|
TSPI_providerInit procedure.
|
|
|
|
pfnPhoneCreateProc - Specifies a far pointer to the PHONEEVENT callback
|
|
procedure supplied by TAPI.DLL. The service provider will use this
|
|
function to send PHONE_CREATE messages when a new phone device needs
|
|
to be created. This function should not be called to send a
|
|
PHONE_CREATE message until after the service provider has returned
|
|
from the TSPI_providerInit procedure.
|
|
|
|
Return Values:
|
|
|
|
Returns zero if the request is successful or a negative error number if
|
|
an error has occurred. Possible return values are:
|
|
|
|
LINEERR_NOMEM - Unable to allocate or lock memory.
|
|
|
|
LINEERR_OPERATIONFAILED - The specified operation failed for unknown
|
|
reasons.
|
|
|
|
--*/
|
|
LONG
|
|
TSPIAPI
|
|
TSPI_providerEnumDevices(
|
|
DWORD dwPermanentProviderID,
|
|
PDWORD pdwNumLines,
|
|
PDWORD pdwNumPhones,
|
|
HPROVIDER hProvider,
|
|
LINEEVENT pfnLineCreateProc,
|
|
PHONEEVENT pfnPhoneCreateProc
|
|
)
|
|
{
|
|
WSADATA wsaData;
|
|
WORD wVersionRequested = H323_WINSOCKVERSION;
|
|
|
|
UNREFERENCED_PARAMETER(pdwNumPhones); // no phone support
|
|
UNREFERENCED_PARAMETER(pfnPhoneCreateProc); // no dynamic phones
|
|
UNREFERENCED_PARAMETER(dwPermanentProviderID); // legacy parameter
|
|
|
|
H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_providerEnumDevices - Entered." ));
|
|
|
|
// initialize winsock stack
|
|
WSAStartup(wVersionRequested, &wsaData);
|
|
|
|
// save provider handle
|
|
g_hProvider = hProvider;
|
|
|
|
|
|
// save line create tapi callback
|
|
g_pfnLineEventProc = pfnLineCreateProc;
|
|
_ASSERTE(g_pfnLineEventProc);
|
|
|
|
H323DBG(( DEBUG_LEVEL_VERBOSE, "service provider supports 1 line."));
|
|
|
|
// report number of interfaces
|
|
*pdwNumLines = 1;
|
|
|
|
H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_providerEnumdevices - Exited." ));
|
|
|
|
// success
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
static LONG H323Initialize (
|
|
IN DWORD LineDeviceIDBase)
|
|
{
|
|
HRESULT hr;
|
|
|
|
H323DBG(( DEBUG_LEVEL_TRACE, "H323Initialize - Entered." ));
|
|
|
|
if (!g_pH323Line -> Initialize (LineDeviceIDBase))
|
|
{
|
|
H323DBG(( DEBUG_LEVEL_ERROR, "init failed for h323 line." ));
|
|
return ERROR_GEN_FAILURE;
|
|
}
|
|
|
|
RegistryStart();
|
|
|
|
g_hCanUnloadDll = H323CreateEvent( NULL, TRUE, TRUE,
|
|
_T( "H323TSP_DLLUnloadEvent" ) );
|
|
|
|
if( g_hCanUnloadDll == NULL )
|
|
{
|
|
H323DBG(( DEBUG_LEVEL_ERROR, "could not create unloadDLL handle." ));
|
|
return ERROR_GEN_FAILURE;
|
|
}
|
|
|
|
#if H323_USE_PRIVATE_IO_THREAD
|
|
|
|
hr = H323IoThreadStart();
|
|
if (hr != S_OK)
|
|
return ERROR_GEN_FAILURE;
|
|
|
|
#endif
|
|
|
|
H323DBG(( DEBUG_LEVEL_TRACE, "H323Initialize - Exited." ));
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
|
|
void ReportTSPEvent(
|
|
LPCTSTR wszErrorMessage )
|
|
{
|
|
if( g_hEventLogSource )
|
|
{
|
|
ReportEvent(
|
|
g_hEventLogSource, // handle of event source
|
|
EVENTLOG_ERROR_TYPE,// event type
|
|
0, // event category
|
|
0x80000001, // event ID
|
|
NULL, // user SID
|
|
1, // string count
|
|
0, // no bytes of raw data
|
|
&wszErrorMessage, // array of error strings
|
|
NULL); // no raw data
|
|
}
|
|
}
|
|
|
|
|
|
static
|
|
VOID H323Shutdown (void)
|
|
{
|
|
g_pH323Line -> Shutdown();
|
|
|
|
RegistryStop();
|
|
|
|
if( g_hCanUnloadDll != NULL )
|
|
{
|
|
H323DBG(( DEBUG_LEVEL_WARNING, "waiting for i/o refcount to get 0..." ));
|
|
|
|
//wait until all the calls have been deleted
|
|
WaitForSingleObject(
|
|
g_hCanUnloadDll,
|
|
300 * 1000 // Wait for 5 minutes to let everything shutdown.
|
|
);
|
|
|
|
H323DBG ((DEBUG_LEVEL_WARNING, "i/o refcount is 0..."));
|
|
|
|
CloseHandle( g_hCanUnloadDll );
|
|
g_hCanUnloadDll = NULL;
|
|
|
|
//sleep for 500 ms
|
|
Sleep( 500 );
|
|
}
|
|
|
|
#if H323_USE_PRIVATE_IO_THREAD
|
|
|
|
H323IoThreadStop();
|
|
|
|
#endif
|
|
|
|
if( g_hEventLogSource )
|
|
{
|
|
DeregisterEventSource( g_hEventLogSource );
|
|
g_hEventLogSource = NULL;
|
|
}
|
|
|
|
// shutdown
|
|
WSACleanup();
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Initializes the service provider, also giving it parameters required for
|
|
subsequent operation.
|
|
|
|
This function is guaranteed to be called before any of the other functions
|
|
prefixed with TSPI_line or TSPI_phone except TSPI_lineNegotiateTSPIVersion.
|
|
It is strictly paired with a subsequent call to TSPI_providerShutdown. It
|
|
is the caller's reponsibility to ensure proper pairing.
|
|
|
|
Note that a service provider should perform as many consistency checks as
|
|
is practical at the time TSPI_providerInit is called to ensure that it is
|
|
ready to run. Some consistency or installation errors, however, may not be
|
|
detectable until the operation is attempted. The error LINEERR_NODRIVER can
|
|
be used to report such non-specific errors at the time they are detected.
|
|
|
|
There is no directly corresponding function at the TAPI level. At that
|
|
level, multiple different usage instances can be outstanding, with an
|
|
"application handle" returned to identify the instance in subsequent
|
|
operations. At the TSPI level, the interface architecture supports only a
|
|
single usage instance for each distinct service provider.
|
|
|
|
A new parameter, lpdwTSPIOptions, is added to this function. This parameter
|
|
allows the service provider to return bits indicating optional behaviors
|
|
desired of TAPI. TAPI sets the options DWORD to 0 before calling
|
|
TSPI_providerInit, so if the service provider doesn't want any of these
|
|
options, it can just leave the DWORD set to 0.
|
|
|
|
At this time, only one bit is defined to be returned through this pointer:
|
|
LINETSPIOPTION_NONREENTRANT. The service provider sets this bit if it is
|
|
not designed for fully pre-emptive, multithreaded, multitasking,
|
|
multiprocessor operation (e.g., updating of global data protected by
|
|
mutexes). When this bit is set, TAPI will only make one call at a time to
|
|
the service provider; it will not call any other entry point, nor that
|
|
entry point again, until the service provider returns from the original
|
|
function call. Without this bit set, TAPI may call into multiple service
|
|
provider entry points, including multiple times to the same entry point,
|
|
simultaneously (actually simultaneously in a multiprocessor system). Note:
|
|
TAPI will not serialize access to TSPI functions that display a dialog
|
|
(TUISPI_lineConfigDialog, TUISPI_lineConfigDialogEdit,
|
|
TUISPI_phoneConfigDialog, TUISPI_providerConfig, TUISPI_providerInstall,
|
|
TUISPI_providerRemove) so that they do not block other TSPI functions
|
|
from being called; the service provider must include internal protection
|
|
on these functions.
|
|
|
|
Arguments:
|
|
|
|
dwTSPIVersion - Specifies the version of the TSPI definition under which
|
|
this function must operate. The caller may use
|
|
TSPI_lineNegotiateTSPIVersion with the special dwDeviceID
|
|
INITIALIZE_NEGOTIATION to negotiate a version that is guaranteed to be
|
|
acceptible to the service provider.
|
|
|
|
dwPermanentProviderID - Specifies the permanent ID, unique within the
|
|
service providers on this system, of the service provider being
|
|
initialized.
|
|
|
|
dwLineDeviceIDBase - Specifies the lowest device ID for the line devices
|
|
supported by this service provider.
|
|
|
|
dwPhoneDeviceIDBase - Specifies the lowest device ID for the phone devices
|
|
supported by this service provider.
|
|
|
|
dwNumLines - Specifies how many line devices this service provider
|
|
supports.
|
|
|
|
dwNumPhones - Specifies how many line devices this service provider
|
|
supports.
|
|
|
|
pfnCompletionProc - Specifies the procedure the service provider calls to
|
|
report completion of all asynchronously operating procedures on line
|
|
and phone devices.
|
|
|
|
pdwTSPIOptions - A pointer to a DWORD-sized memory location, into which
|
|
the service provider may write a value specifying LINETSPIOPTIONS_
|
|
values.
|
|
|
|
Return Values:
|
|
|
|
Returns zero if the function is successful, or a negative error number if
|
|
an error has occurred. Possible return values are as follows:
|
|
|
|
LINEERR_INCOMPATIBLEAPIVERSION - The application requested an API
|
|
version or version range that is either incompatible or cannot be
|
|
supported by the Telephony API implementation and/or corresponding
|
|
service provider.
|
|
|
|
LINEERR_NOMEM - Unable to allocate or lock memory.
|
|
|
|
LINEERR_OPERATIONFAILED - The specified operation failed for unknown
|
|
reasons.
|
|
|
|
LINEERR_RESOURCEUNAVAIL - Insufficient resources to complete the
|
|
operation.
|
|
|
|
--*/
|
|
|
|
|
|
LONG
|
|
TSPIAPI
|
|
TSPI_providerInit(
|
|
DWORD dwTSPIVersion,
|
|
DWORD dwPermanentProviderID,
|
|
DWORD dwLineDeviceIDBase,
|
|
DWORD dwPhoneDeviceIDBase,
|
|
DWORD_PTR dwNumLines,
|
|
DWORD_PTR dwNumPhones,
|
|
ASYNC_COMPLETION pfnCompletionProc,
|
|
LPDWORD pdwTSPIOptions
|
|
)
|
|
{
|
|
LONG dwStatus;
|
|
|
|
UNREFERENCED_PARAMETER (dwNumLines); // legacy parameter
|
|
UNREFERENCED_PARAMETER (dwNumPhones); // legacy parameter
|
|
UNREFERENCED_PARAMETER (dwPhoneDeviceIDBase); // no phone support
|
|
UNREFERENCED_PARAMETER (pdwTSPIOptions); // already thread-safe
|
|
|
|
#if DBG
|
|
// Register for trace output.
|
|
TRACELogRegister(_T("h323tsp"));
|
|
#else
|
|
OpenLogFile();
|
|
#endif
|
|
|
|
// make sure this is a version we support
|
|
if (!H323ValidateTSPIVersion(dwTSPIVersion))
|
|
{
|
|
H323DBG(( DEBUG_LEVEL_ERROR,
|
|
"provider init::incompatible tspi version." ));
|
|
|
|
// incompatible api version
|
|
return LINEERR_INCOMPATIBLEAPIVERSION;
|
|
}
|
|
|
|
dwStatus = H323Initialize (dwLineDeviceIDBase);
|
|
|
|
if (dwStatus == ERROR_SUCCESS)
|
|
{
|
|
// save global service provider info
|
|
|
|
// we don't store dwTSPIVersion, because our behavior does not change based
|
|
// on any negotiated version.
|
|
// if this changes in the future, then we will record the negotiated version.
|
|
|
|
g_pfnCompletionProc = pfnCompletionProc;
|
|
_ASSERTE( g_pfnCompletionProc );
|
|
|
|
g_dwLineDeviceIDBase = dwLineDeviceIDBase;
|
|
g_dwPermanentProviderID = dwPermanentProviderID;
|
|
}
|
|
else
|
|
{
|
|
H323Shutdown();
|
|
}
|
|
|
|
return dwStatus;
|
|
}
|
|
|
|
|
|
|
|
LONG
|
|
TSPIAPI
|
|
TSPI_providerShutdown(
|
|
DWORD dwTSPIVersion,
|
|
DWORD dwPermanentProviderID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Shuts down the service provider. The service provider should terminate
|
|
any activities it has in progress and release any resources it has
|
|
allocated.
|
|
|
|
Arguments:
|
|
|
|
dwTSPIVersion - Specifies the version of the TSPI definition under which
|
|
this function must operate. The caller may use
|
|
TSPI_lineNegotiateTSPIVersion or TSPI_phoneNegotiateTSPIVersion with
|
|
the special dwDeviceID INITIALIZE_NEGOTIATION to negotiate a version
|
|
that is guaranteed to be acceptible to the service provider.
|
|
|
|
dwPermanentProviderID - Specifies the permanent ID, unique within the
|
|
service providers on this system, of the service provider being
|
|
shut down.
|
|
|
|
Return Values:
|
|
|
|
Returns zero if the function is successful, or a negative error number
|
|
if an error has occurred. Possible return values are as follows:
|
|
|
|
LINEERR_INCOMPATIBLEAPIVERSION - The application requested an API
|
|
version or version range that is either incompatible or cannot be
|
|
supported by the Telephony API implementation and/or corresponding
|
|
service provider.
|
|
|
|
LINEERR_NOMEM - Unable to allocate or lock memory.
|
|
|
|
LINEERR_OPERATIONFAILED - The specified operation failed for unknown
|
|
reasons.
|
|
|
|
--*/
|
|
|
|
{
|
|
UNREFERENCED_PARAMETER(dwPermanentProviderID); // legacy parameter
|
|
|
|
H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_providerShutdown - Entered." ));
|
|
// make sure this is a version we support
|
|
if (!H323ValidateTSPIVersion(dwTSPIVersion))
|
|
{
|
|
H323DBG(( DEBUG_LEVEL_ERROR, "invalid tspi version." ));
|
|
|
|
// failure
|
|
return LINEERR_INCOMPATIBLEAPIVERSION;
|
|
}
|
|
|
|
H323Shutdown();
|
|
|
|
H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_providerShutdown - Exited." ));
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
|
|
|
|
LONG
|
|
TSPIAPI
|
|
TSPI_providerInstall(
|
|
HWND hwndOwner,
|
|
DWORD dwPermanentProviderID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
The TSPI_providerInstall function is obsolete. TAPI version 1.4
|
|
or earlier service providers can implement this TSPI function.
|
|
TAPI version 2.0 or later TSPs implement TUISPI_providerInstall.
|
|
|
|
Arguments:
|
|
|
|
hwndOwner - The handle of the parent window in which the function
|
|
can create any dialog box windows that are required during
|
|
installation.
|
|
|
|
dwPermanentProviderID - The service provider's permanent provider
|
|
identifier.
|
|
|
|
Return Values:
|
|
|
|
Always returns NOERROR.
|
|
|
|
--*/
|
|
|
|
{
|
|
UNREFERENCED_PARAMETER(hwndOwner);
|
|
UNREFERENCED_PARAMETER(dwPermanentProviderID);
|
|
|
|
// success
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
LONG
|
|
TSPIAPI
|
|
TSPI_providerRemove(
|
|
HWND hwndOwner,
|
|
DWORD dwPermanentProviderID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
The TSPI_providerRemove function is obsolete. TAPI version 1.4 or
|
|
earlier service providers can implement this TSPI function. TAPI
|
|
version 2.0 or later TSPs implement TUISPI_providerRemove.
|
|
|
|
Arguments:
|
|
|
|
hwndOwner - The handle of the parent window in which the function
|
|
can create any dialog box windows that are required during
|
|
installation.
|
|
|
|
dwPermanentProviderID - The service provider's permanent provider
|
|
identifier.
|
|
|
|
Return Values:
|
|
|
|
Always returns NOERROR.
|
|
|
|
--*/
|
|
|
|
{
|
|
UNREFERENCED_PARAMETER(hwndOwner);
|
|
UNREFERENCED_PARAMETER(dwPermanentProviderID);
|
|
|
|
H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_lineTSPIProviderRemove - Entered." ));
|
|
|
|
H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_lineTSPIProviderRemove - Exited." ));
|
|
// success
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
LONG
|
|
TSPIAPI
|
|
TSPI_providerUIIdentify(
|
|
LPWSTR pwszUIDLLName
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
The TSPI_providerUIIdentify function extracts from the service
|
|
provider the fully qualified path to load the service provider's
|
|
UI DLL component.
|
|
|
|
Implementation is mandatory if the service provider implements
|
|
any UI DLL functions.
|
|
|
|
Arguments:
|
|
|
|
pwszUIDLLName - Pointer to a block of memory at least MAX_PATH
|
|
in length, into which the service provider must copy a NULL-
|
|
terminated string specifying the fully-qualified path for the
|
|
DLL containing the service provider functions which must execute
|
|
in the process of the calling application.
|
|
|
|
Return Values:
|
|
|
|
Always returns NOERROR.
|
|
|
|
--*/
|
|
|
|
{
|
|
H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_ProviderUIIdentify - Entered." ));
|
|
|
|
// copy name of our dll as ui dll
|
|
lstrcpyW(pwszUIDLLName,H323_UIDLL);
|
|
|
|
H323DBG(( DEBUG_LEVEL_TRACE, "TSPI_ProviderUIIdentify - Exited." ));
|
|
|
|
// success
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Implementation of the TUISPI_providerInstall function is the
|
|
service provider's opportunity to install any additional
|
|
"pieces" of the provider into the right directories (or at
|
|
least verifying that they're there) and set up registry entries
|
|
the provider needs.
|
|
|
|
Arguments:
|
|
|
|
pfnUIDLLCallback - Pointer to a function the UI DLL can call to
|
|
communicate with the service provider DLL to obtain information
|
|
needed to display the dialog box.
|
|
|
|
hwndOwner - The handle of the parent window in which the function
|
|
can create any dialog box windows that are required during
|
|
installation.
|
|
|
|
dwPermanentProviderID - The service provider's permanent provider
|
|
identifier.
|
|
|
|
Return Values:
|
|
|
|
Returns zero if the function is successful, or a negative error number
|
|
if an error has occurred. Possible return values are as follows:
|
|
|
|
LINEERR_NOMEM - Unable to allocate or lock memory.
|
|
|
|
LINEERR_NOMULTIPLEINSTANCE - A telephony service provider which
|
|
does not support multiple instances is listed more than once
|
|
in the [Providers] section in the registry. The application
|
|
|
|
LINEERR_OPERATIONFAILED - The specified operation failed for unknown
|
|
reasons.
|
|
|
|
--*/
|
|
|
|
LONG
|
|
TSPIAPI
|
|
TUISPI_providerInstall(
|
|
TUISPIDLLCALLBACK pfnUIDLLCallback,
|
|
HWND hwndOwner,
|
|
DWORD dwPermanentProviderID
|
|
)
|
|
{
|
|
HKEY hKey;
|
|
HKEY hKeyTSP;
|
|
LONG lStatus;
|
|
LPTSTR pszKey;
|
|
|
|
UNREFERENCED_PARAMETER(pfnUIDLLCallback);
|
|
UNREFERENCED_PARAMETER(hwndOwner);
|
|
UNREFERENCED_PARAMETER(dwPermanentProviderID);
|
|
|
|
H323DBG(( DEBUG_LEVEL_TRACE, "TUISPI_providerInstall - Entered." ));
|
|
|
|
// check for previous instance
|
|
if (H323IsTSPAlreadyInstalled())
|
|
{
|
|
// cannot be installed twice
|
|
return LINEERR_NOMULTIPLEINSTANCE;
|
|
}
|
|
|
|
// set key to h323
|
|
pszKey = H323_REGKEY_ROOT;
|
|
|
|
// attempt to open key
|
|
lStatus = RegOpenKeyEx(
|
|
HKEY_LOCAL_MACHINE,
|
|
pszKey,
|
|
0,
|
|
KEY_READ,
|
|
&hKey
|
|
);
|
|
|
|
// validate status
|
|
if( lStatus == NOERROR )
|
|
{
|
|
H323DBG((DEBUG_LEVEL_TRACE,
|
|
"successfully installed H.323 provider." ));
|
|
|
|
// release handle
|
|
RegCloseKey(hKey);
|
|
|
|
H323DBG(( DEBUG_LEVEL_TRACE, "TUISPI_providerInstall - Exited." ));
|
|
|
|
// success
|
|
return NOERROR;
|
|
}
|
|
|
|
// set key to windows
|
|
pszKey = REGSTR_PATH_WINDOWS_CURRENTVERSION;
|
|
|
|
// attempt to open key
|
|
lStatus = RegOpenKeyEx(
|
|
HKEY_LOCAL_MACHINE,
|
|
pszKey,
|
|
0,
|
|
KEY_WRITE,
|
|
&hKey
|
|
);
|
|
|
|
// validate status
|
|
if( lStatus != NOERROR )
|
|
{
|
|
H323DBG(( DEBUG_LEVEL_ERROR,
|
|
"error 0x%08lx opening windows registry key.", lStatus ));
|
|
|
|
// operation failed
|
|
return LINEERR_OPERATIONFAILED;
|
|
}
|
|
|
|
// attempt to create key
|
|
lStatus = RegCreateKey(
|
|
hKey,
|
|
H323_SUBKEY,
|
|
&hKeyTSP
|
|
);
|
|
|
|
// validate status
|
|
if (lStatus != NOERROR)
|
|
{
|
|
H323DBG(( DEBUG_LEVEL_ERROR,
|
|
"error 0x%08lx creating tsp registry key.", lStatus ));
|
|
|
|
// release handle
|
|
RegCloseKey(hKey);
|
|
|
|
// operation failed
|
|
return LINEERR_OPERATIONFAILED;
|
|
}
|
|
|
|
H323DBG(( DEBUG_LEVEL_TRACE, "successfully installed H.323 provider." ));
|
|
|
|
// release handle
|
|
RegCloseKey(hKeyTSP);
|
|
|
|
// release handle
|
|
RegCloseKey(hKey);
|
|
|
|
H323DBG(( DEBUG_LEVEL_TRACE, "TUISPI_providerInstall - Exited." ));
|
|
// success
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
LONG
|
|
TSPIAPI
|
|
TUISPI_providerRemove(
|
|
TUISPIDLLCALLBACK pfnUIDLLCallback,
|
|
HWND hwndOwner,
|
|
DWORD dwPermanentProviderID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
The TUISPI_providerRemove function asks the user to confirm
|
|
elimination of the service provider.
|
|
|
|
It is the responsibility of the service provider to remove any
|
|
registry entries that the service provider added at addProvider
|
|
time, as well as any other modules and files that are no longer
|
|
needed.
|
|
|
|
Arguments:
|
|
|
|
pfnUIDLLCallback - Pointer to a function the UI DLL can call to
|
|
communicate with the service provider DLL to obtain information
|
|
needed to display the dialog box.
|
|
|
|
hwndOwner - The handle of the parent window in which the function
|
|
can create any dialog box windows that are required during
|
|
removal.
|
|
|
|
dwPermanentProviderID - The service provider's permanent provider
|
|
identifier.
|
|
|
|
Return Values:
|
|
|
|
Returns zero if the function is successful, or a negative error number
|
|
if an error has occurred. Possible return values are as follows:
|
|
|
|
LINEERR_NOMEM - Unable to allocate or lock memory.
|
|
|
|
LINEERR_OPERATIONFAILED - The specified operation failed for unknown
|
|
reasons.
|
|
|
|
--*/
|
|
|
|
{
|
|
HKEY hKey;
|
|
LONG lStatus;
|
|
LPTSTR pszKey;
|
|
|
|
UNREFERENCED_PARAMETER(pfnUIDLLCallback);
|
|
UNREFERENCED_PARAMETER(hwndOwner);
|
|
UNREFERENCED_PARAMETER(dwPermanentProviderID);
|
|
|
|
// set key to h323
|
|
pszKey = H323_REGKEY_ROOT;
|
|
|
|
H323DBG(( DEBUG_LEVEL_FORCE, "TUISPI_providerRemove - Entered." ));
|
|
|
|
// attempt to open key
|
|
lStatus = RegOpenKeyEx(
|
|
HKEY_LOCAL_MACHINE,
|
|
pszKey,
|
|
0,
|
|
KEY_READ,
|
|
&hKey
|
|
);
|
|
|
|
// validate status
|
|
if (lStatus != NOERROR)
|
|
{
|
|
H323DBG ((DEBUG_LEVEL_TRACE, "successfully removed H.323 provider."));
|
|
H323DBG ((DEBUG_LEVEL_TRACE, "TUISPI_providerRemove - Exited."));
|
|
|
|
// success
|
|
return NOERROR;
|
|
}
|
|
|
|
// release handle
|
|
RegCloseKey(hKey);
|
|
|
|
// set key to windows
|
|
pszKey = REGSTR_PATH_WINDOWS_CURRENTVERSION;
|
|
|
|
// attempt to open key
|
|
lStatus = RegOpenKeyEx(
|
|
HKEY_LOCAL_MACHINE,
|
|
pszKey,
|
|
0,
|
|
KEY_WRITE,
|
|
&hKey
|
|
);
|
|
|
|
// validate status
|
|
if (lStatus != NOERROR)
|
|
{
|
|
H323DBG(( DEBUG_LEVEL_ERROR,
|
|
"error 0x%08lx opening windows registry key.", lStatus ));
|
|
|
|
// operation failed
|
|
return LINEERR_OPERATIONFAILED;
|
|
}
|
|
|
|
// attempt to delete key
|
|
lStatus = RegDeleteKey(
|
|
hKey,
|
|
H323_SUBKEY
|
|
);
|
|
|
|
// validate status
|
|
if (lStatus != NOERROR)
|
|
{
|
|
H323DBG(( DEBUG_LEVEL_ERROR,
|
|
"error 0x%08lx deleting tsp registry key.", lStatus ));
|
|
|
|
// release handle
|
|
RegCloseKey(hKey);
|
|
|
|
// operation failed
|
|
return LINEERR_OPERATIONFAILED;
|
|
}
|
|
|
|
H323DBG(( DEBUG_LEVEL_FORCE, "successfully removed H.323 provider." ));
|
|
|
|
// release handle
|
|
RegCloseKey(hKey);
|
|
H323DBG(( DEBUG_LEVEL_TRACE, "TUISPI_providerRemove - Exited." ));
|
|
|
|
// success
|
|
return NOERROR;
|
|
} |