1576 lines
43 KiB
C++
1576 lines
43 KiB
C++
//*********************************************************************
|
|
//* Microsoft Windows **
|
|
//* Copyright(c) Microsoft Corp., 1999 **
|
|
//*********************************************************************
|
|
//
|
|
// tapiloc.CPP - Header for the implementation of CObMain
|
|
//
|
|
// HISTORY:
|
|
//
|
|
// 1/27/99 vyung Created.
|
|
//
|
|
|
|
#include "tapiloc.h"
|
|
#include "appdefs.h"
|
|
#include "dispids.h"
|
|
#include "msobmain.h"
|
|
#include <shlwapi.h>
|
|
#include "resource.h"
|
|
#include <regapix.h>
|
|
|
|
DISPATCHLIST TapiExternalInterface[] =
|
|
{
|
|
{L"IsTAPIConfigured", DISPID_TAPI_INITTAPI },
|
|
{L"get_CountryNameForIndex", DISPID_TAPI_GETCOUNTRYNAME },
|
|
{L"get_CountryIndex", DISPID_TAPI_GETCOUNTRYINDEX },
|
|
{L"set_CountryIndex", DISPID_TAPI_SETCOUNTRYINDEX },
|
|
{L"get_NumOfCountry", DISPID_TAPI_GETNUMOFCOUNTRY },
|
|
{L"get_AreaCode", DISPID_TAPI_GETAREACODE },
|
|
{L"set_AreaCode", DISPID_TAPI_SETAREACODE },
|
|
{L"get_DialOut", DISPID_TAPI_GETDIALOUT },
|
|
{L"set_DialOut", DISPID_TAPI_SETDIALOUT },
|
|
{L"get_PhoneSystem", DISPID_TAPI_GETPHONESYS },
|
|
{L"set_PhoneSystem", DISPID_TAPI_SETPHONESYS },
|
|
{L"get_CallWaiting", DISPID_TAPI_GETCALLWAITING },
|
|
{L"set_CallWaiting", DISPID_TAPI_SETCALLWAITING },
|
|
{L"get_AllCountryName", DISPID_TAPI_GETALLCNTRYNAME },
|
|
{L"IsAreaCodeRequired", DISPID_TAPI_ISACODEREQUIRED },
|
|
{L"get_CountryID", DISPID_TAPI_GETCOUNTRYID },
|
|
{L"IsTapiServiceRunning", DISPID_TAPI_TAPISERVICERUNNING}
|
|
};
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: CompareCntryNameLookUpElements()
|
|
//
|
|
// Synopsis: Function to compare names used by sort
|
|
//
|
|
//+---------------------------------------------------------------------------
|
|
int __cdecl CompareCntryNameLookUpElements(const void *e1, const void *e2)
|
|
{
|
|
LPCNTRYNAMELOOKUPELEMENT pCUE1 = (LPCNTRYNAMELOOKUPELEMENT)e1;
|
|
LPCNTRYNAMELOOKUPELEMENT pCUE2 = (LPCNTRYNAMELOOKUPELEMENT)e2;
|
|
|
|
return CompareStringW(LOCALE_USER_DEFAULT, 0,
|
|
pCUE1->psCountryName, -1,
|
|
pCUE2->psCountryName, -1
|
|
) - 2;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: LineCallback()
|
|
//
|
|
// Synopsis: Call back for TAPI line
|
|
//
|
|
//+---------------------------------------------------------------------------
|
|
void CALLBACK LineCallback(DWORD hDevice,
|
|
DWORD dwMessage,
|
|
DWORD_PTR dwInstance,
|
|
DWORD_PTR dwParam1,
|
|
DWORD_PTR dwParam2,
|
|
DWORD_PTR dwParam3)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
// Function: GetCurrentTapiLocation
|
|
//
|
|
// Synopsis: Open the
|
|
// \HKLM\Software\Microsoft\CurrentVersion\Telephony\Locations\LocationX
|
|
// where X is the id of the current location. The id is stored in
|
|
// HKLM\Software\Microsoft\Windows\CurrentVersion\Telephony\Locations\CurrentID.
|
|
//
|
|
//+---------------------------------------------------------------------------
|
|
HRESULT
|
|
GetCurrentTapiLocation(
|
|
LPWSTR szLocation,
|
|
DWORD cbLocation
|
|
)
|
|
{
|
|
HKEY hkey = NULL;
|
|
HRESULT hr = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
TAPI_PATH_LOCATIONS,
|
|
0,
|
|
KEY_QUERY_VALUE,
|
|
&hkey
|
|
);
|
|
if (ERROR_SUCCESS == hr)
|
|
{
|
|
DWORD dwCurrentId = 0;
|
|
DWORD cbCurrentId = sizeof(DWORD);
|
|
|
|
hr = RegQueryValueEx(hkey, TAPI_CURRENTID, NULL, NULL,
|
|
(LPBYTE) &dwCurrentId, &cbCurrentId);
|
|
if (ERROR_SUCCESS == hr)
|
|
{
|
|
if (0 >= wnsprintf(szLocation, cbLocation - 1, L"%s\\%s%lu",
|
|
TAPI_PATH_LOCATIONS, TAPI_LOCATION, dwCurrentId)
|
|
)
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
|
|
}
|
|
RegCloseKey(hkey);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: SetTapiReg()
|
|
//
|
|
// Synopsis: Set TAPI REG
|
|
//
|
|
//+---------------------------------------------------------------------------
|
|
STDMETHODIMP SetTapiReg(LPCWSTR lpValueName, DWORD dwType, const BYTE* lpByte, DWORD dwSize)
|
|
{
|
|
HKEY hKey = 0;
|
|
// get path to the TAPI
|
|
WCHAR szLocation[MAXIMUM_VALUE_NAME_LENGTH];
|
|
|
|
HRESULT hr = GetCurrentTapiLocation(szLocation, MAXIMUM_VALUE_NAME_LENGTH);
|
|
if (ERROR_SUCCESS == hr)
|
|
{
|
|
hr = RegOpenKey(HKEY_LOCAL_MACHINE, szLocation, &hKey);
|
|
}
|
|
|
|
if (hr != ERROR_SUCCESS)
|
|
return( E_FAIL );
|
|
|
|
hr = RegSetValueEx(hKey, lpValueName, 0, dwType, lpByte, dwSize );
|
|
|
|
RegCloseKey(hKey);
|
|
if (hr != ERROR_SUCCESS)
|
|
return( E_FAIL );
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
STDMETHODIMP GetTapiReg(LPCWSTR lpValueName, DWORD* pdwType, BYTE* lpByte, DWORD* pdwSize)
|
|
{
|
|
HRESULT hr;
|
|
HKEY hKey = 0;
|
|
|
|
// get path to the TAPI
|
|
WCHAR szLocation[MAXIMUM_VALUE_NAME_LENGTH];
|
|
|
|
hr = GetCurrentTapiLocation(szLocation, MAXIMUM_VALUE_NAME_LENGTH);
|
|
if (ERROR_SUCCESS == hr)
|
|
{
|
|
hr = RegOpenKey(HKEY_LOCAL_MACHINE, szLocation, &hKey);
|
|
}
|
|
|
|
if (hr != ERROR_SUCCESS)
|
|
return( E_FAIL );
|
|
|
|
hr = RegQueryValueEx(hKey, lpValueName, 0, pdwType, lpByte, pdwSize );
|
|
|
|
RegCloseKey(hKey);
|
|
if (hr != ERROR_SUCCESS) return( E_FAIL );
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////
|
|
/////// IUnknown implementation
|
|
///////
|
|
///////
|
|
|
|
/////////////////////////////////////////////////////////////
|
|
// CObMain::QueryInterface
|
|
STDMETHODIMP CTapiLocationInfo::QueryInterface(REFIID riid, LPVOID* ppvObj)
|
|
{
|
|
// must set out pointer parameters to NULL
|
|
*ppvObj = NULL;
|
|
|
|
if ( riid == IID_IUnknown)
|
|
{
|
|
AddRef();
|
|
*ppvObj = (IUnknown*)this;
|
|
return ResultFromScode(S_OK);
|
|
}
|
|
|
|
if (riid == IID_IDispatch)
|
|
{
|
|
AddRef();
|
|
*ppvObj = (IDispatch*)this;
|
|
return ResultFromScode(S_OK);
|
|
}
|
|
|
|
// Not a supported interface
|
|
return ResultFromScode(E_NOINTERFACE);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////
|
|
// CTapiLocationInfo::AddRef
|
|
STDMETHODIMP_(ULONG) CTapiLocationInfo::AddRef()
|
|
{
|
|
return ++m_cRef;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////
|
|
// CTapiLocationInfo::Release
|
|
STDMETHODIMP_(ULONG) CTapiLocationInfo::Release()
|
|
{
|
|
return --m_cRef;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////
|
|
/////// IDispatch implementation
|
|
///////
|
|
///////
|
|
|
|
/////////////////////////////////////////////////////////////
|
|
// CTapiLocationInfo::GetTypeInfo
|
|
STDMETHODIMP CTapiLocationInfo::GetTypeInfo(UINT, LCID, ITypeInfo**)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////
|
|
// CTapiLocationInfo::GetTypeInfoCount
|
|
STDMETHODIMP CTapiLocationInfo::GetTypeInfoCount(UINT* pcInfo)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////
|
|
// CTapiLocationInfo::GetIDsOfNames
|
|
STDMETHODIMP CTapiLocationInfo::GetIDsOfNames(REFIID riid,
|
|
OLECHAR** rgszNames,
|
|
UINT cNames,
|
|
LCID lcid,
|
|
DISPID* rgDispId)
|
|
{
|
|
|
|
HRESULT hr = DISP_E_UNKNOWNNAME;
|
|
rgDispId[0] = DISPID_UNKNOWN;
|
|
|
|
for (int iX = 0; iX < sizeof(TapiExternalInterface)/sizeof(DISPATCHLIST); iX ++)
|
|
{
|
|
if(lstrcmp(TapiExternalInterface[iX].szName, rgszNames[0]) == 0)
|
|
{
|
|
rgDispId[0] = TapiExternalInterface[iX].dwDispID;
|
|
hr = NOERROR;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Set the disid's for the parameters
|
|
if (cNames > 1)
|
|
{
|
|
// Set a DISPID for function parameters
|
|
for (UINT i = 1; i < cNames ; i++)
|
|
rgDispId[i] = DISPID_UNKNOWN;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////
|
|
// CTapiLocationInfo::Invoke
|
|
HRESULT CTapiLocationInfo::Invoke
|
|
(
|
|
DISPID dispidMember,
|
|
REFIID riid,
|
|
LCID lcid,
|
|
WORD wFlags,
|
|
DISPPARAMS* pdispparams,
|
|
VARIANT* pvarResult,
|
|
EXCEPINFO* pexcepinfo,
|
|
UINT* puArgErr
|
|
)
|
|
{
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
switch(dispidMember)
|
|
{
|
|
case DISPID_TAPI_INITTAPI:
|
|
{
|
|
|
|
TRACE(L"DISPID_TAPI_INITTAPI\n");
|
|
|
|
BOOL bRet;
|
|
InitTapiInfo(&bRet);
|
|
if(pvarResult)
|
|
{
|
|
VariantInit(pvarResult);
|
|
V_VT(pvarResult) = VT_BOOL;
|
|
pvarResult->boolVal = Bool2VarBool(bRet);
|
|
}
|
|
break;
|
|
}
|
|
case DISPID_TAPI_GETCOUNTRYINDEX:
|
|
{
|
|
|
|
TRACE(L"DISPID_TAPI_GETCOUNTRYINDEX\n");
|
|
|
|
if(pvarResult)
|
|
{
|
|
VariantInit(pvarResult);
|
|
V_VT(pvarResult) = VT_I4;
|
|
|
|
GetlCountryIndex(&(pvarResult->lVal));
|
|
}
|
|
break;
|
|
}
|
|
case DISPID_TAPI_SETCOUNTRYINDEX:
|
|
{
|
|
|
|
TRACE(L"DISPID_TAPI_SETCOUNTRYINDEX\n");
|
|
|
|
if(pdispparams && &pdispparams[0].rgvarg[0])
|
|
{
|
|
SetlCountryIndex(pdispparams[0].rgvarg[0].lVal);
|
|
}
|
|
break;
|
|
}
|
|
case DISPID_TAPI_GETNUMOFCOUNTRY:
|
|
{
|
|
|
|
TRACE(L"DISPID_TAPI_GETNUMOFCOUNTRY\n");
|
|
|
|
if(pvarResult)
|
|
{
|
|
VariantInit(pvarResult);
|
|
V_VT(pvarResult) = VT_I4;
|
|
|
|
GetNumCountries(&(pvarResult->lVal));
|
|
}
|
|
break;
|
|
}
|
|
case DISPID_TAPI_GETCOUNTRYNAME:
|
|
{
|
|
|
|
TRACE(L"DISPID_TAPI_GETCOUNTRYNAME\n");
|
|
|
|
BSTR bstrCountry;
|
|
|
|
if(pdispparams && &pdispparams[0].rgvarg[0])
|
|
{
|
|
GetCountryName(pdispparams[0].rgvarg[0].lVal, &bstrCountry);
|
|
}
|
|
if(pvarResult)
|
|
{
|
|
VariantInit(pvarResult);
|
|
V_VT(pvarResult) = VT_BSTR;
|
|
pvarResult->bstrVal = bstrCountry;
|
|
bstrCountry = NULL;
|
|
}
|
|
break;
|
|
}
|
|
case DISPID_TAPI_GETAREACODE:
|
|
{
|
|
|
|
TRACE(L"DISPID_TAPI_GETAREACODE\n");
|
|
|
|
if(pvarResult)
|
|
{
|
|
VariantInit(pvarResult);
|
|
V_VT(pvarResult) = VT_BSTR;
|
|
GetbstrAreaCode(&(pvarResult->bstrVal));
|
|
}
|
|
|
|
break;
|
|
}
|
|
case DISPID_TAPI_SETAREACODE:
|
|
{
|
|
|
|
TRACE(L"DISPID_TAPI_SETAREACODE\n");
|
|
|
|
if(pdispparams && &pdispparams[0].rgvarg[0])
|
|
{
|
|
PutbstrAreaCode(pdispparams[0].rgvarg[0].bstrVal);
|
|
}
|
|
break;
|
|
}
|
|
case DISPID_TAPI_GETDIALOUT:
|
|
{
|
|
|
|
TRACE(L"DISPID_TAPI_GETDIALOUT\n");
|
|
|
|
if(pvarResult)
|
|
{
|
|
VariantInit(pvarResult);
|
|
V_VT(pvarResult) = VT_BSTR;
|
|
GetOutsideDial(&(pvarResult->bstrVal));
|
|
}
|
|
break;
|
|
}
|
|
case DISPID_TAPI_SETDIALOUT:
|
|
{
|
|
|
|
TRACE(L"DISPID_TAPI_SETDIALOUT\n");
|
|
|
|
if(pdispparams && &pdispparams[0].rgvarg[0])
|
|
{
|
|
PutOutsideDial(pdispparams[0].rgvarg[0].bstrVal);
|
|
}
|
|
break;
|
|
}
|
|
case DISPID_TAPI_GETPHONESYS:
|
|
{
|
|
|
|
TRACE(L"DISPID_TAPI_GETPHONESYS\n");
|
|
|
|
if(pvarResult)
|
|
{
|
|
VariantInit(pvarResult);
|
|
V_VT(pvarResult) = VT_I4;
|
|
GetPhoneSystem(&(pvarResult->lVal));
|
|
}
|
|
break;
|
|
}
|
|
case DISPID_TAPI_SETPHONESYS:
|
|
{
|
|
|
|
TRACE(L"DISPID_TAPI_SETPHONESYS\n");
|
|
|
|
if(pdispparams && &pdispparams[0].rgvarg[0])
|
|
{
|
|
PutPhoneSystem(pdispparams[0].rgvarg[0].lVal);
|
|
}
|
|
break;
|
|
}
|
|
case DISPID_TAPI_GETCALLWAITING:
|
|
{
|
|
|
|
TRACE(L"DISPID_TAPI_GETCALLWAITING\n");
|
|
|
|
if(pvarResult)
|
|
{
|
|
VariantInit(pvarResult);
|
|
V_VT(pvarResult) = VT_BSTR;
|
|
GetCallWaiting(&(pvarResult->bstrVal));
|
|
}
|
|
break;
|
|
}
|
|
case DISPID_TAPI_SETCALLWAITING:
|
|
{
|
|
|
|
TRACE(L"DISPID_TAPI_SETCALLWAITING\n");
|
|
|
|
if(pdispparams && &pdispparams[0].rgvarg[0])
|
|
{
|
|
PutCallWaiting(pdispparams[0].rgvarg[0].bstrVal);
|
|
}
|
|
break;
|
|
}
|
|
case DISPID_TAPI_GETALLCNTRYNAME:
|
|
{
|
|
|
|
TRACE(L"DISPID_TAPI_GETALLCNTRYNAME\n");
|
|
|
|
if(pvarResult)
|
|
{
|
|
VariantInit(pvarResult);
|
|
V_VT(pvarResult) = VT_BSTR;
|
|
GetAllCountryName(&(pvarResult->bstrVal));
|
|
}
|
|
|
|
break;
|
|
}
|
|
case DISPID_TAPI_ISACODEREQUIRED:
|
|
{
|
|
|
|
TRACE(L"DISPID_TAPI_ISACODEREQUIRED\n");
|
|
|
|
if(pdispparams && &pdispparams[0].rgvarg[0] && pvarResult)
|
|
{
|
|
VariantInit(pvarResult);
|
|
V_VT(pvarResult) = VT_BOOL;
|
|
IsAreaCodeRequired(pdispparams[0].rgvarg[0].lVal, (BOOL*)&(pvarResult->boolVal));
|
|
}
|
|
break;
|
|
}
|
|
case DISPID_TAPI_GETCOUNTRYID:
|
|
{
|
|
|
|
TRACE(L"DISPID_TAPI_GETCOUNTRYID");
|
|
|
|
if(pvarResult)
|
|
{
|
|
VariantInit(pvarResult);
|
|
V_VT(pvarResult) = VT_I4;
|
|
pvarResult->lVal = m_dwCountryID;
|
|
TRACE1(L"... %d returned", m_dwCountryID);
|
|
}
|
|
break;
|
|
}
|
|
case DISPID_TAPI_TAPISERVICERUNNING:
|
|
{
|
|
|
|
TRACE(L"DISPID_TAPI_TAPISERVICERUNNING\n");
|
|
|
|
BOOL bRet;
|
|
TapiServiceRunning(&bRet);
|
|
if(pvarResult)
|
|
{
|
|
VariantInit(pvarResult);
|
|
V_VT(pvarResult) = VT_BOOL;
|
|
pvarResult->boolVal = Bool2VarBool(bRet);
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
hr = DISP_E_MEMBERNOTFOUND;
|
|
break;
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CTapiLocationInfo
|
|
CTapiLocationInfo::CTapiLocationInfo()
|
|
{
|
|
m_wNumTapiLocations = 0;
|
|
m_dwComboCountryIndex = 0;
|
|
m_dwCountryID = 0;
|
|
m_dwCurrLoc = 0;
|
|
m_hLineApp = NULL;
|
|
m_pLineCountryList = NULL;
|
|
m_rgNameLookUp = NULL;
|
|
m_pTC = NULL;
|
|
m_bTapiAvailable = FALSE;
|
|
m_szAreaCode [0] = L'\0';
|
|
m_szDialOut [0] = L'\0';
|
|
m_szAllCountryPairs = NULL;
|
|
m_bTapiCountrySet = FALSE;
|
|
m_bCheckModemCountry = FALSE;
|
|
}
|
|
|
|
CTapiLocationInfo::~CTapiLocationInfo()
|
|
{
|
|
//
|
|
// It is possible that the country ID is set but dialing, hence the call
|
|
// to CheckModemCountry, is skipped.
|
|
//
|
|
|
|
CheckModemCountry();
|
|
|
|
if (m_szAllCountryPairs)
|
|
{
|
|
GlobalFree(m_szAllCountryPairs);
|
|
}
|
|
if (m_pLineCountryList)
|
|
{
|
|
GlobalFree(m_pLineCountryList);
|
|
}
|
|
if (m_rgNameLookUp)
|
|
{
|
|
GlobalFree(m_rgNameLookUp);
|
|
}
|
|
if (m_pTC)
|
|
{
|
|
GlobalFree(m_pTC);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
const WCHAR gszInternationalSec[] = L"intl";
|
|
const WCHAR gszCountryEntry[] = L"iCountry";
|
|
|
|
STDMETHODIMP CTapiLocationInfo::InitTapiInfo(BOOL* pbRetVal)
|
|
{
|
|
HRESULT hr = ERROR_SUCCESS;
|
|
DWORD cDevices =0;
|
|
DWORD dwCurDev = 0;
|
|
DWORD dwAPI = 0;
|
|
LONG lrc = 0;
|
|
LINEEXTENSIONID leid;
|
|
LPVOID pv = NULL;
|
|
DWORD dwCurLoc = 0;
|
|
WCHAR szCountryCode[8];
|
|
WCHAR szIniFile[MAX_PATH*2] = SZ_EMPTY;
|
|
|
|
|
|
if (0 != m_dwCountryID)
|
|
{
|
|
// TAPI already initialized, don't do it again.
|
|
*pbRetVal = m_bTapiAvailable;
|
|
goto InitTapiInfoExit;
|
|
}
|
|
|
|
m_hLineApp=NULL;
|
|
// Assume Failure
|
|
*pbRetVal = FALSE;
|
|
if (m_pTC)
|
|
{
|
|
GlobalFree(m_pTC);
|
|
m_pTC = NULL;
|
|
}
|
|
|
|
m_bTapiAvailable = TRUE;
|
|
hr = tapiGetLocationInfo(szCountryCode, m_szAreaCode);
|
|
if (hr)
|
|
{
|
|
HKEY hKey = 0;
|
|
m_bTapiAvailable = FALSE;
|
|
|
|
// GetLocation failed. Normally we show the TAPI mini dialog which
|
|
// has no cancel option, and the user is forced to enter info and hit OK.
|
|
// In OOBE, we have to mimic this dialog in html, so here we will
|
|
// give user country list, and default phone system
|
|
|
|
// This code taken from dial.c in tapi32.dll
|
|
|
|
m_dwCountryID = (DWORD)GetProfileInt( gszInternationalSec,
|
|
gszCountryEntry,
|
|
1 );
|
|
|
|
// create necessary tapi keys
|
|
*pbRetVal = TRUE; // Getting here means everything worked
|
|
HRESULT hr = RegCreateKey(HKEY_LOCAL_MACHINE, TAPI_PATH_LOC0, &hKey);
|
|
if (hr != ERROR_SUCCESS)
|
|
{
|
|
*pbRetVal = FALSE;
|
|
}
|
|
else
|
|
{
|
|
RegSetValueEx(hKey, TAPI_CALLWAIT, 0, REG_SZ, (LPBYTE)NULL_SZ, BYTES_REQUIRED_BY_SZ(NULL_SZ) );
|
|
|
|
HINSTANCE hInst = GetModuleHandle(L"msobmain.dll");
|
|
WCHAR szTapiNewLoc[MAX_PATH];
|
|
LoadString(hInst, IDS_TAPI_NEWLOC, szTapiNewLoc, MAX_CHARS_IN_BUFFER(szTapiNewLoc));
|
|
|
|
RegSetValueEx(hKey, TAPI_NAME, 0, REG_SZ, (LPBYTE)szTapiNewLoc, BYTES_REQUIRED_BY_SZ(szTapiNewLoc) );
|
|
|
|
RegCloseKey(hKey);
|
|
}
|
|
if (ERROR_SUCCESS == RegOpenKey(HKEY_LOCAL_MACHINE, TAPI_PATH_LOCATIONS, &hKey))
|
|
{
|
|
DWORD dwVal;
|
|
|
|
DWORD dwSize = sizeof(dwVal);
|
|
|
|
dwVal = 0;
|
|
|
|
hr = RegSetValueEx(hKey, TAPI_CURRENTID, 0, REG_DWORD, (LPBYTE)&dwVal, sizeof(DWORD));
|
|
|
|
RegQueryValueEx(hKey, TAPI_NUMENTRIES, 0, NULL, (LPBYTE)&dwVal, &dwSize);
|
|
|
|
dwVal++; //bump the entry count up
|
|
|
|
RegSetValueEx(hKey, TAPI_NUMENTRIES, 0, REG_DWORD, (LPBYTE)&dwVal, sizeof(DWORD));
|
|
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
*pbRetVal = FALSE;
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
DWORD dwFlag = REG_DWORD;
|
|
DWORD dwSize = sizeof(dwFlag);
|
|
DWORD dwType = 0;
|
|
|
|
if (S_OK != GetTapiReg(TAPI_COUNTRY, &dwType, (LPBYTE)&dwFlag, &dwSize))
|
|
{
|
|
m_bTapiAvailable = FALSE;
|
|
goto InitTapiInfoExit;
|
|
}
|
|
|
|
// Get CountryID from TAPI
|
|
m_hLineApp = NULL;
|
|
|
|
// Get the handle to the line app
|
|
lineInitialize(&m_hLineApp, NULL, LineCallback, NULL, &cDevices);
|
|
if (!m_hLineApp)
|
|
{
|
|
goto InitTapiInfoExit;
|
|
}
|
|
if (cDevices)
|
|
{
|
|
|
|
// Get the TAPI API version
|
|
//
|
|
dwCurDev = 0;
|
|
dwAPI = 0;
|
|
lrc = -1;
|
|
while (lrc && dwCurDev < cDevices)
|
|
{
|
|
// NOTE: device ID's are 0 based
|
|
ZeroMemory(&leid, sizeof(leid));
|
|
lrc = lineNegotiateAPIVersion(m_hLineApp, dwCurDev,0x00010004,0x00010004,&dwAPI,&leid);
|
|
dwCurDev++;
|
|
}
|
|
if (lrc)
|
|
{
|
|
// TAPI and us can't agree on anything so nevermind...
|
|
goto InitTapiInfoExit;
|
|
}
|
|
|
|
// Find the CountryID in the translate cap structure
|
|
m_pTC = (LINETRANSLATECAPS *)GlobalAlloc(GPTR, sizeof(LINETRANSLATECAPS));
|
|
if (!m_pTC)
|
|
{
|
|
// we are in real trouble here, get out!
|
|
hr = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto InitTapiInfoExit;
|
|
}
|
|
|
|
// Get the needed size
|
|
m_pTC->dwTotalSize = sizeof(LINETRANSLATECAPS);
|
|
lrc = lineGetTranslateCaps(m_hLineApp, dwAPI,m_pTC);
|
|
if(lrc)
|
|
{
|
|
goto InitTapiInfoExit;
|
|
}
|
|
|
|
pv = GlobalAlloc(GPTR, ((size_t)m_pTC->dwNeededSize));
|
|
if (!pv)
|
|
{
|
|
hr = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto InitTapiInfoExit;
|
|
}
|
|
((LINETRANSLATECAPS*)pv)->dwTotalSize = m_pTC->dwNeededSize;
|
|
m_pTC = (LINETRANSLATECAPS*)pv;
|
|
pv = NULL;
|
|
lrc = lineGetTranslateCaps(m_hLineApp, dwAPI,m_pTC);
|
|
if(lrc)
|
|
{
|
|
goto InitTapiInfoExit;
|
|
}
|
|
|
|
// sanity check
|
|
// Assert(m_pTC->dwLocationListOffset);
|
|
|
|
// We have the Number of TAPI locations, so save it now
|
|
m_wNumTapiLocations = (WORD)m_pTC->dwNumLocations;
|
|
|
|
// Loop through the locations to find the correct country code
|
|
m_plle = LPLINELOCATIONENTRY (PBYTE(m_pTC) + m_pTC->dwLocationListOffset);
|
|
for (dwCurLoc = 0; dwCurLoc < m_pTC->dwNumLocations; dwCurLoc++)
|
|
{
|
|
if (m_pTC->dwCurrentLocationID == m_plle->dwPermanentLocationID)
|
|
{
|
|
m_dwCountryID = m_plle->dwCountryID;
|
|
m_dwCurrLoc = dwCurLoc;
|
|
break; // for loop
|
|
}
|
|
m_plle++;
|
|
}
|
|
|
|
// If we could not find it in the above loop, default to US
|
|
if (!m_dwCountryID)
|
|
{
|
|
m_dwCountryID = 1;
|
|
goto InitTapiInfoExit;
|
|
}
|
|
}
|
|
*pbRetVal = TRUE; // Getting here means everything worked
|
|
}
|
|
|
|
// Settings in INI_SETTINGS_FILENAME should initialize or override the
|
|
// system's Tapi configuration.
|
|
|
|
if (GetCanonicalizedPath(szIniFile, INI_SETTINGS_FILENAME))
|
|
{
|
|
|
|
//
|
|
// [Options]
|
|
// Tonepulse = 0 for pulse, 1 for tone
|
|
// Areacode = {string}
|
|
// OutsideLine = {string}
|
|
// DisableCallWaiting = {string}
|
|
//
|
|
|
|
LONG lTonDialing = (BOOL) GetPrivateProfileInt(OPTIONS_SECTION,
|
|
TONEPULSE,
|
|
-1,
|
|
szIniFile);
|
|
if (lTonDialing != -1)
|
|
{
|
|
PutPhoneSystem(lTonDialing);
|
|
}
|
|
|
|
if (GetPrivateProfileString(OPTIONS_SECTION,
|
|
AREACODE,
|
|
L"\0",
|
|
m_szAreaCode,
|
|
MAX_CHARS_IN_BUFFER(m_szAreaCode),
|
|
szIniFile))
|
|
{
|
|
PutbstrAreaCode(SysAllocString(m_szAreaCode));
|
|
}
|
|
|
|
if (GetPrivateProfileString(OPTIONS_SECTION,
|
|
OUTSIDELINE,
|
|
L"\0",
|
|
m_szDialOut,
|
|
MAX_CHARS_IN_BUFFER(m_szDialOut),
|
|
szIniFile))
|
|
{
|
|
PutOutsideDial(SysAllocString(m_szDialOut));
|
|
}
|
|
|
|
if (GetPrivateProfileString(OPTIONS_SECTION,
|
|
DISABLECALLWAITING,
|
|
L"\0",
|
|
m_szCallWaiting,
|
|
MAX_CHARS_IN_BUFFER(m_szCallWaiting),
|
|
szIniFile))
|
|
{
|
|
PutCallWaiting(SysAllocString(m_szCallWaiting));
|
|
}
|
|
}
|
|
|
|
InitTapiInfoExit:
|
|
|
|
// if we can't figure it out because TAPI is messed up just default to
|
|
// the US. The user will still have the chance to pick the right answer.
|
|
if (!m_dwCountryID) {
|
|
m_dwCountryID = 1;
|
|
}
|
|
|
|
if (m_hLineApp)
|
|
{
|
|
lineShutdown(m_hLineApp);
|
|
m_hLineApp = NULL;
|
|
}
|
|
|
|
m_lNumOfCountry = 0;
|
|
GetNumCountries(&m_lNumOfCountry);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
STDMETHODIMP CTapiLocationInfo::GetlCountryIndex(long * plVal)
|
|
{
|
|
*plVal = m_dwComboCountryIndex;
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CTapiLocationInfo::SetlCountryIndex(long lVal)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
// Write to registry
|
|
if (lVal < m_lNumOfCountry && lVal > -1)
|
|
{
|
|
m_bTapiCountrySet = TRUE;
|
|
m_dwCountryID = m_rgNameLookUp[lVal].pLCE->dwCountryID;
|
|
m_dwCountrycode = m_rgNameLookUp[lVal].pLCE->dwCountryCode;
|
|
m_dwComboCountryIndex = lVal;
|
|
hr = SetTapiReg(TAPI_COUNTRY, REG_DWORD, (LPBYTE)&m_rgNameLookUp[lVal].pLCE->dwCountryID, sizeof(DWORD) );
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
m_bCheckModemCountry = TRUE;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CTapiLocationInfo::GetCountryID(DWORD* dwCountryID)
|
|
{
|
|
MYASSERT( m_dwCountryID );
|
|
*dwCountryID = m_dwCountryID;
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CTapiLocationInfo::GetCountryCode(DWORD* dwCountryCode)
|
|
{
|
|
*dwCountryCode = m_dwCountrycode;
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CTapiLocationInfo::GetNumCountries(long *plNumOfCountry)
|
|
{
|
|
USES_CONVERSION;
|
|
|
|
LPLINECOUNTRYLIST pLineCountryTemp = NULL;
|
|
LPLINECOUNTRYENTRY pLCETemp;
|
|
DWORD idx;
|
|
DWORD dwCurLID = 0;
|
|
HINSTANCE hTapi32Dll = NULL;
|
|
FARPROC fp;
|
|
BOOL bBookLoaded = FALSE;
|
|
HRESULT hr = S_OK;
|
|
|
|
if (NULL == plNumOfCountry)
|
|
goto GetNumCountriesExit;
|
|
|
|
// Avoid returning rubbish
|
|
//
|
|
*plNumOfCountry = 0;
|
|
|
|
if (m_lNumOfCountry != 0)
|
|
{
|
|
*plNumOfCountry = m_lNumOfCountry;
|
|
goto GetNumCountriesExit;
|
|
}
|
|
|
|
hTapi32Dll = LoadLibrary(L"tapi32.dll");
|
|
if (hTapi32Dll)
|
|
{
|
|
fp = GetProcAddress(hTapi32Dll, "lineGetCountryW");
|
|
if (!fp)
|
|
{
|
|
hr = GetLastError();
|
|
goto GetNumCountriesExit;
|
|
}
|
|
|
|
|
|
// Get TAPI country list
|
|
if (m_pLineCountryList)
|
|
GlobalFree(m_pLineCountryList);
|
|
|
|
m_pLineCountryList = (LPLINECOUNTRYLIST)GlobalAlloc(GPTR, sizeof(LINECOUNTRYLIST));
|
|
if (!m_pLineCountryList)
|
|
{
|
|
hr = S_FALSE;
|
|
goto GetNumCountriesExit;
|
|
}
|
|
|
|
m_pLineCountryList->dwTotalSize = sizeof(LINECOUNTRYLIST);
|
|
|
|
idx = ((LINEGETCOUNTRY)fp)(0, 0x10003,m_pLineCountryList);
|
|
if (idx && idx != LINEERR_STRUCTURETOOSMALL)
|
|
{
|
|
hr = S_FALSE;
|
|
goto GetNumCountriesExit;
|
|
}
|
|
|
|
// Assert(m_pLineCountryList->dwNeededSize);
|
|
|
|
pLineCountryTemp = (LPLINECOUNTRYLIST)GlobalAlloc(GPTR,
|
|
(size_t)m_pLineCountryList->dwNeededSize);
|
|
if (!pLineCountryTemp)
|
|
{
|
|
hr = S_FALSE;
|
|
goto GetNumCountriesExit;
|
|
}
|
|
|
|
pLineCountryTemp->dwTotalSize = m_pLineCountryList->dwNeededSize;
|
|
GlobalFree(m_pLineCountryList);
|
|
|
|
m_pLineCountryList = pLineCountryTemp;
|
|
pLineCountryTemp = NULL;
|
|
|
|
if (((LINEGETCOUNTRY)fp)(0, 0x10003,m_pLineCountryList))
|
|
{
|
|
hr = S_FALSE;
|
|
goto GetNumCountriesExit;
|
|
}
|
|
|
|
// look up array
|
|
pLCETemp = (LPLINECOUNTRYENTRY)((DWORD_PTR)m_pLineCountryList +
|
|
m_pLineCountryList->dwCountryListOffset);
|
|
|
|
if(m_rgNameLookUp)
|
|
GlobalFree(m_rgNameLookUp);
|
|
|
|
m_rgNameLookUp = (LPCNTRYNAMELOOKUPELEMENT)GlobalAlloc(GPTR,
|
|
(int)(sizeof(CNTRYNAMELOOKUPELEMENT) * m_pLineCountryList->dwNumCountries));
|
|
|
|
if (!m_rgNameLookUp)
|
|
{
|
|
hr = S_FALSE;
|
|
goto GetNumCountriesExit;
|
|
}
|
|
|
|
CNTRYNAMELOOKUPELEMENT CntryNameLUElement = {NULL, 0, NULL};
|
|
CNTRYNAMELOOKUPELEMENT cnleUS = {NULL, 0, NULL};
|
|
DWORD cbAllCountryPairs = 0;
|
|
|
|
for (idx=0;idx<m_pLineCountryList->dwNumCountries;idx++)
|
|
{
|
|
|
|
m_rgNameLookUp[idx].psCountryName = (LPWSTR)((LPBYTE)m_pLineCountryList + (DWORD)pLCETemp[idx].dwCountryNameOffset);
|
|
m_rgNameLookUp[idx].dwNameSize = pLCETemp[idx].dwCountryNameSize;
|
|
m_rgNameLookUp[idx].pLCE = &pLCETemp[idx];
|
|
#if 0
|
|
TRACE2(L"GetNumCountries:%d:%s",
|
|
m_rgNameLookUp[idx].pLCE->dwCountryID,
|
|
m_rgNameLookUp[idx].psCountryName
|
|
);
|
|
#endif
|
|
// Include space for NUL at end of unicode string
|
|
//
|
|
cbAllCountryPairs += m_rgNameLookUp[idx].dwNameSize + 2;
|
|
|
|
// If TAPI is not available, we set the default to US
|
|
if ( m_rgNameLookUp[idx].pLCE->dwCountryID == m_dwCountryID)
|
|
{
|
|
// Set the index to our default country in combo box
|
|
m_dwComboCountryIndex = idx;
|
|
m_dwCountrycode = m_rgNameLookUp[idx].pLCE->dwCountryCode;
|
|
if (m_rgNameLookUp[idx].psCountryName)
|
|
{
|
|
m_bstrDefaultCountry = SysAllocString(m_rgNameLookUp[idx].psCountryName);
|
|
}
|
|
|
|
memcpy(&CntryNameLUElement, &m_rgNameLookUp[idx], sizeof(CNTRYNAMELOOKUPELEMENT));
|
|
}
|
|
else if (m_rgNameLookUp[idx].pLCE->dwCountryID == 1)
|
|
{
|
|
// Save the US info away in case we don't find the default
|
|
memcpy(&cnleUS, &m_rgNameLookUp[idx], sizeof(CNTRYNAMELOOKUPELEMENT));
|
|
}
|
|
}
|
|
|
|
// If we didn't find the default country, we're going to blow up.
|
|
if (CntryNameLUElement.psCountryName == NULL)
|
|
{
|
|
TRACE1(L"Warning: Couldn't find country id %d. Defaulting to US.", m_dwCountryID);
|
|
memcpy(&CntryNameLUElement, &cnleUS, sizeof(CNTRYNAMELOOKUPELEMENT));
|
|
m_dwCountryID = 1;
|
|
}
|
|
MYASSERT( CntryNameLUElement.psCountryName );
|
|
|
|
qsort(m_rgNameLookUp, (int)m_pLineCountryList->dwNumCountries,sizeof(CNTRYNAMELOOKUPELEMENT),
|
|
CompareCntryNameLookUpElements);
|
|
|
|
LPCNTRYNAMELOOKUPELEMENT pResult = (LPCNTRYNAMELOOKUPELEMENT)bsearch(&CntryNameLUElement, m_rgNameLookUp, (int)m_pLineCountryList->dwNumCountries,sizeof(CNTRYNAMELOOKUPELEMENT),
|
|
CompareCntryNameLookUpElements);
|
|
|
|
|
|
m_dwComboCountryIndex = (DWORD)((DWORD_PTR)pResult - (DWORD_PTR)m_rgNameLookUp) / sizeof(CNTRYNAMELOOKUPELEMENT);
|
|
|
|
if (m_dwComboCountryIndex > m_pLineCountryList->dwNumCountries)
|
|
m_dwComboCountryIndex = 0;
|
|
|
|
*plNumOfCountry = m_pLineCountryList->dwNumCountries;
|
|
m_lNumOfCountry = m_pLineCountryList->dwNumCountries;
|
|
|
|
// Create the SELECT tag for the html so it can get all the country names in one shot.
|
|
if (m_szAllCountryPairs)
|
|
GlobalFree(m_szAllCountryPairs);
|
|
|
|
// BUGBUG: Does this calculation account for country name strings??
|
|
cbAllCountryPairs += m_lNumOfCountry * sizeof(szOptionTag) + 1;
|
|
m_szAllCountryPairs = (WCHAR *)GlobalAlloc(GPTR, cbAllCountryPairs );
|
|
if (m_szAllCountryPairs)
|
|
{
|
|
WCHAR szBuffer[MAX_PATH];
|
|
for (idx=0; idx < (DWORD)m_lNumOfCountry; idx++)
|
|
{
|
|
wsprintf(szBuffer, szOptionTag, m_rgNameLookUp[idx].psCountryName);
|
|
lstrcat(m_szAllCountryPairs, szBuffer);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
GetNumCountriesExit:
|
|
if (hTapi32Dll)
|
|
{
|
|
FreeLibrary(hTapi32Dll);
|
|
hTapi32Dll = NULL;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CTapiLocationInfo::GetAllCountryName(BSTR* pbstrAllCountryName)
|
|
{
|
|
if (pbstrAllCountryName == NULL)
|
|
{
|
|
return E_POINTER;
|
|
}
|
|
|
|
// Avoid returning rubbish
|
|
//
|
|
*pbstrAllCountryName = NULL;
|
|
|
|
if (m_lNumOfCountry && pbstrAllCountryName && m_szAllCountryPairs)
|
|
{
|
|
*pbstrAllCountryName = SysAllocString(m_szAllCountryPairs);
|
|
return S_OK;
|
|
}
|
|
return E_FAIL;
|
|
}
|
|
|
|
STDMETHODIMP CTapiLocationInfo::GetCountryName(long lCountryIndex, BSTR* pszCountryName)
|
|
{
|
|
USES_CONVERSION;
|
|
|
|
if (lCountryIndex < m_lNumOfCountry && lCountryIndex >= 0)
|
|
{
|
|
*pszCountryName = SysAllocString(m_rgNameLookUp[lCountryIndex].psCountryName);
|
|
return S_OK;
|
|
}
|
|
return E_FAIL;
|
|
}
|
|
|
|
STDMETHODIMP CTapiLocationInfo::GetDefaultCountry(long* lCountryIndex)
|
|
{
|
|
if (lCountryIndex)
|
|
*lCountryIndex = m_dwComboCountryIndex;
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CTapiLocationInfo::PutCountry(long lCountryIndex)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDMETHODIMP CTapiLocationInfo::GetbstrAreaCode(BSTR * pbstrAreaCode)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DWORD dwType = REG_SZ;
|
|
DWORD dwSize = sizeof(m_szAreaCode);
|
|
BSTR bstrTmp = NULL;
|
|
|
|
if (pbstrAreaCode == NULL)
|
|
{
|
|
hr = E_POINTER;
|
|
goto GetbstrAreaCodeExit;
|
|
}
|
|
|
|
// Avoid returning rubbish
|
|
//
|
|
*pbstrAreaCode = NULL;
|
|
|
|
// Allocate default return value
|
|
//
|
|
hr = GetTapiReg(TAPI_AREACODE, &dwType, (LPBYTE)m_szAreaCode, &dwSize);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
bstrTmp = SysAllocString(m_szAreaCode);
|
|
}
|
|
else
|
|
{
|
|
bstrTmp = SysAllocString(SZ_EMPTY);
|
|
}
|
|
|
|
// A valid string can be returned (though it may be empty) so we've
|
|
// succeeded.
|
|
//
|
|
hr = S_OK;
|
|
|
|
GetbstrAreaCodeExit:
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
*pbstrAreaCode = bstrTmp;
|
|
bstrTmp = NULL;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CTapiLocationInfo::PutbstrAreaCode(BSTR bstrAreaCode)
|
|
{
|
|
LPWSTR szAreaCode = (NULL != bstrAreaCode) ? bstrAreaCode : SZ_EMPTY;
|
|
|
|
DWORD dwSize = BYTES_REQUIRED_BY_SZ(szAreaCode);
|
|
SetTapiReg(TAPI_AREACODE, REG_SZ, (LPBYTE)szAreaCode, dwSize);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CTapiLocationInfo::IsAreaCodeRequired(long lVal, BOOL *pbVal)
|
|
{
|
|
LPWSTR szAreaCodeRule = NULL;
|
|
LPWSTR szLongDistanceRule = NULL;
|
|
if (!pbVal)
|
|
return E_POINTER;
|
|
|
|
*pbVal = FALSE;
|
|
|
|
if (lVal < m_lNumOfCountry && lVal > -1 && m_pLineCountryList)
|
|
{
|
|
szAreaCodeRule = (LPWSTR)m_pLineCountryList + m_rgNameLookUp[lVal].pLCE->dwSameAreaRuleOffset;
|
|
szLongDistanceRule = (LPWSTR)m_pLineCountryList + m_rgNameLookUp[lVal].pLCE->dwLongDistanceRuleOffset;
|
|
if (szAreaCodeRule && szLongDistanceRule)
|
|
{
|
|
*pbVal = (NULL != StrChr(szAreaCodeRule, L'F')) || (NULL != StrChr(szLongDistanceRule, 'F'));
|
|
}
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CTapiLocationInfo::GetOutsideDial(BSTR * pbstrOutside)
|
|
{
|
|
DWORD dwType = REG_SZ;
|
|
DWORD dwSize = sizeof(m_szDialOut);
|
|
HRESULT hr = S_OK;
|
|
BSTR bstrTmp = NULL;
|
|
|
|
if (pbstrOutside == NULL)
|
|
{
|
|
hr = E_POINTER;
|
|
goto GetOutsideDialExit;
|
|
}
|
|
|
|
// Avoid returning rubbish in case of error
|
|
//
|
|
*pbstrOutside = NULL;
|
|
|
|
// Allocate empty string for default return string
|
|
//
|
|
bstrTmp = SysAllocString(SZ_EMPTY);
|
|
if (NULL == bstrTmp)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto GetOutsideDialExit;
|
|
}
|
|
|
|
|
|
hr = GetTapiReg(TAPI_OUTSIDE, &dwType, (LPBYTE)m_szDialOut, &dwSize);
|
|
if FAILED(hr)
|
|
{
|
|
goto GetOutsideDialExit;
|
|
}
|
|
|
|
if (! SysReAllocString(&bstrTmp, m_szDialOut))
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto GetOutsideDialExit;
|
|
}
|
|
|
|
|
|
GetOutsideDialExit:
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
*pbstrOutside = bstrTmp;
|
|
}
|
|
else
|
|
{
|
|
if (NULL != bstrTmp)
|
|
{
|
|
SysFreeString(bstrTmp);
|
|
}
|
|
}
|
|
bstrTmp = NULL;
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CTapiLocationInfo::PutOutsideDial(BSTR bstrOutside)
|
|
{
|
|
// Is the bstr null-terminated??
|
|
assert(lstrlen(bstrOutside) <= SysStringLen(bstrOutside));
|
|
|
|
// If no string is passed in, default to empty string
|
|
//
|
|
lstrcpyn(
|
|
m_szDialOut,
|
|
(NULL != bstrOutside) ? bstrOutside : SZ_EMPTY,
|
|
MAX_CHARS_IN_BUFFER(m_szDialOut));
|
|
|
|
DWORD dwSize = BYTES_REQUIRED_BY_SZ(m_szDialOut);
|
|
|
|
HRESULT hr = SetTapiReg(TAPI_OUTSIDE, REG_SZ, (LPBYTE)m_szDialOut, dwSize);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = SetTapiReg(TAPI_LONGDIST, REG_SZ, (LPBYTE)m_szDialOut, dwSize);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CTapiLocationInfo::GetPhoneSystem(long* plTone)
|
|
{
|
|
DWORD dwFlag = REG_DWORD;
|
|
DWORD dwSize = sizeof(dwFlag);
|
|
DWORD dwType = 0;
|
|
|
|
if (NULL == plTone)
|
|
return E_FAIL;
|
|
*plTone = 1;
|
|
|
|
if (S_OK == GetTapiReg(TAPI_FLAG, &dwType, (LPBYTE)&dwFlag, &dwSize))
|
|
{
|
|
*plTone = dwFlag & 0x01;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CTapiLocationInfo::PutPhoneSystem(long lTone)
|
|
{
|
|
DWORD dwFlag = REG_DWORD;
|
|
DWORD dwSize = sizeof(dwFlag);
|
|
DWORD dwType = 0;
|
|
|
|
if (S_OK != GetTapiReg(TAPI_FLAG, &dwType, (LPBYTE)&dwFlag, &dwSize))
|
|
{
|
|
dwFlag = 0;
|
|
}
|
|
|
|
if (lTone)
|
|
dwFlag |= 0x01;
|
|
else
|
|
dwFlag &= (~0x01);
|
|
|
|
return SetTapiReg(TAPI_FLAG, REG_DWORD, (LPBYTE)&dwFlag, sizeof(DWORD) );
|
|
}
|
|
|
|
STDMETHODIMP CTapiLocationInfo::GetCallWaiting(BSTR* pbstrCallWaiting)
|
|
{
|
|
DWORD dwFlag = 0;
|
|
DWORD dwSize = sizeof(dwFlag);
|
|
DWORD dwType = REG_DWORD;
|
|
HRESULT hr = S_OK;
|
|
BSTR bstrTmp = NULL;
|
|
|
|
|
|
if (NULL == pbstrCallWaiting)
|
|
{
|
|
hr = E_POINTER;
|
|
goto GetCallWaitingExit;
|
|
}
|
|
|
|
// Avoid returning rubbish in case of error
|
|
//
|
|
*pbstrCallWaiting = NULL;
|
|
|
|
// Allocate empty string for default return string
|
|
//
|
|
bstrTmp = SysAllocString(SZ_EMPTY);
|
|
if (NULL == bstrTmp)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto GetCallWaitingExit;
|
|
}
|
|
|
|
if (S_OK == GetTapiReg(TAPI_FLAG, &dwType, (LPBYTE)&dwFlag, &dwSize))
|
|
{
|
|
// If call waiting is not enabled, return default string
|
|
if (!(dwFlag & 0x04))
|
|
{
|
|
goto GetCallWaitingExit;
|
|
}
|
|
}
|
|
|
|
dwType = REG_SZ;
|
|
dwSize = sizeof(m_szCallWaiting);
|
|
|
|
hr = GetTapiReg(TAPI_CALLWAIT, &dwType, (LPBYTE)m_szCallWaiting, &dwSize);
|
|
if (FAILED(hr))
|
|
{
|
|
goto GetCallWaitingExit;
|
|
}
|
|
|
|
// Replace the default string with the retrieved string
|
|
//
|
|
if (! SysReAllocString(&bstrTmp, m_szCallWaiting))
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto GetCallWaitingExit;
|
|
}
|
|
|
|
GetCallWaitingExit:
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
*pbstrCallWaiting = bstrTmp;
|
|
bstrTmp = NULL;
|
|
}
|
|
else
|
|
{
|
|
if (NULL != bstrTmp)
|
|
{
|
|
SysFreeString(bstrTmp);
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CTapiLocationInfo::PutCallWaiting(BSTR bstrCallWaiting)
|
|
{
|
|
DWORD dwFlag = 0;
|
|
DWORD dwSize = sizeof(dwFlag);
|
|
DWORD dwType = REG_DWORD;
|
|
HRESULT hr = S_OK;
|
|
|
|
// Is the BSTR null-terminated?
|
|
assert(lstrlen(bstrCallWaiting) <= SysStringLen(bstrCallWaiting));
|
|
|
|
if (bstrCallWaiting == NULL || SysStringLen(bstrCallWaiting) == 0)
|
|
{
|
|
if (S_OK == GetTapiReg(TAPI_FLAG, &dwType, (LPBYTE)&dwFlag, &dwSize))
|
|
{
|
|
dwFlag &= (~0x04);
|
|
hr = SetTapiReg(TAPI_FLAG, REG_DWORD, (LPBYTE)&dwFlag, sizeof(DWORD) );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (S_OK == GetTapiReg(TAPI_FLAG, &dwType, (LPBYTE)&dwFlag, &dwSize))
|
|
{
|
|
dwFlag |= 0x04;
|
|
}
|
|
else
|
|
{
|
|
// Value doesn't exist yet
|
|
//
|
|
dwFlag = (DWORD)0x04;
|
|
}
|
|
|
|
dwSize = BYTES_REQUIRED_BY_SZ(bstrCallWaiting);
|
|
hr = SetTapiReg(TAPI_CALLWAIT, REG_SZ, (LPBYTE)bstrCallWaiting, dwSize);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = SetTapiReg(TAPI_FLAG, REG_DWORD, (LPBYTE)&dwFlag, sizeof(DWORD) );
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
void CTapiLocationInfo::DeleteTapiInfo()
|
|
{
|
|
HKEY hKey;
|
|
DWORD dwRun = 0;
|
|
|
|
if (!m_bTapiCountrySet && !m_bTapiAvailable)
|
|
{
|
|
|
|
// We need to remove the tapi data.
|
|
//
|
|
RegDeleteKey(HKEY_LOCAL_MACHINE, TAPI_PATH_LOC0);
|
|
|
|
if ( RegOpenKeyEx(HKEY_LOCAL_MACHINE, TAPI_PATH_LOCATIONS, 0, KEY_ALL_ACCESS, &hKey) == ERROR_SUCCESS )
|
|
{
|
|
RegDeleteValue(hKey, TAPI_NUMENTRIES);
|
|
RegDeleteValue(hKey, TAPI_CURRENTID);
|
|
RegDeleteValue(hKey, TAPI_NEXTID);
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
// Now pretend that we didn't create these entries so we don't clean up twice
|
|
// (2nd instance case)
|
|
m_bTapiCountrySet = TRUE;
|
|
}
|
|
|
|
}
|
|
|
|
STDMETHODIMP CTapiLocationInfo::TapiServiceRunning(BOOL *pbRet)
|
|
{
|
|
SC_HANDLE sc_handle;
|
|
SC_HANDLE sc_service;
|
|
SERVICE_STATUS service_status;
|
|
|
|
TRACE(L"TapiServiceRunning");
|
|
*pbRet = FALSE;
|
|
sc_handle = OpenSCManager(NULL, SERVICES_ACTIVE_DATABASE, SC_MANAGER_CONNECT);
|
|
if (sc_handle)
|
|
{
|
|
TRACE(L"OpenSCManager succeeded");
|
|
sc_service = OpenService(sc_handle, TEXT("TAPISRV"), SERVICE_QUERY_STATUS);
|
|
if (sc_service)
|
|
{
|
|
TRACE(L"OpenService succeeded");
|
|
if (QueryServiceStatus(sc_service, &service_status ))
|
|
{
|
|
*pbRet = (service_status.dwCurrentState == SERVICE_RUNNING);
|
|
}
|
|
else
|
|
{
|
|
TRACE1(L"QueryServiceStatus failed with %lx", GetLastError());
|
|
}
|
|
CloseServiceHandle(sc_service);
|
|
}
|
|
else
|
|
{
|
|
TRACE1(L"OpenService failed. GetLastError()=%lx",GetLastError());
|
|
|
|
}
|
|
CloseServiceHandle(sc_handle);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
void CTapiLocationInfo::CheckModemCountry()
|
|
|
|
/*++
|
|
|
|
Routine description:
|
|
|
|
This is soft modem workaround provided by unimodem team. It should be called
|
|
before dialing when the TAPI country code is changed in OOBE. Also, it
|
|
should be called during OEM install only, as GUI mode setup handles TAPI
|
|
configuration for upgrade and clean install.
|
|
|
|
The problem we have is that:
|
|
1. Some vendors set the GCI code incorrectly based on the TAPI location
|
|
key (which is a bad thing L)
|
|
2. Some modems do not conform to GCI
|
|
3. Some modems do not correctly accept AT+GCI commands.
|
|
(+GCI is Modems AT commands for setting country)
|
|
|
|
The conformance check ensures the GCI value is properly sync
|
|
with the TAPI location. It disables GCI if the modem does not conform
|
|
to the GCI spec.
|
|
|
|
Note:
|
|
|
|
This function can take as long as 15 seconds. We should make sure the UI
|
|
doesn't appear to hang during the call.
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
typedef void (*COUNTRYRUNONCE)();
|
|
|
|
if (m_bCheckModemCountry)
|
|
{
|
|
TCHAR szIniFile[MAX_PATH];
|
|
|
|
if (GetCanonicalizedPath(szIniFile, INI_SETTINGS_FILENAME))
|
|
{
|
|
UINT bCheckModem = GetPrivateProfileInt(
|
|
OPTIONS_SECTION,
|
|
CHECK_MODEMGCI,
|
|
0,
|
|
szIniFile);
|
|
|
|
if (bCheckModem)
|
|
{
|
|
HMODULE hLib;
|
|
|
|
hLib=LoadLibrary(TEXT("modemui.dll"));
|
|
|
|
if (hLib != NULL)
|
|
{
|
|
|
|
COUNTRYRUNONCE Proc;
|
|
|
|
Proc=(COUNTRYRUNONCE)GetProcAddress(hLib,"CountryRunOnce");
|
|
|
|
if (Proc != NULL)
|
|
{
|
|
TRACE(L"Start modemui!CountryRunOnce");
|
|
Proc();
|
|
TRACE(L"End modemui!CountryRunOnce");
|
|
}
|
|
|
|
FreeLibrary(hLib);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
m_bCheckModemCountry = FALSE;
|
|
|
|
}
|
|
|
|
}
|