1604 lines
58 KiB
C
1604 lines
58 KiB
C
/*
|
|
* TAPI32 line services
|
|
*
|
|
* Copyright 1999 Andreas Mohr
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <stdarg.h>
|
|
#include <stdio.h>
|
|
#include "windef.h"
|
|
#include "winbase.h"
|
|
#include "winternl.h"
|
|
#include "wingdi.h"
|
|
#include "winreg.h"
|
|
#include "winnls.h"
|
|
#include "winerror.h"
|
|
#include "objbase.h"
|
|
#include "tapi.h"
|
|
#include "wine/debug.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(tapi);
|
|
|
|
/* registry keys */
|
|
static const char szCountrylistKey[] =
|
|
"Software\\Microsoft\\Windows\\CurrentVersion\\Telephony\\Country List";
|
|
static const char szLocationsKey[] =
|
|
"Software\\Microsoft\\Windows\\CurrentVersion\\Telephony\\Locations";
|
|
static const char szCardsKey[] =
|
|
"Software\\Microsoft\\Windows\\CurrentVersion\\Telephony\\Cards";
|
|
|
|
|
|
/***********************************************************************
|
|
* lineAccept (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineAccept(HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
|
|
{
|
|
FIXME("(%p, %s, %d): stub.\n", hCall, lpsUserUserInfo, dwSize);
|
|
return 1;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineAddProviderA (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineAddProviderA(LPCSTR lpszProviderName, HWND hwndOwner, LPDWORD lpdwPermanentProviderID)
|
|
{
|
|
FIXME("(%s, %p, %p): stub.\n", lpszProviderName, hwndOwner, lpdwPermanentProviderID);
|
|
return LINEERR_OPERATIONFAILED;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineAddProviderW (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineAddProviderW(LPCWSTR lpszProviderName, HWND hwndOwner, LPDWORD lpdwPermanentProviderID)
|
|
{
|
|
FIXME("(%s, %p, %p): stub.\n", wine_dbgstr_w(lpszProviderName), hwndOwner, lpdwPermanentProviderID);
|
|
return LINEERR_OPERATIONFAILED;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineAddToConference (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineAddToConference(HCALL hConfCall, HCALL hConsultCall)
|
|
{
|
|
FIXME("(%p, %p): stub.\n", hConfCall, hConsultCall);
|
|
return 1;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineAnswer (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineAnswer(HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
|
|
{
|
|
FIXME("(%p, %s, %d): stub.\n", hCall, lpsUserUserInfo, dwSize);
|
|
return 1;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineBlindTransfer (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineBlindTransferA(HCALL hCall, LPCSTR lpszDestAddress, DWORD dwCountryCode)
|
|
{
|
|
FIXME("(%p, %s, %08x): stub.\n", hCall, lpszDestAddress, dwCountryCode);
|
|
return 1;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineClose (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineClose(HLINE hLine)
|
|
{
|
|
FIXME("(%p): stub.\n", hLine);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineCompleteCall (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineCompleteCall(HCALL hCall, LPDWORD lpdwCompletionID, DWORD dwCompletionMode, DWORD dwMessageID)
|
|
{
|
|
FIXME("(%p, %p, %08x, %08x): stub.\n", hCall, lpdwCompletionID, dwCompletionMode, dwMessageID);
|
|
return 1;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineCompleteTransfer (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineCompleteTransfer(HCALL hCall, HCALL hConsultCall, LPHCALL lphConfCall, DWORD dwTransferMode)
|
|
{
|
|
FIXME("(%p, %p, %p, %08x): stub.\n", hCall, hConsultCall, lphConfCall, dwTransferMode);
|
|
return 1;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineConfigDialog (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineConfigDialogA(DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass)
|
|
{
|
|
FIXME("(%08x, %p, %s): stub.\n", dwDeviceID, hwndOwner, lpszDeviceClass);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineConfigDialogW (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineConfigDialogW(DWORD dwDeviceID, HWND hwndOwner, LPCWSTR lpszDeviceClass)
|
|
{
|
|
FIXME("(%08x, %p, %s): stub.\n", dwDeviceID, hwndOwner, debugstr_w(lpszDeviceClass));
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineConfigDialogEdit (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineConfigDialogEditA(DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass, LPVOID const lpDeviceConfigIn, DWORD dwSize, LPVARSTRING lpDeviceConfigOut)
|
|
{
|
|
FIXME("stub.\n");
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineConfigProvider (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineConfigProvider(HWND hwndOwner, DWORD dwPermanentProviderID)
|
|
{
|
|
FIXME("(%p, %08x): stub.\n", hwndOwner, dwPermanentProviderID);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineDeallocateCall (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineDeallocateCall(HCALL hCall)
|
|
{
|
|
FIXME("(%p): stub.\n", hCall);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineDevSpecific (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineDevSpecific(HLINE hLine, DWORD dwAddressId, HCALL hCall, LPVOID lpParams, DWORD dwSize)
|
|
{
|
|
FIXME("(%p, %08x, %p, %p, %d): stub.\n", hLine, dwAddressId, hCall, lpParams, dwSize);
|
|
return 1;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineDevSpecificFeature (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineDevSpecificFeature(HLINE hLine, DWORD dwFeature, LPVOID lpParams, DWORD dwSize)
|
|
{
|
|
FIXME("(%p, %08x, %p, %d): stub.\n", hLine, dwFeature, lpParams, dwSize);
|
|
return 1;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineDial (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineDialA(HCALL hCall, LPCSTR lpszDestAddress, DWORD dwCountryCode)
|
|
{
|
|
FIXME("(%p, %s, %08x): stub.\n", hCall, lpszDestAddress, dwCountryCode);
|
|
return 1;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineDialW (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineDialW(HCALL hCall, LPCWSTR lpszDestAddress, DWORD dwCountryCode)
|
|
{
|
|
FIXME("(%p, %s, %08x): stub.\n", hCall, debugstr_w(lpszDestAddress), dwCountryCode);
|
|
return 1;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineDrop (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineDrop(HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
|
|
{
|
|
FIXME("(%p, %s, %08x): stub.\n", hCall, lpsUserUserInfo, dwSize);
|
|
return 1;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineForward (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineForwardA(HLINE hLine, DWORD bAllAddress, DWORD dwAddressID, LPLINEFORWARDLIST lpForwardList, DWORD dwNumRingsNoAnswer, LPHCALL lphConsultCall, LPLINECALLPARAMS lpCallParams)
|
|
{
|
|
FIXME("stub.\n");
|
|
return 1;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineGatherDigits (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineGatherDigitsA(HCALL hCall, DWORD dwDigitModes, LPSTR lpsDigits, DWORD dwNumDigits, LPCSTR lpszTerminationDigits, DWORD dwFirstDigitTimeout, DWORD dwInterDigitTimeout)
|
|
{
|
|
FIXME("stub.\n");
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineGenerateDigits (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineGenerateDigitsA(HCALL hCall, DWORD dwDigitModes, LPCSTR lpszDigits, DWORD dwDuration)
|
|
{
|
|
FIXME("(%p, %08x, %s, %d): stub.\n", hCall, dwDigitModes, lpszDigits, dwDuration);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineGenerateTone (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineGenerateTone(HCALL hCall, DWORD dwToneMode, DWORD dwDuration, DWORD dwNumTones, LPLINEGENERATETONE lpTones)
|
|
{
|
|
FIXME("(%p, %08x, %d, %d, %p): stub.\n", hCall, dwToneMode, dwDuration, dwNumTones, lpTones);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineGetAddressCaps (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineGetAddressCapsA(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAddressID, DWORD dwAPIVersion, DWORD dwExtVersion, LPLINEADDRESSCAPS lpAddressCaps)
|
|
{
|
|
FIXME("(%p, %08x, %08x, %08x, %08x, %p): stub.\n", hLineApp, dwDeviceID, dwAddressID, dwAPIVersion, dwExtVersion, lpAddressCaps);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineGetAddressID (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineGetAddressIDA(HLINE hLine, LPDWORD lpdwAddressID, DWORD dwAddressMode, LPCSTR lpsAddress, DWORD dwSize)
|
|
{
|
|
FIXME("%p, %p, %08x, %s, %d): stub.\n", hLine, lpdwAddressID, dwAddressMode, lpsAddress, dwSize);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineGetAddressStatus (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineGetAddressStatusA(HLINE hLine, DWORD dwAddressID, LPLINEADDRESSSTATUS lpAddressStatus)
|
|
{
|
|
FIXME("(%p, %08x, %p): stub.\n", hLine, dwAddressID, lpAddressStatus);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineGetAppPriority (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineGetAppPriorityA(LPCSTR lpszAppFilename, DWORD dwMediaMode, LPLINEEXTENSIONID const lpExtensionID, DWORD dwRequestMode, LPVARSTRING lpExtensionName, LPDWORD lpdwPriority)
|
|
{
|
|
FIXME("(%s, %08x, %p, %08x, %p, %p): stub.\n", lpszAppFilename, dwMediaMode, lpExtensionID, dwRequestMode, lpExtensionName, lpdwPriority);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineGetCallInfo (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineGetCallInfoA(HCALL hCall, LPLINECALLINFO lpCallInfo)
|
|
{
|
|
FIXME("(%p, %p): stub.\n", hCall, lpCallInfo);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineGetCallStatus (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineGetCallStatus(HCALL hCall, LPLINECALLSTATUS lpCallStatus)
|
|
{
|
|
FIXME("(%p, %p): stub.\n", hCall, lpCallStatus);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineGetConfRelatedCalls (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineGetConfRelatedCalls(HCALL hCall, LPLINECALLLIST lpCallList)
|
|
{
|
|
FIXME("(%p, %p): stub.\n", hCall, lpCallList);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineGetCountryA (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineGetCountryA(DWORD dwCountryID, DWORD dwAPIVersion, LPLINECOUNTRYLIST lpLineCountryList)
|
|
{
|
|
DWORD dwAvailSize, dwOffset, i, num_countries, max_subkey_len;
|
|
LPLINECOUNTRYENTRY lpLCE;
|
|
HKEY hkey;
|
|
char *subkey_name;
|
|
|
|
if(!lpLineCountryList) {
|
|
TRACE("(%08x, %08x, %p): stub. Returning LINEERR_INVALPOINTER\n",
|
|
dwCountryID, dwAPIVersion, lpLineCountryList);
|
|
return LINEERR_INVALPOINTER;
|
|
}
|
|
|
|
TRACE("(%08x, %08x, %p(%d)): stub.\n",
|
|
dwCountryID, dwAPIVersion, lpLineCountryList,
|
|
lpLineCountryList->dwTotalSize);
|
|
|
|
if(RegOpenKeyA(HKEY_LOCAL_MACHINE, szCountrylistKey, &hkey)
|
|
!= ERROR_SUCCESS)
|
|
return LINEERR_INIFILECORRUPT;
|
|
|
|
|
|
dwAvailSize = lpLineCountryList->dwTotalSize;
|
|
dwOffset = sizeof (LINECOUNTRYLIST);
|
|
|
|
if(dwAvailSize<dwOffset)
|
|
return LINEERR_STRUCTURETOOSMALL;
|
|
|
|
memset(lpLineCountryList, 0, dwAvailSize);
|
|
|
|
lpLineCountryList->dwTotalSize = dwAvailSize;
|
|
lpLineCountryList->dwUsedSize = dwOffset;
|
|
lpLineCountryList->dwNumCountries = 0;
|
|
lpLineCountryList->dwCountryListSize = 0;
|
|
lpLineCountryList->dwCountryListOffset = dwOffset;
|
|
|
|
lpLCE = (LPLINECOUNTRYENTRY)(&lpLineCountryList[1]);
|
|
|
|
if(RegQueryInfoKeyA(hkey, NULL, NULL, NULL, &num_countries, &max_subkey_len,
|
|
NULL, NULL, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) {
|
|
RegCloseKey(hkey);
|
|
return LINEERR_STRUCTURETOOSMALL;
|
|
}
|
|
|
|
if(dwCountryID)
|
|
dwOffset = sizeof (LINECOUNTRYENTRY);
|
|
else
|
|
dwOffset += num_countries * sizeof (LINECOUNTRYENTRY);
|
|
|
|
max_subkey_len++;
|
|
subkey_name = HeapAlloc(GetProcessHeap(), 0, max_subkey_len);
|
|
for(i = 0; i < num_countries; i++)
|
|
{
|
|
DWORD len, size, size_int, size_long, size_name, size_same;
|
|
HKEY hsubkey;
|
|
|
|
if(RegEnumKeyA(hkey, i, subkey_name, max_subkey_len) !=
|
|
ERROR_SUCCESS)
|
|
continue;
|
|
|
|
if(dwCountryID && (atoi(subkey_name) != dwCountryID))
|
|
continue;
|
|
|
|
if(RegOpenKeyA(hkey, subkey_name, &hsubkey) != ERROR_SUCCESS)
|
|
continue;
|
|
|
|
RegQueryValueExA(hsubkey, "InternationalRule", NULL, NULL,
|
|
NULL, &size_int);
|
|
len = size_int;
|
|
|
|
RegQueryValueExA(hsubkey, "LongDistanceRule", NULL, NULL,
|
|
NULL, &size_long);
|
|
len += size_long;
|
|
|
|
RegQueryValueExA(hsubkey, "Name", NULL, NULL,
|
|
NULL, &size_name);
|
|
len += size_name;
|
|
|
|
RegQueryValueExA(hsubkey, "SameAreaRule", NULL, NULL,
|
|
NULL, &size_same);
|
|
len += size_same;
|
|
|
|
if(dwAvailSize < (dwOffset+len))
|
|
{
|
|
dwOffset += len;
|
|
RegCloseKey(hsubkey);
|
|
if(dwCountryID)
|
|
break;
|
|
continue;
|
|
}
|
|
|
|
lpLineCountryList->dwNumCountries++;
|
|
lpLineCountryList->dwCountryListSize += sizeof (LINECOUNTRYENTRY);
|
|
lpLineCountryList->dwUsedSize += len + sizeof (LINECOUNTRYENTRY);
|
|
|
|
if(dwCountryID)
|
|
i = 0;
|
|
|
|
lpLCE[i].dwCountryID = atoi(subkey_name);
|
|
size = sizeof(DWORD);
|
|
RegQueryValueExA(hsubkey, "CountryCode", NULL, NULL,
|
|
(BYTE*)&lpLCE[i].dwCountryCode, &size);
|
|
|
|
lpLCE[i].dwNextCountryID = 0;
|
|
|
|
if(i > 0)
|
|
lpLCE[i-1].dwNextCountryID = lpLCE[i].dwCountryID;
|
|
|
|
/* add country name */
|
|
lpLCE[i].dwCountryNameSize = size_name;
|
|
lpLCE[i].dwCountryNameOffset = dwOffset;
|
|
RegQueryValueExA(hsubkey, "Name", NULL, NULL,
|
|
((LPBYTE)lpLineCountryList)+dwOffset,
|
|
&size_name);
|
|
dwOffset += size_name;
|
|
|
|
/* add Same Area Rule */
|
|
lpLCE[i].dwSameAreaRuleSize = size_same;
|
|
lpLCE[i].dwSameAreaRuleOffset = dwOffset;
|
|
RegQueryValueExA(hsubkey, "SameAreaRule", NULL, NULL,
|
|
((LPBYTE)lpLineCountryList)+dwOffset,
|
|
&size_same);
|
|
dwOffset += size_same;
|
|
|
|
/* add Long Distance Rule */
|
|
lpLCE[i].dwLongDistanceRuleSize = size_long;
|
|
lpLCE[i].dwLongDistanceRuleOffset = dwOffset;
|
|
RegQueryValueExA(hsubkey, "LongDistanceRule", NULL, NULL,
|
|
((LPBYTE)lpLineCountryList)+dwOffset,
|
|
&size_long);
|
|
dwOffset += size_long;
|
|
|
|
/* add Long Distance Rule */
|
|
lpLCE[i].dwInternationalRuleSize = size_int;
|
|
lpLCE[i].dwInternationalRuleOffset = dwOffset;
|
|
RegQueryValueExA(hsubkey, "InternationalRule", NULL, NULL,
|
|
((LPBYTE)lpLineCountryList)+dwOffset,
|
|
&size_int);
|
|
dwOffset += size_int;
|
|
RegCloseKey(hsubkey);
|
|
|
|
TRACE("Added country %s at %p\n", (LPSTR)lpLineCountryList + lpLCE[i].dwCountryNameOffset,
|
|
&lpLCE[i]);
|
|
|
|
if(dwCountryID) break;
|
|
}
|
|
|
|
lpLineCountryList->dwNeededSize = dwOffset;
|
|
|
|
TRACE("%d available %d required\n", dwAvailSize, dwOffset);
|
|
|
|
HeapFree(GetProcessHeap(), 0, subkey_name);
|
|
RegCloseKey(hkey);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineGetCountryW (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineGetCountryW(DWORD id, DWORD version, LPLINECOUNTRYLIST list)
|
|
{
|
|
static const WCHAR country_listW[] =
|
|
{'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
|
|
'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
|
|
'T','e','l','e','p','h','o','n','y','\\','C','o','u','n','t','r','y',' ','L','i','s','t',0};
|
|
static const WCHAR international_ruleW[] =
|
|
{'I','n','t','e','r','n','a','t','i','o','n','a','l','R','u','l','e',0};
|
|
static const WCHAR longdistance_ruleW[] =
|
|
{'L','o','n','g','D','i','s','t','a','n','c','e','R','u','l','e',0};
|
|
static const WCHAR samearea_ruleW[] =
|
|
{'S','a','m','e','A','r','e','a','R','u','l','e',0};
|
|
static const WCHAR nameW[] =
|
|
{'N','a','m','e',0};
|
|
static const WCHAR country_codeW[] =
|
|
{'C','o','u','n','t','r','y','C','o','d','e',0};
|
|
DWORD total_size, offset, i, num_countries, max_subkey_len;
|
|
LINECOUNTRYENTRY *entry;
|
|
WCHAR *subkey_name;
|
|
HKEY hkey;
|
|
|
|
if (!list) return LINEERR_INVALPOINTER;
|
|
TRACE("(%08x, %08x, %p(%d))\n", id, version, list, list->dwTotalSize);
|
|
|
|
if (RegOpenKeyW(HKEY_LOCAL_MACHINE, country_listW, &hkey) != ERROR_SUCCESS)
|
|
return LINEERR_INIFILECORRUPT;
|
|
|
|
total_size = list->dwTotalSize;
|
|
offset = sizeof(LINECOUNTRYLIST);
|
|
if (total_size < offset) return LINEERR_STRUCTURETOOSMALL;
|
|
|
|
memset(list, 0, total_size);
|
|
list->dwTotalSize = total_size;
|
|
list->dwUsedSize = offset;
|
|
list->dwNumCountries = 0;
|
|
list->dwCountryListSize = 0;
|
|
list->dwCountryListOffset = offset;
|
|
|
|
entry = (LINECOUNTRYENTRY *)(list + 1);
|
|
|
|
if (RegQueryInfoKeyW(hkey, NULL, NULL, NULL, &num_countries, &max_subkey_len,
|
|
NULL, NULL, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
|
|
{
|
|
RegCloseKey(hkey);
|
|
return LINEERR_OPERATIONFAILED;
|
|
}
|
|
if (id) offset = sizeof(LINECOUNTRYENTRY);
|
|
else offset += num_countries * sizeof(LINECOUNTRYENTRY);
|
|
|
|
max_subkey_len++;
|
|
if (!(subkey_name = HeapAlloc(GetProcessHeap(), 0, max_subkey_len * sizeof(WCHAR))))
|
|
{
|
|
RegCloseKey(hkey);
|
|
return LINEERR_NOMEM;
|
|
}
|
|
for (i = 0; i < num_countries; i++)
|
|
{
|
|
DWORD len, size, size_int, size_long, size_name, size_same;
|
|
HKEY hsubkey;
|
|
|
|
if (RegEnumKeyW(hkey, i, subkey_name, max_subkey_len) != ERROR_SUCCESS) continue;
|
|
if (id && (wcstol(subkey_name, NULL, 10) != id)) continue;
|
|
if (RegOpenKeyW(hkey, subkey_name, &hsubkey) != ERROR_SUCCESS) continue;
|
|
|
|
RegQueryValueExW(hsubkey, international_ruleW, NULL, NULL, NULL, &size_int);
|
|
len = size_int;
|
|
|
|
RegQueryValueExW(hsubkey, longdistance_ruleW, NULL, NULL, NULL, &size_long);
|
|
len += size_long;
|
|
|
|
RegQueryValueExW(hsubkey, nameW, NULL, NULL, NULL, &size_name);
|
|
len += size_name;
|
|
|
|
RegQueryValueExW(hsubkey, samearea_ruleW, NULL, NULL, NULL, &size_same);
|
|
len += size_same;
|
|
|
|
if (total_size < offset + len)
|
|
{
|
|
offset += len;
|
|
RegCloseKey(hsubkey);
|
|
if (id) break;
|
|
continue;
|
|
}
|
|
list->dwNumCountries++;
|
|
list->dwCountryListSize += sizeof(LINECOUNTRYENTRY);
|
|
list->dwUsedSize += len + sizeof(LINECOUNTRYENTRY);
|
|
|
|
if (id) i = 0;
|
|
entry[i].dwCountryID = wcstol(subkey_name, NULL, 10);
|
|
size = sizeof(DWORD);
|
|
RegQueryValueExW(hsubkey, country_codeW, NULL, NULL, (BYTE *)&entry[i].dwCountryCode, &size);
|
|
entry[i].dwNextCountryID = 0;
|
|
|
|
if (i > 0) entry[i - 1].dwNextCountryID = entry[i].dwCountryID;
|
|
|
|
/* add country name */
|
|
entry[i].dwCountryNameSize = size_name;
|
|
entry[i].dwCountryNameOffset = offset;
|
|
RegQueryValueExW(hsubkey, nameW, NULL, NULL, (BYTE *)list + offset, &size_name);
|
|
offset += size_name;
|
|
|
|
/* add Same Area Rule */
|
|
entry[i].dwSameAreaRuleSize = size_same;
|
|
entry[i].dwSameAreaRuleOffset = offset;
|
|
RegQueryValueExW(hsubkey, samearea_ruleW, NULL, NULL, (BYTE *)list + offset, &size_same);
|
|
offset += size_same;
|
|
|
|
/* add Long Distance Rule */
|
|
entry[i].dwLongDistanceRuleSize = size_long;
|
|
entry[i].dwLongDistanceRuleOffset = offset;
|
|
RegQueryValueExW(hsubkey, longdistance_ruleW, NULL, NULL, (BYTE *)list + offset, &size_long);
|
|
offset += size_long;
|
|
|
|
/* add Long Distance Rule */
|
|
entry[i].dwInternationalRuleSize = size_int;
|
|
entry[i].dwInternationalRuleOffset = offset;
|
|
RegQueryValueExW(hsubkey, international_ruleW, NULL, NULL, (BYTE *)list + offset, &size_int);
|
|
offset += size_int;
|
|
RegCloseKey(hsubkey);
|
|
|
|
TRACE("added country %s at %p\n",
|
|
debugstr_w((const WCHAR *)((const char *)list + entry[i].dwCountryNameOffset)), &entry[i]);
|
|
if (id) break;
|
|
}
|
|
list->dwNeededSize = offset;
|
|
|
|
TRACE("%d available %d required\n", total_size, offset);
|
|
|
|
HeapFree(GetProcessHeap(), 0, subkey_name);
|
|
RegCloseKey(hkey);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineGetDevCapsW (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineGetDevCapsW(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion,
|
|
DWORD dwExtVersion, LPLINEDEVCAPS lpLineDevCaps)
|
|
{
|
|
static int warn_once;
|
|
|
|
if(!warn_once++)
|
|
FIXME("(%p, %08x, %08x, %08x, %p): stub.\n", hLineApp, dwDeviceID, dwAPIVersion,
|
|
dwExtVersion, lpLineDevCaps);
|
|
return LINEERR_OPERATIONFAILED;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineGetDevCapsA (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineGetDevCapsA(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion,
|
|
DWORD dwExtVersion, LPLINEDEVCAPS lpLineDevCaps)
|
|
{
|
|
static int warn_once;
|
|
|
|
if(!warn_once++)
|
|
FIXME("(%p, %08x, %08x, %08x, %p): stub.\n", hLineApp, dwDeviceID, dwAPIVersion,
|
|
dwExtVersion, lpLineDevCaps);
|
|
return LINEERR_OPERATIONFAILED;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineGetDevConfig (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineGetDevConfigA(DWORD dwDeviceID, LPVARSTRING lpDeviceConfig, LPCSTR lpszDeviceClass)
|
|
{
|
|
FIXME("(%08x, %p, %s): stub.\n", dwDeviceID, lpDeviceConfig, lpszDeviceClass);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineGetIDW (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineGetIDW(HLINE hLine, DWORD dwAddressID, HCALL hCall, DWORD dwSelect,
|
|
LPVARSTRING lpDeviceID, LPCWSTR lpszDeviceClass)
|
|
{
|
|
FIXME("(%p, %08x, %p, %08x, %p, %s): stub.\n", hLine, dwAddressID, hCall,
|
|
dwSelect, lpDeviceID,
|
|
debugstr_w(lpszDeviceClass));
|
|
return LINEERR_OPERATIONFAILED;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineGetIDA (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineGetIDA(HLINE hLine, DWORD dwAddressID, HCALL hCall, DWORD dwSelect,
|
|
LPVARSTRING lpDeviceID, LPCSTR lpszDeviceClass)
|
|
{
|
|
FIXME("(%p, %08x, %p, %08x, %p, %s): stub.\n", hLine, dwAddressID, hCall,
|
|
dwSelect, lpDeviceID, lpszDeviceClass);
|
|
return LINEERR_OPERATIONFAILED;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineGetIcon (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineGetIconA(DWORD dwDeviceID, LPCSTR lpszDeviceClass, HICON *lphIcon)
|
|
{
|
|
FIXME("(%08x, %s, %p): stub.\n", dwDeviceID, lpszDeviceClass, lphIcon);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineGetLineDevStatus (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineGetLineDevStatusA(HLINE hLine, LPLINEDEVSTATUS lpLineDevStatus)
|
|
{
|
|
FIXME("(%p, %p): stub.\n", hLine, lpLineDevStatus);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineGetMessage (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineGetMessage(HLINEAPP hLineApp, LPLINEMESSAGE lpMessage, DWORD dwTimeout)
|
|
{
|
|
FIXME("(%p, %p, %08x): stub.\n", hLineApp, lpMessage, dwTimeout);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineGetNewCalls (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineGetNewCalls(HLINE hLine, DWORD dwAddressID, DWORD dwSelect, LPLINECALLLIST lpCallList)
|
|
{
|
|
FIXME("(%p, %08x, %08x, %p): stub.\n", hLine, dwAddressID, dwSelect, lpCallList);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineGetNumRings (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineGetNumRings(HLINE hLine, DWORD dwAddressID, LPDWORD lpdwNumRings)
|
|
{
|
|
FIXME("(%p, %08x, %p): stub.\n", hLine, dwAddressID, lpdwNumRings);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineGetProviderListA (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineGetProviderListA(DWORD dwAPIVersion, LPLINEPROVIDERLIST lpProviderList)
|
|
{
|
|
FIXME("(%08x, %p): stub.\n", dwAPIVersion, lpProviderList);
|
|
return LINEERR_OPERATIONFAILED;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineGetProviderListW (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineGetProviderListW(DWORD dwAPIVersion, LPLINEPROVIDERLIST lpProviderList)
|
|
{
|
|
FIXME("(%08x, %p): stub.\n", dwAPIVersion, lpProviderList);
|
|
return LINEERR_OPERATIONFAILED;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineGetRequest (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineGetRequestA(HLINEAPP hLineApp, DWORD dwRequestMode, LPVOID lpRequestBuffer)
|
|
{
|
|
FIXME("%p, %08x, %p): stub.\n", hLineApp, dwRequestMode, lpRequestBuffer);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineGetStatusMessages (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineGetStatusMessages(HLINE hLine, LPDWORD lpdwLineStatus, LPDWORD lpdwAddressStates)
|
|
{
|
|
FIXME("(%p, %p, %p): stub.\n", hLine, lpdwLineStatus, lpdwAddressStates);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineGetTranslateCaps (TAPI32.@)
|
|
*
|
|
* get address translate capabilities. Returns a LINETRANSLATECAPS
|
|
* structure:
|
|
*
|
|
* +-----------------------+
|
|
* |TotalSize |
|
|
* |NeededSize |
|
|
* |UsedSize |
|
|
* +-----------------------+
|
|
* |NumLocations |
|
|
* |LocationsListSize |
|
|
* |LocationsListOffset | -+
|
|
* |CurrentLocationID | |
|
|
* +-----------------------+ |
|
|
* |NumCards | |
|
|
* |CardListSize | |
|
|
* |CardListOffset | -|--+
|
|
* |CurrentPreferredCardID | | |
|
|
* +-----------------------+ | |
|
|
* | | <+ |
|
|
* |LINELOCATIONENTRY #1 | |
|
|
* | | |
|
|
* +-----------------------+ |
|
|
* ~ ~ |
|
|
* +-----------------------+ |
|
|
* | | |
|
|
* |LINELOCATIONENTRY | |
|
|
* | #NumLocations| |
|
|
* +-----------------------+ |
|
|
* | | <---+
|
|
* |LINECARDENTRY #1 |
|
|
* | |
|
|
* +-----------------------+
|
|
* ~ ~
|
|
* +-----------------------+
|
|
* | |
|
|
* |LINECARDENTRY #NumCards|
|
|
* | |
|
|
* +-----------------------+
|
|
* | room for strings named|
|
|
* | in the structures |
|
|
* | above. |
|
|
* +-----------------------+
|
|
*/
|
|
DWORD WINAPI lineGetTranslateCapsA(HLINEAPP hLineApp, DWORD dwAPIVersion,
|
|
LPLINETRANSLATECAPS lpTranslateCaps)
|
|
{
|
|
HKEY hkLocations, hkCards, hkCardLocations, hsubkey;
|
|
int numlocations, numcards;
|
|
DWORD maxlockeylen,
|
|
maxcardkeylen;
|
|
char *loc_key_name = NULL;
|
|
char *card_key_name = NULL;
|
|
LPBYTE strptr;
|
|
int length;
|
|
int i;
|
|
DWORD lendword;
|
|
DWORD currentid;
|
|
LPLINELOCATIONENTRY pLocEntry;
|
|
LPLINECARDENTRY pCardEntry;
|
|
|
|
TRACE("(%p, %08x, %p (tot. size %d)\n", hLineApp, dwAPIVersion,
|
|
lpTranslateCaps, lpTranslateCaps->dwTotalSize );
|
|
if( lpTranslateCaps->dwTotalSize < sizeof(LINETRANSLATECAPS))
|
|
return LINEERR_STRUCTURETOOSMALL;
|
|
if( RegCreateKeyA(HKEY_LOCAL_MACHINE, szLocationsKey, &hkLocations)
|
|
!= ERROR_SUCCESS ) {
|
|
ERR("unexpected registry error 1.\n");
|
|
return LINEERR_INIFILECORRUPT;
|
|
}
|
|
lendword = sizeof( DWORD);
|
|
if( RegQueryValueExA( hkLocations, "CurrentID", NULL, NULL,
|
|
(LPBYTE) ¤tid, &lendword) != ERROR_SUCCESS )
|
|
currentid = -1; /* change this later */
|
|
if(RegQueryInfoKeyA(hkLocations, NULL, NULL, NULL, NULL, &maxlockeylen,
|
|
NULL, NULL, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) {
|
|
RegCloseKey(hkLocations);
|
|
ERR("unexpected registry error 2.\n");
|
|
return LINEERR_INIFILECORRUPT;
|
|
}
|
|
maxlockeylen++;
|
|
if( maxlockeylen < 10)
|
|
maxlockeylen = 10; /* need this also if there is no key */
|
|
loc_key_name = HeapAlloc( GetProcessHeap(), 0, maxlockeylen);
|
|
/* first time through: calculate needed space */
|
|
length=0;
|
|
i=0;
|
|
numlocations=0;
|
|
while( RegEnumKeyA(hkLocations, i, loc_key_name, maxlockeylen)
|
|
== ERROR_SUCCESS){
|
|
DWORD size_val;
|
|
i++;
|
|
if( _strnicmp(loc_key_name, "location", 8) ||
|
|
(RegOpenKeyA(hkLocations, loc_key_name, &hsubkey)
|
|
!= ERROR_SUCCESS))
|
|
continue;
|
|
numlocations++;
|
|
length += sizeof(LINELOCATIONENTRY);
|
|
RegQueryValueExA(hsubkey, "Name",NULL,NULL,NULL,&size_val);
|
|
length += size_val;
|
|
RegQueryValueExA(hsubkey, "AreaCode",NULL,NULL,NULL,&size_val);
|
|
length += size_val;
|
|
RegQueryValueExA(hsubkey, "OutsideAccess",NULL,NULL,NULL,&size_val);
|
|
length += size_val;
|
|
RegQueryValueExA(hsubkey, "LongDistanceAccess",NULL,NULL,NULL,&size_val);
|
|
length += size_val;
|
|
RegQueryValueExA(hsubkey, "DisableCallWaiting",NULL,NULL,NULL,&size_val);
|
|
length += size_val;
|
|
/* fixme: what about TollPrefixList???? */
|
|
RegCloseKey(hsubkey);
|
|
}
|
|
if(numlocations == 0) {
|
|
/* add one location */
|
|
if( RegCreateKeyA( hkLocations, "Location1", &hsubkey)
|
|
== ERROR_SUCCESS) {
|
|
DWORD dwval;
|
|
char buf[10];
|
|
numlocations = 1;
|
|
length += sizeof(LINELOCATIONENTRY) + 20 ;
|
|
RegSetValueExA( hsubkey, "AreaCode", 0, REG_SZ, (const BYTE *)"010", 4);
|
|
GetLocaleInfoA( LOCALE_SYSTEM_DEFAULT, LOCALE_ICOUNTRY, buf, 8);
|
|
dwval = atoi(buf);
|
|
RegSetValueExA( hsubkey, "Country", 0, REG_DWORD, (LPBYTE)&dwval,
|
|
sizeof(DWORD));
|
|
RegSetValueExA( hsubkey, "DisableCallWaiting", 0, REG_SZ, (const BYTE *)"", 1);
|
|
dwval = 1;
|
|
RegSetValueExA( hsubkey, "Flags", 0, REG_DWORD, (LPBYTE)&dwval,
|
|
sizeof(DWORD));
|
|
RegSetValueExA( hsubkey, "LongDistanceAccess", 0, REG_SZ, (const BYTE *)"", 1);
|
|
RegSetValueExA( hsubkey, "Name", 0, REG_SZ, (const BYTE *)"New Location", 13);
|
|
RegSetValueExA( hsubkey, "OutsideAccess", 0, REG_SZ, (const BYTE *)"", 1);
|
|
RegCloseKey(hsubkey);
|
|
dwval = 1;
|
|
RegSetValueExA( hkLocations, "CurrentID", 0, REG_DWORD,
|
|
(LPBYTE)&dwval, sizeof(DWORD));
|
|
dwval = 2;
|
|
RegSetValueExA( hkLocations, "NextID", 0, REG_DWORD, (LPBYTE)&dwval,
|
|
sizeof(DWORD));
|
|
}
|
|
}
|
|
/* do the card list */
|
|
numcards=0;
|
|
if( RegCreateKeyA(HKEY_CURRENT_USER, szCardsKey, &hkCards)
|
|
== ERROR_SUCCESS ) {
|
|
if(RegQueryInfoKeyA(hkCards, NULL, NULL, NULL, NULL, &maxcardkeylen,
|
|
NULL, NULL, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) {
|
|
maxcardkeylen++;
|
|
if( maxcardkeylen < 6) maxcardkeylen = 6;
|
|
card_key_name = HeapAlloc(GetProcessHeap(), 0, maxcardkeylen);
|
|
i=0;
|
|
while( RegEnumKeyA(hkCards, i, card_key_name, maxcardkeylen) ==
|
|
ERROR_SUCCESS){
|
|
DWORD size_val;
|
|
i++;
|
|
if( _strnicmp(card_key_name, "card", 4) || ERROR_SUCCESS !=
|
|
(RegOpenKeyA(hkCards, card_key_name, &hsubkey) ))
|
|
continue;
|
|
numcards++;
|
|
length += sizeof(LINECARDENTRY);
|
|
RegQueryValueExA(hsubkey, "Name",NULL,NULL,NULL,&size_val);
|
|
length += size_val;
|
|
RegQueryValueExA(hsubkey, "LocalRule",NULL,NULL,NULL,&size_val);
|
|
length += size_val;
|
|
RegQueryValueExA(hsubkey, "LDRule",NULL,NULL,NULL,&size_val);
|
|
length += size_val;
|
|
RegQueryValueExA(hsubkey, "InternationalRule",NULL,NULL,NULL,
|
|
&size_val);
|
|
length += size_val;
|
|
RegCloseKey(hsubkey);
|
|
}
|
|
}
|
|
/* add one card (direct call) */
|
|
if (numcards == 0 &&
|
|
ERROR_SUCCESS == RegCreateKeyA( hkCards, "Card1", &hsubkey)) {
|
|
DWORD dwval;
|
|
numcards = 1;
|
|
length += sizeof(LINECARDENTRY) + 22 ;
|
|
RegSetValueExA( hsubkey, "Name", 0, REG_SZ, (const BYTE *)"None (Direct Call)", 19);
|
|
dwval = 1;
|
|
RegSetValueExA( hsubkey, "Flags", 0, REG_DWORD, (LPBYTE)&dwval,
|
|
sizeof(DWORD));
|
|
RegSetValueExA( hsubkey, "InternationalRule", 0, REG_SZ, (const BYTE *)"", 1);
|
|
RegSetValueExA( hsubkey, "LDRule", 0, REG_SZ, (const BYTE *)"", 1);
|
|
RegSetValueExA( hsubkey, "LocalRule", 0, REG_SZ, (const BYTE *)"", 1);
|
|
RegCloseKey(hsubkey);
|
|
dwval = 2;
|
|
RegSetValueExA( hkCards, "NextID", 0, REG_DWORD, (LPBYTE)&dwval,
|
|
sizeof(DWORD));
|
|
}
|
|
} else hkCards = 0; /* should really fail */
|
|
/* check if sufficient room is available */
|
|
lpTranslateCaps->dwNeededSize = sizeof(LINETRANSLATECAPS) + length;
|
|
if ( lpTranslateCaps->dwNeededSize > lpTranslateCaps->dwTotalSize ) {
|
|
RegCloseKey( hkLocations);
|
|
if( hkCards) RegCloseKey( hkCards);
|
|
HeapFree(GetProcessHeap(), 0, loc_key_name);
|
|
HeapFree(GetProcessHeap(), 0, card_key_name);
|
|
lpTranslateCaps->dwUsedSize = sizeof(LINETRANSLATECAPS);
|
|
TRACE("Insufficient space: total %d needed %d used %d\n",
|
|
lpTranslateCaps->dwTotalSize,
|
|
lpTranslateCaps->dwNeededSize,
|
|
lpTranslateCaps->dwUsedSize);
|
|
return 0;
|
|
}
|
|
/* fill in the LINETRANSLATECAPS structure */
|
|
lpTranslateCaps->dwUsedSize = lpTranslateCaps->dwNeededSize;
|
|
lpTranslateCaps->dwNumLocations = numlocations;
|
|
lpTranslateCaps->dwLocationListSize = sizeof(LINELOCATIONENTRY) *
|
|
lpTranslateCaps->dwNumLocations;
|
|
lpTranslateCaps->dwLocationListOffset = sizeof(LINETRANSLATECAPS);
|
|
lpTranslateCaps->dwCurrentLocationID = currentid;
|
|
lpTranslateCaps->dwNumCards = numcards;
|
|
lpTranslateCaps->dwCardListSize = sizeof(LINECARDENTRY) *
|
|
lpTranslateCaps->dwNumCards;
|
|
lpTranslateCaps->dwCardListOffset = lpTranslateCaps->dwLocationListOffset +
|
|
lpTranslateCaps->dwLocationListSize;
|
|
lpTranslateCaps->dwCurrentPreferredCardID = 0;
|
|
/* this is where the strings will be stored */
|
|
strptr = ((LPBYTE) lpTranslateCaps) +
|
|
lpTranslateCaps->dwCardListOffset + lpTranslateCaps->dwCardListSize;
|
|
pLocEntry = (LPLINELOCATIONENTRY) (lpTranslateCaps + 1);
|
|
/* key with Preferred CardIDs */
|
|
if( RegOpenKeyA(HKEY_CURRENT_USER, szLocationsKey, &hkCardLocations)
|
|
!= ERROR_SUCCESS )
|
|
hkCardLocations = 0;
|
|
/* second time through all locations */
|
|
i=0;
|
|
while(RegEnumKeyA(hkLocations, i, loc_key_name, maxlockeylen)
|
|
== ERROR_SUCCESS){
|
|
DWORD size_val;
|
|
i++;
|
|
if( _strnicmp(loc_key_name, "location", 8) ||
|
|
(RegOpenKeyA(hkLocations, loc_key_name, &hsubkey)
|
|
!= ERROR_SUCCESS))
|
|
continue;
|
|
size_val=sizeof(DWORD);
|
|
if( RegQueryValueExA(hsubkey, "ID",NULL, NULL,
|
|
(LPBYTE) &(pLocEntry->dwPermanentLocationID), &size_val) !=
|
|
ERROR_SUCCESS)
|
|
pLocEntry->dwPermanentLocationID = atoi( loc_key_name + 8);
|
|
size_val=2048;
|
|
RegQueryValueExA(hsubkey, "Name",NULL,NULL, strptr, &size_val);
|
|
pLocEntry->dwLocationNameSize = size_val;
|
|
pLocEntry->dwLocationNameOffset = strptr - (LPBYTE) lpTranslateCaps;
|
|
strptr += size_val;
|
|
|
|
size_val=2048;
|
|
RegQueryValueExA(hsubkey, "AreaCode",NULL,NULL, strptr, &size_val);
|
|
pLocEntry->dwCityCodeSize = size_val;
|
|
pLocEntry->dwCityCodeOffset = strptr - (LPBYTE) lpTranslateCaps;
|
|
strptr += size_val;
|
|
|
|
size_val=2048;
|
|
RegQueryValueExA(hsubkey, "OutsideAccess",NULL,NULL, strptr, &size_val);
|
|
pLocEntry->dwLocalAccessCodeSize = size_val;
|
|
pLocEntry->dwLocalAccessCodeOffset = strptr - (LPBYTE) lpTranslateCaps;
|
|
strptr += size_val;
|
|
size_val=2048;
|
|
RegQueryValueExA(hsubkey, "LongDistanceAccess",NULL,NULL, strptr,
|
|
&size_val);
|
|
pLocEntry->dwLongDistanceAccessCodeSize= size_val;
|
|
pLocEntry->dwLongDistanceAccessCodeOffset= strptr -
|
|
(LPBYTE) lpTranslateCaps;
|
|
strptr += size_val;
|
|
size_val=2048;
|
|
RegQueryValueExA(hsubkey, "DisableCallWaiting",NULL,NULL, strptr,
|
|
&size_val);
|
|
pLocEntry->dwCancelCallWaitingSize= size_val;
|
|
pLocEntry->dwCancelCallWaitingOffset= strptr - (LPBYTE) lpTranslateCaps;
|
|
strptr += size_val;
|
|
|
|
pLocEntry->dwTollPrefixListSize = 0; /* FIXME */
|
|
pLocEntry->dwTollPrefixListOffset = 0; /* FIXME */
|
|
|
|
size_val=sizeof(DWORD);
|
|
RegQueryValueExA(hsubkey, "Country",NULL,NULL,
|
|
(LPBYTE) &(pLocEntry->dwCountryCode), &size_val);
|
|
pLocEntry->dwCountryID = pLocEntry->dwCountryCode; /* FIXME */
|
|
RegQueryValueExA(hsubkey, "Flags",NULL,NULL,
|
|
(LPBYTE) &(pLocEntry->dwOptions), &size_val);
|
|
RegCloseKey(hsubkey);
|
|
/* get preferred cardid */
|
|
pLocEntry->dwPreferredCardID = 0;
|
|
if ( hkCardLocations) {
|
|
size_val=sizeof(DWORD);
|
|
if(RegOpenKeyA(hkCardLocations, loc_key_name, &hsubkey) ==
|
|
ERROR_SUCCESS) {
|
|
RegQueryValueExA(hsubkey, "CallingCard",NULL,NULL,
|
|
(LPBYTE) &(pLocEntry->dwPreferredCardID), &size_val);
|
|
RegCloseKey(hsubkey);
|
|
}
|
|
|
|
}
|
|
/* make sure there is a currentID */
|
|
if(currentid == -1){
|
|
currentid = pLocEntry->dwPermanentLocationID;
|
|
lpTranslateCaps->dwCurrentLocationID = currentid;
|
|
}
|
|
if(pLocEntry->dwPermanentLocationID == currentid )
|
|
lpTranslateCaps->dwCurrentPreferredCardID =
|
|
pLocEntry->dwPreferredCardID;
|
|
TRACE("added: ID %d %s CountryCode %d CityCode %s CardID %d "
|
|
"LocalAccess: %s LongDistanceAccess: %s CountryID %d "
|
|
"Options %d CancelCallWait %s\n",
|
|
pLocEntry->dwPermanentLocationID,
|
|
debugstr_a( (char*)lpTranslateCaps + pLocEntry->dwLocationNameOffset),
|
|
pLocEntry->dwCountryCode,
|
|
debugstr_a( (char*)lpTranslateCaps + pLocEntry->dwCityCodeOffset),
|
|
pLocEntry->dwPreferredCardID,
|
|
debugstr_a( (char*)lpTranslateCaps + pLocEntry->dwLocalAccessCodeOffset),
|
|
debugstr_a( (char*)lpTranslateCaps + pLocEntry->dwLongDistanceAccessCodeOffset),
|
|
pLocEntry->dwCountryID,
|
|
pLocEntry->dwOptions,
|
|
debugstr_a( (char*)lpTranslateCaps + pLocEntry->dwCancelCallWaitingOffset));
|
|
pLocEntry++;
|
|
}
|
|
pCardEntry= (LPLINECARDENTRY) pLocEntry;
|
|
/* do the card list */
|
|
if( hkCards) {
|
|
i=0;
|
|
while( RegEnumKeyA(hkCards, i, card_key_name, maxcardkeylen) ==
|
|
ERROR_SUCCESS){
|
|
DWORD size_val;
|
|
i++;
|
|
if( _strnicmp(card_key_name, "card", 4) ||
|
|
(RegOpenKeyA(hkCards, card_key_name, &hsubkey) != ERROR_SUCCESS))
|
|
continue;
|
|
size_val=sizeof(DWORD);
|
|
if( RegQueryValueExA(hsubkey, "ID",NULL, NULL,
|
|
(LPBYTE) &(pCardEntry->dwPermanentCardID), &size_val) !=
|
|
ERROR_SUCCESS)
|
|
pCardEntry->dwPermanentCardID= atoi( card_key_name + 4);
|
|
size_val=2048;
|
|
RegQueryValueExA(hsubkey, "Name",NULL,NULL, strptr, &size_val);
|
|
pCardEntry->dwCardNameSize = size_val;
|
|
pCardEntry->dwCardNameOffset = strptr - (LPBYTE) lpTranslateCaps;
|
|
strptr += size_val;
|
|
pCardEntry->dwCardNumberDigits = 1; /* FIXME */
|
|
size_val=2048;
|
|
RegQueryValueExA(hsubkey, "LocalRule",NULL,NULL, strptr, &size_val);
|
|
pCardEntry->dwSameAreaRuleSize= size_val;
|
|
pCardEntry->dwSameAreaRuleOffset= strptr - (LPBYTE) lpTranslateCaps;
|
|
strptr += size_val;
|
|
size_val=2048;
|
|
RegQueryValueExA(hsubkey, "LDRule",NULL,NULL, strptr, &size_val);
|
|
pCardEntry->dwLongDistanceRuleSize = size_val;
|
|
pCardEntry->dwLongDistanceRuleOffset = strptr - (LPBYTE) lpTranslateCaps;
|
|
strptr += size_val;
|
|
size_val=2048;
|
|
RegQueryValueExA(hsubkey, "InternationalRule",NULL,NULL, strptr,
|
|
&size_val);
|
|
pCardEntry->dwInternationalRuleSize = size_val;
|
|
pCardEntry->dwInternationalRuleOffset = strptr -
|
|
(LPBYTE) lpTranslateCaps;
|
|
strptr += size_val;
|
|
size_val=sizeof(DWORD);
|
|
RegQueryValueExA(hsubkey, "Flags",NULL, NULL,
|
|
(LPBYTE) &(pCardEntry->dwOptions), &size_val);
|
|
TRACE( "added card: ID %d name %s SameArea %s LongDistance %s International %s Options 0x%x\n",
|
|
pCardEntry->dwPermanentCardID,
|
|
debugstr_a( (char*)lpTranslateCaps + pCardEntry->dwCardNameOffset),
|
|
debugstr_a( (char*)lpTranslateCaps + pCardEntry->dwSameAreaRuleOffset),
|
|
debugstr_a( (char*)lpTranslateCaps + pCardEntry->dwLongDistanceRuleOffset),
|
|
debugstr_a( (char*)lpTranslateCaps + pCardEntry->dwInternationalRuleOffset),
|
|
pCardEntry->dwOptions);
|
|
|
|
pCardEntry++;
|
|
}
|
|
}
|
|
|
|
if(hkLocations) RegCloseKey(hkLocations);
|
|
if(hkCards) RegCloseKey(hkCards);
|
|
if(hkCardLocations) RegCloseKey(hkCardLocations);
|
|
HeapFree(GetProcessHeap(), 0, loc_key_name);
|
|
HeapFree(GetProcessHeap(), 0, card_key_name);
|
|
TRACE(" returning success tot %d needed %d used %d\n",
|
|
lpTranslateCaps->dwTotalSize,
|
|
lpTranslateCaps->dwNeededSize,
|
|
lpTranslateCaps->dwUsedSize );
|
|
return 0; /* success */
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineHandoff (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineHandoffA(HCALL hCall, LPCSTR lpszFileName, DWORD dwMediaMode)
|
|
{
|
|
FIXME("(%p, %s, %08x): stub.\n", hCall, lpszFileName, dwMediaMode);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineHold (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineHold(HCALL hCall)
|
|
{
|
|
FIXME("(%p): stub.\n", hCall);
|
|
return 1;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineInitialize (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineInitialize(
|
|
LPHLINEAPP lphLineApp,
|
|
HINSTANCE hInstance,
|
|
LINECALLBACK lpfnCallback,
|
|
LPCSTR lpszAppName,
|
|
LPDWORD lpdwNumDevs)
|
|
{
|
|
FIXME("(%p, %p, %p, %s, %p): stub.\n", lphLineApp, hInstance,
|
|
lpfnCallback, debugstr_a(lpszAppName), lpdwNumDevs);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineInitializeExA (TAPI32.@)
|
|
*/
|
|
LONG WINAPI lineInitializeExA(LPHLINEAPP lphLineApp, HINSTANCE hInstance, LINECALLBACK lpfnCallback, LPCSTR lpszFriendlyAppName, LPDWORD lpdwNumDevs, LPDWORD lpdwAPIVersion, LPLINEINITIALIZEEXPARAMS lpLineInitializeExParams)
|
|
{
|
|
FIXME("(%p, %p, %p, %s, %p, %p, %p): stub.\n", lphLineApp, hInstance,
|
|
lpfnCallback, debugstr_a(lpszFriendlyAppName), lpdwNumDevs, lpdwAPIVersion, lpLineInitializeExParams);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineInitializeExW (TAPI32.@)
|
|
*/
|
|
LONG WINAPI lineInitializeExW(LPHLINEAPP lphLineApp, HINSTANCE hInstance, LINECALLBACK lpfnCallback, LPCWSTR lpszFriendlyAppName, LPDWORD lpdwNumDevs, LPDWORD lpdwAPIVersion, LPLINEINITIALIZEEXPARAMS lpLineInitializeExParams)
|
|
{
|
|
FIXME("(%p, %p, %p, %s, %p, %p, %p): stub.\n", lphLineApp, hInstance,
|
|
lpfnCallback, debugstr_w(lpszFriendlyAppName), lpdwNumDevs, lpdwAPIVersion, lpLineInitializeExParams);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineMakeCallW (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineMakeCallW(HLINE hLine, LPHCALL lphCall, LPCWSTR lpszDestAddress,
|
|
DWORD dwCountryCode, LPLINECALLPARAMS lpCallParams)
|
|
{
|
|
FIXME("(%p, %p, %s, %08x, %p): stub.\n", hLine, lphCall, debugstr_w(lpszDestAddress),
|
|
dwCountryCode, lpCallParams);
|
|
return LINEERR_OPERATIONFAILED;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineMakeCallA (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineMakeCallA(HLINE hLine, LPHCALL lphCall, LPCSTR lpszDestAddress,
|
|
DWORD dwCountryCode, LPLINECALLPARAMS lpCallParams)
|
|
{
|
|
FIXME("(%p, %p, %s, %08x, %p): stub.\n", hLine, lphCall, lpszDestAddress,
|
|
dwCountryCode, lpCallParams);
|
|
return LINEERR_OPERATIONFAILED;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineMonitorDigits (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineMonitorDigits(HCALL hCall, DWORD dwDigitModes)
|
|
{
|
|
FIXME("(%p, %08x): stub.\n", hCall, dwDigitModes);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineMonitorMedia (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineMonitorMedia(HCALL hCall, DWORD dwMediaModes)
|
|
{
|
|
FIXME("(%p, %08x): stub.\n", hCall, dwMediaModes);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineMonitorTones (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineMonitorTones(HCALL hCall, LPLINEMONITORTONE lpToneList, DWORD dwNumEntries)
|
|
{
|
|
FIXME("(%p, %p, %08x): stub.\n", hCall, lpToneList, dwNumEntries);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineNegotiateAPIVersion (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineNegotiateAPIVersion(
|
|
HLINEAPP hLineApp,
|
|
DWORD dwDeviceID,
|
|
DWORD dwAPILowVersion,
|
|
DWORD dwAPIHighVersion,
|
|
LPDWORD lpdwAPIVersion,
|
|
LPLINEEXTENSIONID lpExtensionID
|
|
)
|
|
{
|
|
static int warn_once;
|
|
|
|
if(!warn_once++)
|
|
FIXME("(%p, %d, %d, %d, %p, %p): stub.\n", hLineApp, dwDeviceID,
|
|
dwAPILowVersion, dwAPIHighVersion, lpdwAPIVersion, lpExtensionID);
|
|
*lpdwAPIVersion = dwAPIHighVersion;
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineNegotiateExtVersion (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineNegotiateExtVersion(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, DWORD dwExtLowVersion, DWORD dwExtHighVersion, LPDWORD lpdwExtVersion)
|
|
{
|
|
FIXME("stub.\n");
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineOpenW (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineOpenW(HLINEAPP hLineApp, DWORD dwDeviceID, LPHLINE lphLine, DWORD dwAPIVersion, DWORD dwExtVersion, DWORD dwCallbackInstance, DWORD dwPrivileges, DWORD dwMediaModes, LPLINECALLPARAMS lpCallParams)
|
|
{
|
|
FIXME("stub.\n");
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineOpen (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineOpenA(HLINEAPP hLineApp, DWORD dwDeviceID, LPHLINE lphLine, DWORD dwAPIVersion, DWORD dwExtVersion, DWORD dwCallbackInstance, DWORD dwPrivileges, DWORD dwMediaModes, LPLINECALLPARAMS lpCallParams)
|
|
{
|
|
FIXME("stub.\n");
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* linePark (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineParkA(HCALL hCall, DWORD dwParkMode, LPCSTR lpszDirAddress, LPVARSTRING lpNonDirAddress)
|
|
{
|
|
FIXME("(%p, %08x, %s, %p): stub.\n", hCall, dwParkMode, lpszDirAddress, lpNonDirAddress);
|
|
return 1;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* linePickup (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI linePickupA(HLINE hLine, DWORD dwAddressID, LPHCALL lphCall, LPCSTR lpszDestAddress, LPCSTR lpszGroupID)
|
|
{
|
|
FIXME("(%p, %08x, %p, %s, %s): stub.\n", hLine, dwAddressID, lphCall, lpszDestAddress, lpszGroupID);
|
|
return 1;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* linePrepareAddToConference (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI linePrepareAddToConferenceA(HCALL hConfCall, LPHCALL lphConsultCall, LPLINECALLPARAMS lpCallParams)
|
|
{
|
|
FIXME("(%p, %p, %p): stub.\n", hConfCall, lphConsultCall, lpCallParams);
|
|
return 1;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineRedirect (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineRedirectA(
|
|
HCALL hCall,
|
|
LPCSTR lpszDestAddress,
|
|
DWORD dwCountryCode) {
|
|
|
|
FIXME(": stub.\n");
|
|
return 1;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineRegisterRequestRecipient (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineRegisterRequestRecipient(HLINEAPP hLineApp, DWORD dwRegistrationInstance, DWORD dwRequestMode, DWORD dwEnable)
|
|
{
|
|
FIXME("(%p, %08x, %08x, %08x): stub.\n", hLineApp, dwRegistrationInstance, dwRequestMode, dwEnable);
|
|
return 1;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineReleaseUserUserInfo (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineReleaseUserUserInfo(HCALL hCall)
|
|
{
|
|
FIXME("(%p): stub.\n", hCall);
|
|
return 1;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineRemoveFromConference (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineRemoveFromConference(HCALL hCall)
|
|
{
|
|
FIXME("(%p): stub.\n", hCall);
|
|
return 1;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineRemoveProvider (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineRemoveProvider(DWORD dwPermanentProviderID, HWND hwndOwner)
|
|
{
|
|
FIXME("(%08x, %p): stub.\n", dwPermanentProviderID, hwndOwner);
|
|
return 1;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineSecureCall (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineSecureCall(HCALL hCall)
|
|
{
|
|
FIXME("(%p): stub.\n", hCall);
|
|
return 1;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineSendUserUserInfo (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineSendUserUserInfo(HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
|
|
{
|
|
FIXME("(%p, %s, %08x): stub.\n", hCall, lpsUserUserInfo, dwSize);
|
|
return 1;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineSetAppPriority (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineSetAppPriorityA(LPCSTR lpszAppFilename, DWORD dwMediaMode, LPLINEEXTENSIONID const lpExtensionID, DWORD dwRequestMode, LPCSTR lpszExtensionName, DWORD dwPriority)
|
|
{
|
|
FIXME("(%s, %08x, %p, %08x, %s, %08x): stub.\n", lpszAppFilename, dwMediaMode, lpExtensionID, dwRequestMode, lpszExtensionName, dwPriority);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineSetAppSpecific (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineSetAppSpecific(HCALL hCall, DWORD dwAppSpecific)
|
|
{
|
|
FIXME("(%p, %08x): stub.\n", hCall, dwAppSpecific);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineSetCallParams (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineSetCallParams(HCALL hCall, DWORD dwBearerMode, DWORD dwMinRate, DWORD dwMaxRate, LPLINEDIALPARAMS lpDialParams)
|
|
{
|
|
FIXME("(%p, %08x, %08x, %08x, %p): stub.\n", hCall, dwBearerMode, dwMinRate, dwMaxRate, lpDialParams);
|
|
return 1;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineSetCallPrivilege (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineSetCallPrivilege(HCALL hCall, DWORD dwCallPrivilege)
|
|
{
|
|
FIXME("(%p, %08x): stub.\n", hCall, dwCallPrivilege);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineSetCurrentLocation (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineSetCurrentLocation(HLINEAPP hLineApp, DWORD dwLocation)
|
|
{
|
|
FIXME("(%p, %08x): stub.\n", hLineApp, dwLocation);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineSetDevConfig (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineSetDevConfigA(DWORD dwDeviceID, LPVOID lpDeviceConfig, DWORD dwSize, LPCSTR lpszDeviceClass)
|
|
{
|
|
FIXME("(%08x, %p, %08x, %s): stub.\n", dwDeviceID, lpDeviceConfig, dwSize, lpszDeviceClass);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineSetMediaControl (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineSetMediaControl(
|
|
HLINE hLine,
|
|
DWORD dwAddressID,
|
|
HCALL hCall,
|
|
DWORD dwSelect,
|
|
LPLINEMEDIACONTROLDIGIT const lpDigitList,
|
|
DWORD dwDigitNumEntries,
|
|
LPLINEMEDIACONTROLMEDIA const lpMediaList,
|
|
DWORD dwMediaNumEntries,
|
|
LPLINEMEDIACONTROLTONE const lpToneList,
|
|
DWORD dwToneNumEntries,
|
|
LPLINEMEDIACONTROLCALLSTATE const lpCallStateList,
|
|
DWORD dwCallStateNumEntries)
|
|
{
|
|
FIXME(": stub.\n");
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineSetMediaMode (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineSetMediaMode(HCALL hCall, DWORD dwMediaModes)
|
|
{
|
|
FIXME("(%p, %08x): stub.\n", hCall, dwMediaModes);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineSetNumRings (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineSetNumRings(HLINE hLine, DWORD dwAddressID, DWORD dwNumRings)
|
|
{
|
|
FIXME("(%p, %08x, %08x): stub.\n", hLine, dwAddressID, dwNumRings);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineSetStatusMessages (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineSetStatusMessages(HLINE hLine, DWORD dwLineStates, DWORD dwAddressStates)
|
|
{
|
|
FIXME("(%p, %08x, %08x): stub.\n", hLine, dwLineStates, dwAddressStates);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineSetTerminal (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineSetTerminal(HLINE hLine, DWORD dwAddressID, HCALL hCall, DWORD dwSelect, DWORD dwTerminalModes, DWORD dwTerminalID, DWORD bEnable)
|
|
{
|
|
FIXME("(%p, %08x, %p, %08x, %08x, %08x, %08x): stub.\n", hLine, dwAddressID, hCall, dwSelect, dwTerminalModes, dwTerminalID, bEnable);
|
|
return 1;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineSetTollList (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineSetTollListA(HLINEAPP hLineApp, DWORD dwDeviceID, LPCSTR lpszAddressIn, DWORD dwTollListOption)
|
|
{
|
|
FIXME("(%p, %08x, %s, %08x): stub.\n", hLineApp, dwDeviceID, lpszAddressIn, dwTollListOption);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineSetupConference (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineSetupConferenceA(HCALL hCall, HLINE hLine, LPHCALL lphConfCall, LPHCALL lphConsultCall, DWORD dwNumParties, LPLINECALLPARAMS lpCallParams)
|
|
{
|
|
FIXME("(%p, %p, %p, %p, %08x, %p): stub.\n", hCall, hLine, lphConfCall, lphConsultCall, dwNumParties, lpCallParams);
|
|
return 1;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineSetupTransfer (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineSetupTransferA(HCALL hCall, LPHCALL lphConsultCall, LPLINECALLPARAMS lpCallParams)
|
|
{
|
|
FIXME("(%p, %p, %p): stub.\n", hCall, lphConsultCall, lpCallParams);
|
|
return 1;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineShutdown (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineShutdown(HLINEAPP hLineApp)
|
|
{
|
|
FIXME("(%p): stub.\n", hLineApp);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineSwapHold (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineSwapHold(HCALL hActiveCall, HCALL hHeldCall)
|
|
{
|
|
FIXME("(active: %p, held: %p): stub.\n", hActiveCall, hHeldCall);
|
|
return 1;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineTranslateAddress (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineTranslateAddressA(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, LPCSTR lpszAddressIn, DWORD dwCard, DWORD dwTranslateOptions, LPLINETRANSLATEOUTPUT lpTranslateOutput)
|
|
{
|
|
FIXME("(%p, %08x, %08x, %s, %08x, %08x, %p): stub.\n", hLineApp, dwDeviceID, dwAPIVersion, lpszAddressIn, dwCard, dwTranslateOptions, lpTranslateOutput);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineTranslateAddressW (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineTranslateAddressW(HLINEAPP hLineApp, DWORD dwDeviceID,
|
|
DWORD dwAPIVersion, LPCWSTR lpszAddressIn, DWORD dwCard,
|
|
DWORD dwTranslateOptions, LPLINETRANSLATEOUTPUT lpTranslateOutput)
|
|
{
|
|
FIXME("(%p, %08x, %08x, %s, %08x, %08x, %p): stub.\n", hLineApp, dwDeviceID, dwAPIVersion,
|
|
debugstr_w(lpszAddressIn), dwCard, dwTranslateOptions, lpTranslateOutput);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineTranslateDialog (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineTranslateDialogA(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, HWND hwndOwner, LPCSTR lpszAddressIn)
|
|
{
|
|
FIXME("(%p, %08x, %08x, %p, %s): stub.\n", hLineApp, dwDeviceID, dwAPIVersion, hwndOwner, lpszAddressIn);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineTranslateDialogW (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineTranslateDialogW(HLINEAPP hLineApp, DWORD dwDeviceID,
|
|
DWORD dwAPIVersion, HWND hwndOwner, LPCWSTR lpszAddressIn)
|
|
{
|
|
FIXME("(%p, %08x, %08x, %p, %s): stub.\n", hLineApp, dwDeviceID,
|
|
dwAPIVersion, hwndOwner, debugstr_w(lpszAddressIn));
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineUncompleteCall (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineUncompleteCall(HLINE hLine, DWORD dwCompletionID)
|
|
{
|
|
FIXME("(%p, %08x): stub.\n", hLine, dwCompletionID);
|
|
return 1;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineUnhold (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineUnhold(HCALL hCall)
|
|
{
|
|
FIXME("(%p): stub.\n", hCall);
|
|
return 1;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lineUnpark (TAPI32.@)
|
|
*/
|
|
DWORD WINAPI lineUnparkA(HLINE hLine, DWORD dwAddressID, LPHCALL lphCall, LPCSTR lpszDestAddress)
|
|
{
|
|
FIXME("(%p, %08x, %p, %s): stub.\n", hLine, dwAddressID, lphCall, lpszDestAddress);
|
|
return 1;
|
|
}
|