You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2135 lines
58 KiB
2135 lines
58 KiB
/*++
|
|
|
|
Copyright(c) 1995 Microsoft Corporation
|
|
|
|
MODULE NAME
|
|
addrmap.c
|
|
|
|
ABSTRACT
|
|
Address attributes database routines shared between
|
|
the automatic connection driver, the registry, and
|
|
the automatic connection service.
|
|
|
|
AUTHOR
|
|
Anthony Discolo (adiscolo) 01-Sep-1995
|
|
|
|
REVISION HISTORY
|
|
|
|
--*/
|
|
|
|
#define UNICODE
|
|
#define _UNICODE
|
|
|
|
#include <nt.h>
|
|
#include <ntrtl.h>
|
|
#include <nturtl.h>
|
|
|
|
#include <stdlib.h>
|
|
#include <windows.h>
|
|
#include <tchar.h>
|
|
#include <stdio.h>
|
|
#include <npapi.h>
|
|
#include <acd.h>
|
|
#include <ras.h>
|
|
#include <raserror.h>
|
|
#include <rasman.h>
|
|
#include <debug.h>
|
|
#include <time.h>
|
|
#include <wchar.h>
|
|
|
|
#include "table.h"
|
|
#include "reg.h"
|
|
#include "imperson.h"
|
|
#include "misc.h"
|
|
#include "addrmap.h"
|
|
#include "netmap.h"
|
|
#include "rasprocs.h"
|
|
#include "tapiproc.h"
|
|
|
|
#define DAYSECONDS (60*60*24)
|
|
|
|
extern HKEY hkeyCUG;
|
|
|
|
extern LONG g_lRasAutoRunning;
|
|
|
|
extern DWORD g_dwCritSecFlags;
|
|
|
|
//
|
|
// All the information we cache about
|
|
// an address is below. The ulAttributes
|
|
// field is written to the automatic connection
|
|
// driver, and the rest of the fields are written
|
|
// to the registry.
|
|
//
|
|
#define ADDRESS_MAP_FIELD_DIALINGLOC 0x00000001 // locationList changed
|
|
#define ADDRESS_MAP_FIELD_PARAMS 0x00000002 // params
|
|
|
|
typedef struct _ADDRESS_DIALING_ENTRY {
|
|
LIST_ENTRY ListEntry;
|
|
BOOLEAN fChanged; // modified bit
|
|
ADDRESS_LOCATION_INFORMATION location;
|
|
} ADDRESS_DIALING_ENTRY, *PADDRESS_DIALING_ENTRY;
|
|
|
|
typedef struct _ADDRESS_MAP_ENTRY {
|
|
LPTSTR pszNetwork; // the remote network this address is on
|
|
ULONG ulModifiedMask; // which fields have been changed
|
|
BOOLEAN fDisabled; // disabled for connection attempts
|
|
DWORD dwFailedConnectTicks; // last failed connect time
|
|
ADDRESS_PARAMS params; // used to garbage collect unref addresses
|
|
LIST_ENTRY locationHead; // list of ADDRESS_DIALING_ENTRYs
|
|
BOOLEAN fPruned; // removed by the list writer
|
|
LIST_ENTRY writerList; // list writer links
|
|
} ADDRESS_MAP_ENTRY, *PADDRESS_MAP_ENTRY;
|
|
|
|
//
|
|
// The address map head.
|
|
//
|
|
typedef struct _ADDRESS_MAP {
|
|
CRITICAL_SECTION csLock;
|
|
PHASH_TABLE pTable;
|
|
} ADDRESS_MAP, *PADDRESS_MAP;
|
|
|
|
//
|
|
// Information needed by the address
|
|
// enumerator procedure.
|
|
//
|
|
typedef struct _ADDRESS_ENUM_INFO {
|
|
ULONG ulIndex;
|
|
LPTSTR *pAddresses;
|
|
} ADDRESS_ENUM_INFO, *PADDRESS_ENUM_INFO;
|
|
|
|
//
|
|
// Information needed by the address map list
|
|
// builder enumerator procedure.
|
|
//
|
|
typedef struct _ADDRESS_LIST_INFO {
|
|
LIST_ENTRY tagHead[3]; // one per ADDRMAP_TAG_*
|
|
} ADDRESS_LIST_INFO, *PADDRESS_LIST_INFO;
|
|
|
|
//
|
|
// Structure shared by GetOrganizationDialingLocationEntry()
|
|
// and FindOrganization() when looking for an address that
|
|
// has the same organization name.
|
|
//
|
|
typedef struct _MATCH_INFO {
|
|
BOOLEAN fWww; // look for www-style address
|
|
BOOLEAN fOrg; // look for organization
|
|
DWORD dwLocationID; // current dialing location
|
|
BOOLEAN bFound; // TRUE if success
|
|
WCHAR szOrganization[ACD_ADDR_INET_LEN]; // organization we're looking for
|
|
WCHAR szAddress[ACD_ADDR_INET_LEN]; // matching address, if found
|
|
PADDRESS_DIALING_ENTRY pDialingEntry; // dialing location entry pointer
|
|
} MATCH_INFO, *PMATCH_INFO;
|
|
|
|
//
|
|
// Default permanently disabled addresses.
|
|
//
|
|
#define MAX_DISABLED_ADDRESSES 5
|
|
TCHAR *szDisabledAddresses[MAX_DISABLED_ADDRESSES] = {
|
|
TEXT("0.0.0.0"),
|
|
TEXT("255.255.255.255"),
|
|
TEXT("127.0.0.0"),
|
|
TEXT("127.0.0.1"),
|
|
TEXT("dialin_gateway")
|
|
};
|
|
|
|
//
|
|
// Global variables
|
|
//
|
|
ADDRESS_MAP AddressMapG;
|
|
HANDLE hAutodialRegChangeG = NULL;
|
|
DWORD dwLearnedAddressIndexG;
|
|
PHASH_TABLE pDisabledAddressesG;
|
|
CRITICAL_SECTION csDisabledAddressesLockG;
|
|
|
|
//
|
|
// External variables
|
|
//
|
|
extern HANDLE hAcdG;
|
|
extern HANDLE hNewLogonUserG;
|
|
extern HANDLE hNewFusG; // Fast user switching
|
|
extern HANDLE hPnpEventG;
|
|
extern HANDLE hLogoffUserG;
|
|
extern HANDLE hLogoffUserDoneG;
|
|
extern HANDLE hTapiChangeG;
|
|
extern HANDLE hTerminatingG;
|
|
extern IMPERSONATION_INFO ImpersonationInfoG;
|
|
|
|
|
|
|
|
PADDRESS_MAP_ENTRY
|
|
NewAddressMapEntry()
|
|
{
|
|
PADDRESS_MAP_ENTRY pAddressMapEntry;
|
|
|
|
pAddressMapEntry = LocalAlloc(LPTR, sizeof (ADDRESS_MAP_ENTRY));
|
|
if (pAddressMapEntry == NULL) {
|
|
RASAUTO_TRACE("NewAddressMapEntry: LocalAlloc failed");
|
|
return NULL;
|
|
}
|
|
pAddressMapEntry->pszNetwork = NULL;
|
|
pAddressMapEntry->ulModifiedMask = 0;
|
|
InitializeListHead(&pAddressMapEntry->locationHead);
|
|
pAddressMapEntry->params.dwTag = 0xffffffff;
|
|
pAddressMapEntry->params.dwModifiedTime = (DWORD)time(0);
|
|
|
|
return pAddressMapEntry;
|
|
} // NewAddressMapEntry
|
|
|
|
|
|
|
|
PADDRESS_MAP_ENTRY
|
|
GetAddressMapEntry(
|
|
IN LPTSTR pszAddress,
|
|
IN BOOLEAN fAllocate
|
|
)
|
|
{
|
|
PADDRESS_MAP_ENTRY pAddressMapEntry = NULL;
|
|
|
|
if (pszAddress == NULL)
|
|
return NULL;
|
|
|
|
if (GetTableEntry(
|
|
AddressMapG.pTable,
|
|
pszAddress,
|
|
&pAddressMapEntry))
|
|
{
|
|
goto done;
|
|
}
|
|
if (fAllocate) {
|
|
pAddressMapEntry = NewAddressMapEntry();
|
|
if (pAddressMapEntry == NULL) {
|
|
RASAUTO_TRACE("GetAddressMapEntry: NewAddressMapEntry failed");
|
|
goto done;
|
|
}
|
|
if (!PutTableEntry(AddressMapG.pTable, pszAddress, pAddressMapEntry))
|
|
{
|
|
RASAUTO_TRACE("GetAddressMapEntry: PutTableEntry failed");
|
|
LocalFree(pAddressMapEntry);
|
|
pAddressMapEntry = NULL;
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
done:
|
|
return pAddressMapEntry;
|
|
} // GetAddressMapEntry
|
|
|
|
|
|
|
|
VOID
|
|
FreeAddressMapEntry(
|
|
IN PADDRESS_MAP_ENTRY pAddressMapEntry
|
|
)
|
|
{
|
|
PLIST_ENTRY pEntry;
|
|
PADDRESS_DIALING_ENTRY pDialingEntry;
|
|
|
|
//
|
|
// Free all dynamically allocated strings.
|
|
//
|
|
if (pAddressMapEntry->pszNetwork != NULL)
|
|
LocalFree(pAddressMapEntry->pszNetwork);
|
|
while (!IsListEmpty(&pAddressMapEntry->locationHead)) {
|
|
pEntry = RemoveHeadList(&pAddressMapEntry->locationHead);
|
|
pDialingEntry =
|
|
CONTAINING_RECORD(pEntry, ADDRESS_DIALING_ENTRY, ListEntry);
|
|
|
|
LocalFree(pDialingEntry);
|
|
}
|
|
//
|
|
}
|
|
|
|
|
|
|
|
BOOLEAN
|
|
ResetDriver()
|
|
{
|
|
NTSTATUS status;
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
|
|
status = NtDeviceIoControlFile(
|
|
hAcdG,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
&ioStatusBlock,
|
|
IOCTL_ACD_RESET,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
0);
|
|
if (status != STATUS_SUCCESS) {
|
|
RASAUTO_TRACE1(
|
|
"ResetDriver: NtDeviceIoControlFile failed (status=0x%x)",
|
|
status);
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
} // ResetDriver
|
|
|
|
|
|
|
|
BOOLEAN
|
|
EnableDriver()
|
|
{
|
|
NTSTATUS status;
|
|
DWORD dwErr;
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
BOOLEAN fEnable = TRUE;
|
|
|
|
dwErr = AutoDialEnabled(&fEnable);
|
|
RASAUTO_TRACE1("EnableDriver: fEnable=%d", fEnable);
|
|
status = NtDeviceIoControlFile(
|
|
hAcdG,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
&ioStatusBlock,
|
|
IOCTL_ACD_ENABLE,
|
|
&fEnable,
|
|
sizeof (fEnable),
|
|
NULL,
|
|
0);
|
|
if (status != STATUS_SUCCESS) {
|
|
RASAUTO_TRACE1(
|
|
"ResetDriver: NtDeviceIoControlFile failed (status=0x%x)",
|
|
status);
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
} // EnableDriver
|
|
|
|
|
|
|
|
PADDRESS_DIALING_ENTRY
|
|
FindAddressDialingEntry(
|
|
IN PADDRESS_MAP_ENTRY pAddressMapEntry,
|
|
IN DWORD dwLocation
|
|
)
|
|
{
|
|
PLIST_ENTRY pEntry;
|
|
PADDRESS_DIALING_ENTRY pDialingEntry;
|
|
|
|
for (pEntry = pAddressMapEntry->locationHead.Flink;
|
|
pEntry != &pAddressMapEntry->locationHead;
|
|
pEntry = pEntry->Flink)
|
|
{
|
|
pDialingEntry = CONTAINING_RECORD(
|
|
pEntry,
|
|
ADDRESS_DIALING_ENTRY,
|
|
ListEntry);
|
|
|
|
if (pDialingEntry->location.dwLocation == dwLocation)
|
|
return pDialingEntry;
|
|
}
|
|
|
|
return NULL;
|
|
} // FindAddressDialingEntry
|
|
|
|
|
|
|
|
BOOLEAN
|
|
ClearAddressMapEntry(
|
|
IN PVOID pArg,
|
|
IN LPTSTR pszAddress,
|
|
IN PVOID pData
|
|
)
|
|
{
|
|
PADDRESS_MAP_ENTRY pAddressMapEntry = (PADDRESS_MAP_ENTRY)pData;
|
|
|
|
FreeAddressMapEntry(pAddressMapEntry);
|
|
|
|
return TRUE;
|
|
} // ClearAddressMapEntry
|
|
|
|
|
|
|
|
VOID
|
|
ClearAddressMap(VOID)
|
|
{
|
|
EnumTable(AddressMapG.pTable, ClearAddressMapEntry, NULL);
|
|
ClearTable(AddressMapG.pTable);
|
|
} // ClearAddressMap
|
|
|
|
|
|
|
|
VOID
|
|
ResetAddressMapAddress(
|
|
IN LPTSTR pszAddress
|
|
)
|
|
{
|
|
DWORD dwErr, dwcb, dwcAddresses, dwcEntries;
|
|
DWORD i, j;
|
|
PADDRESS_MAP_ENTRY pAddressMapEntry = NULL;
|
|
PADDRESS_LOCATION_INFORMATION pLocationInfo = NULL;
|
|
|
|
RASAUTO_TRACE1("ResetAddressMapAddress(%S)", pszAddress);
|
|
|
|
dwErr = GetAddressDialingLocationInfo(
|
|
pszAddress,
|
|
&pLocationInfo,
|
|
&dwcEntries);
|
|
if (dwErr || !dwcEntries)
|
|
return;
|
|
//
|
|
// Enter this address into the address map
|
|
// if it doesn't already exist.
|
|
//
|
|
if (!GetTableEntry(AddressMapG.pTable, pszAddress, &pAddressMapEntry)) {
|
|
pAddressMapEntry = NewAddressMapEntry();
|
|
if (pAddressMapEntry == NULL) {
|
|
RASAUTO_TRACE("ResetAddressMapAddress: NewAddressMapEntry failed");
|
|
goto done;
|
|
}
|
|
pAddressMapEntry->fDisabled = FALSE;
|
|
RASAUTO_TRACE1(
|
|
"ResetAddressMap: inserting pszAddress=%S",
|
|
RASAUTO_TRACESTRW(pszAddress));
|
|
if (!PutTableEntry(
|
|
AddressMapG.pTable,
|
|
pszAddress,
|
|
pAddressMapEntry))
|
|
{
|
|
RASAUTO_TRACE("ResetAddressMapAddress: PutTableEntry failed");
|
|
goto done;
|
|
}
|
|
}
|
|
//
|
|
// Get the network for this address.
|
|
//
|
|
if (pAddressMapEntry->pszNetwork == NULL) {
|
|
pAddressMapEntry->pszNetwork = AddressToNetwork(pszAddress);
|
|
if (pAddressMapEntry->pszNetwork == NULL) {
|
|
RASAUTO_TRACE1(
|
|
"ResetAddressMapAddress: AddressToNetwork(%S) failed",
|
|
pszAddress);
|
|
LocalFree(pAddressMapEntry);
|
|
goto done;
|
|
}
|
|
}
|
|
//
|
|
// Read the Autodial parameters for this address.
|
|
//
|
|
GetAddressParams(pszAddress, &pAddressMapEntry->params);
|
|
//
|
|
// Add this address to the associated
|
|
// network map.
|
|
//
|
|
LockNetworkMap();
|
|
AddNetworkAddress(
|
|
pAddressMapEntry->pszNetwork,
|
|
pszAddress,
|
|
pAddressMapEntry->params.dwTag);
|
|
UnlockNetworkMap();
|
|
//
|
|
// Add each dialing location onto
|
|
// the address's list.
|
|
//
|
|
for (j = 0; j < dwcEntries; j++) {
|
|
PADDRESS_DIALING_ENTRY pDialingEntry;
|
|
|
|
pDialingEntry = FindAddressDialingEntry(
|
|
pAddressMapEntry,
|
|
pLocationInfo[j].dwLocation);
|
|
if (pDialingEntry == NULL) {
|
|
//
|
|
// The dialing entry doesn't exist.
|
|
// We need to create it.
|
|
//
|
|
pDialingEntry = LocalAlloc(LPTR, sizeof (ADDRESS_DIALING_ENTRY));
|
|
if (pDialingEntry == NULL) {
|
|
RASAUTO_TRACE("ResetAddressMapAddress: LocalAlloc failed");
|
|
goto done;
|
|
}
|
|
RASAUTO_TRACE1(
|
|
"ResetAddressMapAddress: inserting dwLocationID=%d",
|
|
pLocationInfo[j].dwLocation);
|
|
pDialingEntry->fChanged = FALSE;
|
|
pDialingEntry->location = pLocationInfo[j];
|
|
InsertTailList(&pAddressMapEntry->locationHead, &pDialingEntry->ListEntry);
|
|
}
|
|
else if (_wcsicmp(
|
|
pDialingEntry->location.pszEntryName,
|
|
pLocationInfo[j].pszEntryName))
|
|
{
|
|
//
|
|
// The dialing entry does exist, but
|
|
// the phonebook entry has changed.
|
|
//
|
|
RASAUTO_TRACE2(
|
|
"ResetAddressMapAddress: updating dwLocationID=%d with %S",
|
|
pLocationInfo[j].dwLocation,
|
|
RASAUTO_TRACESTRW(pLocationInfo[j].pszEntryName));
|
|
pDialingEntry->location.pszEntryName =
|
|
pLocationInfo[j].pszEntryName;
|
|
}
|
|
else {
|
|
//
|
|
// The dialing entry exists, and we
|
|
// already have it loaded.
|
|
//
|
|
RASAUTO_TRACE1(
|
|
"ResetAddressMapAddress: no changes for dwLocationID=%d",
|
|
pLocationInfo[j].dwLocation);
|
|
LocalFree(pLocationInfo[j].pszEntryName);
|
|
}
|
|
}
|
|
|
|
done:
|
|
LocalFree(pLocationInfo);
|
|
} // ResetAddressMapAddress
|
|
|
|
|
|
|
|
BOOLEAN
|
|
ResetAddressMap(
|
|
IN BOOLEAN fClear
|
|
)
|
|
{
|
|
BOOLEAN fSuccess = FALSE;
|
|
DWORD dwErr, i, dwcb, dwcAddresses;
|
|
LPTSTR *ppAddresses = NULL;
|
|
|
|
//
|
|
// Clear the current addresses from the table.
|
|
// and reset the driver.
|
|
//
|
|
if (fClear) {
|
|
LockAddressMap();
|
|
ClearAddressMap();
|
|
UnlockAddressMap();
|
|
if (!ResetDriver())
|
|
return FALSE;
|
|
}
|
|
//
|
|
// Enumerate the Autodial addresses.
|
|
//
|
|
dwErr = EnumAutodialAddresses(NULL, &dwcb, &dwcAddresses);
|
|
if (dwErr && dwErr != ERROR_BUFFER_TOO_SMALL) {
|
|
RASAUTO_TRACE1(
|
|
"ResetAddressMap: RasEnumAutodialAddresses failed (dwErr=%d)",
|
|
dwErr);
|
|
return FALSE;
|
|
}
|
|
if (!dwcAddresses)
|
|
return TRUE;
|
|
ppAddresses = LocalAlloc(LPTR, dwcb);
|
|
if (ppAddresses == NULL) {
|
|
RASAUTO_TRACE("ResetAddressMap: LocalAlloc failed");
|
|
return FALSE;
|
|
}
|
|
dwErr = EnumAutodialAddresses(
|
|
ppAddresses,
|
|
&dwcb,
|
|
&dwcAddresses);
|
|
if (dwErr) {
|
|
RASAUTO_TRACE1(
|
|
"ResetAddressMap: RasEnumAutodialAddresses failed (dwErr=%d)",
|
|
dwErr);
|
|
goto done;
|
|
}
|
|
//
|
|
// Get the Autodial information for
|
|
// each of the addresses.
|
|
//
|
|
LockAddressMap();
|
|
for (i = 0; i < dwcAddresses; i++)
|
|
ResetAddressMapAddress(ppAddresses[i]);
|
|
UnlockAddressMap();
|
|
LocalFree(ppAddresses);
|
|
ppAddresses = NULL;
|
|
fSuccess = TRUE;
|
|
|
|
done:
|
|
//
|
|
// Free resources.
|
|
//
|
|
if (ppAddresses != NULL)
|
|
LocalFree(ppAddresses);
|
|
|
|
return fSuccess;
|
|
} // ResetAddressMap
|
|
|
|
|
|
|
|
BOOLEAN
|
|
InitializeAddressMap()
|
|
{
|
|
DWORD dwErr;
|
|
|
|
RasInitializeCriticalSection(&AddressMapG.csLock, &dwErr);
|
|
|
|
if(dwErr != ERROR_SUCCESS)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
g_dwCritSecFlags |= RASAUTO_CRITSEC_ADDRMAP;
|
|
|
|
AddressMapG.pTable = NewTable();
|
|
if (AddressMapG.pTable == NULL) {
|
|
RASAUTO_TRACE("InitializeAddressMap: NewTable failed");
|
|
DeleteCriticalSection(&AddressMapG.csLock);
|
|
g_dwCritSecFlags &= ~(RASAUTO_CRITSEC_ADDRMAP);
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
} // InitializeAddressMap
|
|
|
|
VOID
|
|
UninitializeAddressMap()
|
|
{
|
|
if(g_dwCritSecFlags & RASAUTO_CRITSEC_ADDRMAP)
|
|
{
|
|
DeleteCriticalSection(&AddressMapG.csLock);
|
|
g_dwCritSecFlags &= ~(RASAUTO_CRITSEC_ADDRMAP);
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
LockAddressMap()
|
|
{
|
|
EnterCriticalSection(&AddressMapG.csLock);
|
|
} // LockAddressMap
|
|
|
|
|
|
|
|
VOID
|
|
UnlockAddressMap()
|
|
{
|
|
LeaveCriticalSection(&AddressMapG.csLock);
|
|
} // UnlockAddressMap
|
|
|
|
|
|
VOID
|
|
LockDisabledAddresses()
|
|
{
|
|
EnterCriticalSection(&csDisabledAddressesLockG);
|
|
}
|
|
|
|
VOID
|
|
UnlockDisabledAddresses()
|
|
{
|
|
LeaveCriticalSection(&csDisabledAddressesLockG);
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
WriteRegistryFields(
|
|
IN LPTSTR pszAddress,
|
|
IN PADDRESS_MAP_ENTRY pAddressMapEntry
|
|
)
|
|
{
|
|
DWORD dwErr;
|
|
PLIST_ENTRY pEntry;
|
|
PADDRESS_DIALING_ENTRY pDialingEntry;
|
|
|
|
//
|
|
// Write the address garbage-collection params.
|
|
//
|
|
if (pAddressMapEntry->ulModifiedMask & ADDRESS_MAP_FIELD_PARAMS) {
|
|
dwErr = SetAddressParams(pszAddress, &pAddressMapEntry->params);
|
|
if (dwErr)
|
|
return FALSE;
|
|
pAddressMapEntry->ulModifiedMask &= ~ADDRESS_MAP_FIELD_PARAMS;
|
|
}
|
|
//
|
|
// Write the dialing location information.
|
|
//
|
|
if (pAddressMapEntry->ulModifiedMask & ADDRESS_MAP_FIELD_DIALINGLOC) {
|
|
for (pEntry = pAddressMapEntry->locationHead.Flink;
|
|
pEntry != &pAddressMapEntry->locationHead;
|
|
pEntry = pEntry->Flink)
|
|
{
|
|
LPTSTR pszPhonebook, pszEntry;
|
|
|
|
pDialingEntry = CONTAINING_RECORD(
|
|
pEntry,
|
|
ADDRESS_DIALING_ENTRY,
|
|
ListEntry);
|
|
|
|
if (!pDialingEntry->fChanged)
|
|
continue;
|
|
RASAUTO_TRACE3(
|
|
"WriteRegistryFields: writing %S=%d/%S",
|
|
RASAUTO_TRACESTRW(pszAddress),
|
|
pDialingEntry->location.dwLocation,
|
|
pDialingEntry->location.pszEntryName);
|
|
dwErr = SetAddressDialingLocationInfo(
|
|
pszAddress,
|
|
&pDialingEntry->location);
|
|
if (dwErr)
|
|
return FALSE;
|
|
pDialingEntry->fChanged = FALSE;
|
|
}
|
|
//
|
|
// If the network value for this address
|
|
// is NULL, read it now from the registry.
|
|
//
|
|
if (pAddressMapEntry->pszNetwork == NULL) {
|
|
pAddressMapEntry->pszNetwork = AddressToNetwork(pszAddress);
|
|
if (pAddressMapEntry->pszNetwork == NULL) {
|
|
RASAUTO_TRACE1(
|
|
"WriteRegistryFields: AddressToNetwork(%S) failed",
|
|
RASAUTO_TRACESTRW(pszAddress));
|
|
}
|
|
}
|
|
//
|
|
// Clear the modified field mask.
|
|
//
|
|
pAddressMapEntry->ulModifiedMask &= ~ADDRESS_MAP_FIELD_DIALINGLOC;
|
|
}
|
|
|
|
return TRUE;
|
|
} // WriteRegistryFields
|
|
|
|
|
|
|
|
BOOLEAN
|
|
BuildAddressList(
|
|
IN PVOID pArg,
|
|
IN LPTSTR pszAddress,
|
|
IN PVOID pData
|
|
)
|
|
{
|
|
PADDRESS_LIST_INFO pAddressListInfo = (PADDRESS_LIST_INFO)pArg;
|
|
PADDRESS_MAP_ENTRY pAddressMapEntry = (PADDRESS_MAP_ENTRY)pData;
|
|
PADDRESS_MAP_ENTRY pAddrMapEntry;
|
|
PLIST_ENTRY pPrevEntry, pEntry;
|
|
DWORD dwTag = pAddressMapEntry->params.dwTag;
|
|
|
|
//
|
|
// If the address does not have any
|
|
// dialing location information, then
|
|
// skip it.
|
|
//
|
|
if (IsListEmpty(&pAddressMapEntry->locationHead)) {
|
|
pAddressMapEntry->fPruned = TRUE;
|
|
RASAUTO_TRACE1("BuildAddressList: %S has no location info", pszAddress);
|
|
return TRUE;
|
|
}
|
|
dwTag = pAddressMapEntry->params.dwTag < ADDRMAP_TAG_LEARNED ?
|
|
pAddressMapEntry->params.dwTag :
|
|
ADDRMAP_TAG_LEARNED;
|
|
//
|
|
// If the list is empty, insert it at the head.
|
|
// Otherwise sort the items in descending order
|
|
// by last modified time per tag. There is no order
|
|
// for ADDRMAP_TAG_NONE addresses, so we insert them
|
|
// all at the head of the list.
|
|
//
|
|
if (dwTag == ADDRMAP_TAG_NONE ||
|
|
IsListEmpty(&pAddressListInfo->tagHead[dwTag]))
|
|
{
|
|
InsertHeadList(&pAddressListInfo->tagHead[dwTag], &pAddressMapEntry->writerList);
|
|
}
|
|
else {
|
|
BOOLEAN fInserted = FALSE;
|
|
|
|
pPrevEntry = &pAddressListInfo->tagHead[dwTag];
|
|
for (pEntry = pAddressListInfo->tagHead[dwTag].Flink;
|
|
pEntry != &pAddressListInfo->tagHead[dwTag];
|
|
pEntry = pEntry->Flink)
|
|
{
|
|
pAddrMapEntry = CONTAINING_RECORD(pEntry, ADDRESS_MAP_ENTRY, writerList);
|
|
|
|
//
|
|
// There are two cases to skip to the next
|
|
// entry:
|
|
//
|
|
// (1) If the tag is either ADDRMAP_TAG_NONE or
|
|
// ADDRMAP_TAG_USED, then we insert sorted
|
|
// by dwModifiedTime.
|
|
// (2) If the tag is ADDRMAP_TAG_LEARNED, then
|
|
// we insert sorted by dwTag, and then by
|
|
// dwModifiedTime.
|
|
// dwTag.
|
|
//
|
|
if ((dwTag < ADDRMAP_TAG_LEARNED &&
|
|
pAddressMapEntry->params.dwModifiedTime <=
|
|
pAddrMapEntry->params.dwModifiedTime) ||
|
|
(dwTag == ADDRMAP_TAG_LEARNED &&
|
|
(pAddressMapEntry->params.dwTag >
|
|
pAddrMapEntry->params.dwTag) ||
|
|
(pAddressMapEntry->params.dwTag ==
|
|
pAddrMapEntry->params.dwTag &&
|
|
(pAddressMapEntry->params.dwModifiedTime <=
|
|
pAddrMapEntry->params.dwModifiedTime))))
|
|
{
|
|
pPrevEntry = pEntry;
|
|
continue;
|
|
}
|
|
InsertHeadList(pPrevEntry, &pAddressMapEntry->writerList);
|
|
fInserted = TRUE;
|
|
break;
|
|
}
|
|
if (!fInserted) {
|
|
InsertTailList(
|
|
&pAddressListInfo->tagHead[dwTag],
|
|
&pAddressMapEntry->writerList);
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
} // BuildAddressList
|
|
|
|
|
|
|
|
VOID
|
|
MarkAddressList(
|
|
IN PADDRESS_LIST_INFO pAddressListInfo
|
|
)
|
|
{
|
|
DWORD i, dwcAddresses = 0;
|
|
DWORD dwMaxAddresses = GetAutodialParam(RASADP_SavedAddressesLimit);
|
|
PLIST_ENTRY pEntry;
|
|
PADDRESS_MAP_ENTRY pAddressMapEntry;
|
|
|
|
RASAUTO_TRACE1("MarkAddressList: RASADP_SavedAddressesLimit=%d", dwMaxAddresses);
|
|
//
|
|
// Enumerate the entries in the list in order,
|
|
// and mark the fPruned bit if its order in the
|
|
// list exceeds the maximum set by the user.
|
|
// We do not include the ADDRMAP_TAG_NONE address
|
|
// in the address count. All of these addresses
|
|
// always get written.
|
|
//
|
|
for (i = 0; i < 3; i++) {
|
|
for (pEntry = pAddressListInfo->tagHead[i].Flink;
|
|
pEntry != &pAddressListInfo->tagHead[i];
|
|
pEntry = pEntry->Flink)
|
|
{
|
|
pAddressMapEntry = CONTAINING_RECORD(pEntry, ADDRESS_MAP_ENTRY, writerList);
|
|
|
|
//
|
|
// If we exceed the limit of addresses in the
|
|
// registry, we have to delete it.
|
|
//
|
|
if (i == ADDRMAP_TAG_NONE)
|
|
pAddressMapEntry->fPruned = FALSE;
|
|
else
|
|
pAddressMapEntry->fPruned = (++dwcAddresses > dwMaxAddresses);
|
|
}
|
|
}
|
|
} // MarkAddressList
|
|
|
|
|
|
|
|
BOOLEAN
|
|
PruneAddressList(
|
|
IN PVOID pArg,
|
|
IN LPTSTR pszAddress,
|
|
IN PVOID pData
|
|
)
|
|
{
|
|
PADDRESS_MAP_ENTRY pAddressMapEntry = (PADDRESS_MAP_ENTRY)pData;
|
|
|
|
if (pAddressMapEntry->fPruned) {
|
|
RASAUTO_TRACE1("PruneAddressList: NEED TO DELETE ADDRESS %S in the driver!", pszAddress);
|
|
ClearAddressDialingLocationInfo(pszAddress);
|
|
FreeAddressMapEntry(pAddressMapEntry);
|
|
DeleteTableEntry(AddressMapG.pTable, pszAddress);
|
|
}
|
|
|
|
return TRUE;
|
|
} // PruneAddressList
|
|
|
|
|
|
|
|
BOOLEAN
|
|
WriteAddressMap(
|
|
IN PVOID pArg,
|
|
IN LPTSTR pszAddress,
|
|
IN PVOID pData
|
|
)
|
|
{
|
|
PADDRESS_MAP_ENTRY pAddressMapEntry = (PADDRESS_MAP_ENTRY)pData;
|
|
|
|
if (pAddressMapEntry->ulModifiedMask) {
|
|
if (!WriteRegistryFields(
|
|
pszAddress,
|
|
pAddressMapEntry))
|
|
{
|
|
RASAUTO_TRACE("WriteAddressMap: WriteRegistryFields failed");
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
} // WriteAddressMap
|
|
|
|
|
|
|
|
BOOLEAN
|
|
FlushAddressMap()
|
|
{
|
|
ADDRESS_LIST_INFO addressListInfo;
|
|
|
|
//
|
|
// Build a new list sorted by address tag and modified
|
|
// date.
|
|
//
|
|
InitializeListHead(&addressListInfo.tagHead[ADDRMAP_TAG_LEARNED]);
|
|
InitializeListHead(&addressListInfo.tagHead[ADDRMAP_TAG_USED]);
|
|
InitializeListHead(&addressListInfo.tagHead[ADDRMAP_TAG_NONE]);
|
|
EnumTable(AddressMapG.pTable, BuildAddressList, &addressListInfo);
|
|
MarkAddressList(&addressListInfo);
|
|
EnumTable(AddressMapG.pTable, PruneAddressList, NULL);
|
|
//
|
|
// Turn off registry change notifications
|
|
// while we are doing this.
|
|
//
|
|
EnableAutoDialChangeEvent(hAutodialRegChangeG, FALSE);
|
|
EnumTable(AddressMapG.pTable, WriteAddressMap, NULL);
|
|
//
|
|
// Enable registry change events again.
|
|
//
|
|
EnableAutoDialChangeEvent(hAutodialRegChangeG, TRUE);
|
|
|
|
return TRUE;
|
|
} // FlushAddressMap
|
|
|
|
|
|
|
|
ULONG
|
|
AddressMapSize()
|
|
{
|
|
return AddressMapG.pTable->ulSize;
|
|
} // AddressMapSize;
|
|
|
|
|
|
|
|
BOOLEAN
|
|
EnumAddresses(
|
|
IN PVOID pArg,
|
|
IN LPTSTR pszAddress,
|
|
IN PVOID pData
|
|
)
|
|
{
|
|
PADDRESS_ENUM_INFO pEnumInfo = (PADDRESS_ENUM_INFO)pArg;
|
|
|
|
pEnumInfo->pAddresses[pEnumInfo->ulIndex++] = CopyString(pszAddress);
|
|
return TRUE;
|
|
} // EnumAddresses
|
|
|
|
|
|
|
|
BOOLEAN
|
|
ListAddressMapAddresses(
|
|
OUT LPTSTR **ppszAddresses,
|
|
OUT PULONG pulcAddresses
|
|
)
|
|
{
|
|
ADDRESS_ENUM_INFO enumInfo;
|
|
|
|
//
|
|
// Check for an empty list.
|
|
//
|
|
*pulcAddresses = AddressMapG.pTable->ulSize;
|
|
if (!*pulcAddresses) {
|
|
*ppszAddresses = NULL;
|
|
return TRUE;
|
|
}
|
|
//
|
|
// Allocate a list large enough to hold all
|
|
// the addresses.
|
|
//
|
|
*ppszAddresses = LocalAlloc(LPTR, *pulcAddresses * sizeof (LPTSTR));
|
|
if (*ppszAddresses == NULL) {
|
|
RASAUTO_TRACE("ListAddressMapAddresses: LocalAlloc failed");
|
|
return FALSE;
|
|
}
|
|
//
|
|
// Set up the structure for the enumerator
|
|
// procedure.
|
|
//
|
|
enumInfo.ulIndex = 0;
|
|
enumInfo.pAddresses = *ppszAddresses;
|
|
EnumTable(AddressMapG.pTable, EnumAddresses, &enumInfo);
|
|
|
|
return TRUE;
|
|
} // ListAddressMapAddresses
|
|
|
|
|
|
|
|
VOID
|
|
EnumAddressMap(
|
|
IN PHASH_TABLE_ENUM_PROC pProc,
|
|
IN PVOID pArg
|
|
)
|
|
{
|
|
EnumTable(AddressMapG.pTable, pProc, pArg);
|
|
} // EnumAddressMap
|
|
|
|
|
|
|
|
BOOLEAN
|
|
GetAddressDisabled(
|
|
IN LPTSTR pszAddress,
|
|
OUT PBOOLEAN pfDisabled
|
|
)
|
|
{
|
|
PADDRESS_MAP_ENTRY pAddressMapEntry;
|
|
|
|
|
|
{
|
|
DWORD i;
|
|
LPTSTR pszDisabled[] =
|
|
{
|
|
TEXT("wpad"),
|
|
TEXT("pnptriage"),
|
|
TEXT("nttriage"),
|
|
TEXT("ntcore2"),
|
|
TEXT("liveraid")
|
|
};
|
|
|
|
for (i = 0; i < sizeof(pszDisabled)/sizeof(LPTSTR); i++)
|
|
{
|
|
if( (0 == (lstrcmpi(pszDisabled[i], pszAddress)))
|
|
|| (wcsstr(_wcslwr(pszAddress), pszDisabled[i])
|
|
== pszAddress))
|
|
{
|
|
*pfDisabled = TRUE;
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
pAddressMapEntry = GetAddressMapEntry(pszAddress, FALSE);
|
|
if (pAddressMapEntry == NULL) {
|
|
*pfDisabled = FALSE;
|
|
return FALSE;
|
|
}
|
|
*pfDisabled = pAddressMapEntry->fDisabled;
|
|
|
|
return TRUE;
|
|
} // GetAddressDisabled
|
|
|
|
|
|
|
|
BOOLEAN
|
|
SetAddressDisabled(
|
|
IN LPTSTR pszAddress,
|
|
IN BOOLEAN fDisabled
|
|
)
|
|
{
|
|
PADDRESS_MAP_ENTRY pAddressMapEntry;
|
|
|
|
pAddressMapEntry = GetAddressMapEntry(pszAddress, TRUE);
|
|
if (pAddressMapEntry == NULL) {
|
|
RASAUTO_TRACE("SetAddressDisabled: GetAddressMapEntry failed");
|
|
return FALSE;
|
|
}
|
|
pAddressMapEntry->fDisabled = fDisabled;
|
|
|
|
return TRUE;
|
|
} // SetAddressDisabled
|
|
|
|
BOOLEAN
|
|
SetAddressDisabledEx(
|
|
IN LPTSTR pszAddress,
|
|
IN BOOLEAN fDisable
|
|
)
|
|
{
|
|
LONG l;
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
ACD_ENABLE_ADDRESS *pEnableAddress;
|
|
|
|
//
|
|
// .NET bug# 514423 new verbose RASAUTO/RASAUTOU prefast warnings
|
|
//
|
|
if (!pszAddress)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
l = InterlockedIncrement(&g_lRasAutoRunning);
|
|
InterlockedDecrement(&g_lRasAutoRunning);
|
|
|
|
if(l == 1)
|
|
{
|
|
//
|
|
// rasauto isn't running. Bail.
|
|
//
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Also set this address as disabled in the driver
|
|
//
|
|
pEnableAddress = LocalAlloc(LPTR, sizeof(ACD_ENABLE_ADDRESS));
|
|
if(NULL != pEnableAddress)
|
|
{
|
|
NTSTATUS status;
|
|
CHAR *pszNew;
|
|
DWORD cb;
|
|
|
|
cb = WideCharToMultiByte(CP_ACP, 0, pszAddress,
|
|
-1, NULL, 0, NULL, NULL);
|
|
|
|
pszNew = (CHAR*)LocalAlloc(LPTR, cb);
|
|
if (pszNew == NULL) {
|
|
return FALSE;
|
|
}
|
|
|
|
cb = WideCharToMultiByte(CP_ACP, 0, pszAddress,
|
|
-1, pszNew, cb, NULL, NULL);
|
|
|
|
if (!cb) {
|
|
LocalFree(pszNew);
|
|
return FALSE;
|
|
}
|
|
|
|
_strlwr(pszNew);
|
|
|
|
pEnableAddress->fDisable = fDisable;
|
|
RtlCopyMemory(pEnableAddress->addr.szInet,
|
|
pszNew,
|
|
cb);
|
|
|
|
status = NtDeviceIoControlFile(
|
|
hAcdG,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
&ioStatusBlock,
|
|
IOCTL_ACD_ENABLE_ADDRESS,
|
|
pEnableAddress,
|
|
sizeof (ACD_ENABLE_ADDRESS),
|
|
NULL,
|
|
0);
|
|
if (status != STATUS_SUCCESS)
|
|
{
|
|
RASAUTO_TRACE("SetAddressDisabledEx: ioctl failed");
|
|
}
|
|
|
|
LocalFree(pEnableAddress);
|
|
}
|
|
|
|
return TRUE;
|
|
} // SetAddressDisabled
|
|
|
|
|
|
|
|
BOOLEAN
|
|
GetAddressDialingLocationEntry(
|
|
IN LPTSTR pszAddress,
|
|
OUT LPTSTR *ppszEntryName
|
|
)
|
|
{
|
|
DWORD dwErr, dwLocationID;
|
|
PLIST_ENTRY pEntry;
|
|
PADDRESS_MAP_ENTRY pAddressMapEntry;
|
|
PADDRESS_DIALING_ENTRY pDialingEntry;
|
|
|
|
dwErr = TapiCurrentDialingLocation(&dwLocationID);
|
|
if (dwErr)
|
|
return FALSE;
|
|
pAddressMapEntry = GetAddressMapEntry(pszAddress, FALSE);
|
|
if (pAddressMapEntry == NULL || IsListEmpty(&pAddressMapEntry->locationHead))
|
|
return FALSE;
|
|
//
|
|
// Search for the dialing information
|
|
// that maps to the current dialing
|
|
// location.
|
|
//
|
|
for (pEntry = pAddressMapEntry->locationHead.Flink;
|
|
pEntry != &pAddressMapEntry->locationHead;
|
|
pEntry = pEntry->Flink)
|
|
{
|
|
pDialingEntry = CONTAINING_RECORD(
|
|
pEntry,
|
|
ADDRESS_DIALING_ENTRY,
|
|
ListEntry);
|
|
|
|
if (pDialingEntry->location.dwLocation == dwLocationID) {
|
|
*ppszEntryName = CopyString(pDialingEntry->location.pszEntryName);
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
} // GetAddressDialingLocationEntry
|
|
|
|
|
|
|
|
BOOLEAN
|
|
IsAWwwAddress(
|
|
IN LPTSTR pszAddr
|
|
)
|
|
{
|
|
DWORD dwcbAddress;
|
|
DWORD i;
|
|
BOOLEAN fDot = FALSE, fIsAWwwAddress = FALSE;
|
|
|
|
//
|
|
// See if this address starts with "www*.".
|
|
//
|
|
if (!_wcsnicmp(pszAddr, L"www", 3)) {
|
|
dwcbAddress = wcslen(pszAddr);
|
|
//
|
|
// Search for a '.' and something else
|
|
// after the '.'.
|
|
//
|
|
for (i = 3; i < dwcbAddress; i++) {
|
|
if (!fDot)
|
|
fDot = (pszAddr[i] == L'.');
|
|
fIsAWwwAddress = fDot && (pszAddr[i] != L'.');
|
|
if (fIsAWwwAddress)
|
|
break;
|
|
}
|
|
}
|
|
|
|
return fIsAWwwAddress;
|
|
} // IsAWwwAddress
|
|
|
|
|
|
|
|
BOOLEAN
|
|
FindSimilarAddress(
|
|
IN PVOID pArg,
|
|
IN LPTSTR pszAddr,
|
|
IN PVOID pData
|
|
)
|
|
|
|
/*++
|
|
|
|
DESCRIPTION
|
|
This is a table enumerator procedure that searches
|
|
for address with a www-style name or the same
|
|
organization name. For example, it will consider
|
|
"www1.netscape.com" and "www2.netscape.com" equal
|
|
since they share the same organization and domain
|
|
address components.
|
|
|
|
ARGUMENTS
|
|
pArg: a pointer to a MATCH_INFO structure
|
|
|
|
pszAddr: a pointer to the enumerated address
|
|
|
|
ulData: the address's data value
|
|
|
|
RETURN VALUE
|
|
TRUE if the enumeration should continue (match
|
|
not found), or FALSE when the enumerations should
|
|
terminate (match found).
|
|
|
|
--*/
|
|
|
|
{
|
|
BOOLEAN fIsWww = FALSE, fHasOrg = FALSE;
|
|
BOOLEAN fDialingLocationFound;
|
|
PMATCH_INFO pMatchInfo = (PMATCH_INFO)pArg;
|
|
PADDRESS_MAP_ENTRY pAddressMapEntry = (PADDRESS_MAP_ENTRY)pData;
|
|
PLIST_ENTRY pEntry;
|
|
PADDRESS_DIALING_ENTRY pDialingEntry;
|
|
WCHAR szOrganization[ACD_ADDR_INET_LEN];
|
|
|
|
if (pMatchInfo->fWww)
|
|
fIsWww = IsAWwwAddress(pszAddr);
|
|
else if (pMatchInfo->fOrg)
|
|
fHasOrg = GetOrganization(pszAddr, szOrganization);
|
|
//
|
|
// If it has neither a www-style address nor
|
|
// it has an organization, then return
|
|
// immediately.
|
|
//
|
|
if ((pMatchInfo->fWww && !fIsWww) ||
|
|
(pMatchInfo->fOrg && !fHasOrg))
|
|
{
|
|
return TRUE;
|
|
}
|
|
if (fIsWww)
|
|
RASAUTO_TRACE1("FindSimilarAddress: fIsWww=1, %S", pszAddr);
|
|
else {
|
|
RASAUTO_TRACE2(
|
|
"FindSimilarAddress: fHasOrg=1, comparing (%S, %S)",
|
|
pMatchInfo->szOrganization,
|
|
szOrganization);
|
|
}
|
|
//
|
|
// If we're looking for an organization,
|
|
// and the organization's don't match,
|
|
// then return.
|
|
//
|
|
if (fHasOrg && _wcsicmp(pMatchInfo->szOrganization, szOrganization))
|
|
{
|
|
return TRUE;
|
|
}
|
|
//
|
|
// Search for the dialing information
|
|
// that maps to the current dialing
|
|
// location.
|
|
//
|
|
fDialingLocationFound = FALSE;
|
|
for (pEntry = pAddressMapEntry->locationHead.Flink;
|
|
pEntry != &pAddressMapEntry->locationHead;
|
|
pEntry = pEntry->Flink)
|
|
{
|
|
pDialingEntry = CONTAINING_RECORD(
|
|
pEntry,
|
|
ADDRESS_DIALING_ENTRY,
|
|
ListEntry);
|
|
|
|
if (pDialingEntry->location.dwLocation == pMatchInfo->dwLocationID) {
|
|
fDialingLocationFound = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
if (!fDialingLocationFound) {
|
|
RASAUTO_TRACE1("FindSimilarAddress: dialing location %d not found", pMatchInfo->dwLocationID);
|
|
return TRUE;
|
|
}
|
|
//
|
|
// If we already have found a match,
|
|
// then make sure the network is the
|
|
// same for all the matching addresses.
|
|
// If not terminate the enumeration.
|
|
//
|
|
if (pMatchInfo->bFound &&
|
|
pDialingEntry->location.pszEntryName != NULL &&
|
|
pMatchInfo->pDialingEntry->location.pszEntryName != NULL &&
|
|
_wcsicmp(
|
|
pMatchInfo->pDialingEntry->location.pszEntryName,
|
|
pDialingEntry->location.pszEntryName))
|
|
{
|
|
pMatchInfo->bFound = FALSE;
|
|
RASAUTO_TRACE("FindSimilarAddress: returning FALSE");
|
|
return FALSE;
|
|
}
|
|
//
|
|
// Update the closure and continue
|
|
// the enumeration.
|
|
//
|
|
if (!pMatchInfo->bFound) {
|
|
pMatchInfo->bFound = TRUE;
|
|
wcscpy(pMatchInfo->szAddress, pszAddr);
|
|
pMatchInfo->pDialingEntry = pDialingEntry;
|
|
}
|
|
return TRUE;
|
|
} // FindSimilarAddress
|
|
|
|
|
|
|
|
BOOLEAN
|
|
GetSimilarDialingLocationEntry(
|
|
IN LPTSTR pszAddress,
|
|
OUT LPTSTR *ppszEntryName
|
|
)
|
|
|
|
/*++
|
|
|
|
DESCRIPTION
|
|
Parse the organization name from the Internet
|
|
address, and look for an address that we know
|
|
about with the same organization name. If we
|
|
find it, make that address our target address.
|
|
This enables us to treat addresses like
|
|
"www1.netscape.com" and "www2.netscape.com"
|
|
equivalently without having to have all
|
|
combinations in our address map.
|
|
|
|
ARGUMENTS
|
|
pszAddress: a pointer to the original address
|
|
|
|
ppszEntryName: a pointer to the phonebook entry of
|
|
a similar address
|
|
|
|
RETURN VALUE
|
|
TRUE if there is a unique phonebook entry;
|
|
FALSE otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD dwErr;
|
|
MATCH_INFO matchInfo;
|
|
BOOLEAN fIsAWwwAddress = FALSE;
|
|
|
|
//
|
|
// Check to see if this is "www*." style address.
|
|
//
|
|
matchInfo.fWww = IsAWwwAddress(pszAddress);
|
|
//
|
|
// Get the organization for the specified address.
|
|
//
|
|
if (!matchInfo.fWww)
|
|
matchInfo.fOrg = GetOrganization(pszAddress, (LPTSTR)&matchInfo.szOrganization);
|
|
else
|
|
matchInfo.fOrg = FALSE;
|
|
if (!matchInfo.fWww && !matchInfo.fOrg) {
|
|
RASAUTO_TRACE1(
|
|
"GetSimilarDialingLocationEntry: %S is not www and has no organization",
|
|
pszAddress);
|
|
return FALSE;
|
|
}
|
|
RASAUTO_TRACE4(
|
|
"GetSimilarDialingLocationEntry: %S: fWww=%d, fOrg=%d, org is %S",
|
|
pszAddress,
|
|
matchInfo.fWww,
|
|
matchInfo.fOrg,
|
|
matchInfo.szOrganization);
|
|
//
|
|
// Search the table.
|
|
//
|
|
dwErr = TapiCurrentDialingLocation(&matchInfo.dwLocationID);
|
|
if (dwErr) {
|
|
RASAUTO_TRACE1(
|
|
"GetSimilarDialingLocationEntry: TapiCurrentDialingLocation failed (dwErr=%d)",
|
|
dwErr);
|
|
return FALSE;
|
|
}
|
|
matchInfo.bFound = FALSE;
|
|
RtlZeroMemory(&matchInfo.szAddress, sizeof (matchInfo.szAddress));
|
|
matchInfo.pDialingEntry = NULL;
|
|
EnumTable(AddressMapG.pTable, FindSimilarAddress, &matchInfo);
|
|
//
|
|
// If we didn't find it, then return.
|
|
//
|
|
if (!matchInfo.bFound) {
|
|
RASAUTO_TRACE1(
|
|
"GetSimilarDialingLocationEntry: %S: did not find matching org",
|
|
pszAddress);
|
|
return FALSE;
|
|
}
|
|
RASAUTO_TRACE2(
|
|
"GetSimilarDialingLocationEntry: %S: matching address is %S",
|
|
pszAddress,
|
|
matchInfo.szAddress);
|
|
//
|
|
// Return the dialing location entry for
|
|
// the matching address.
|
|
//
|
|
return GetAddressDialingLocationEntry(matchInfo.szAddress, ppszEntryName);
|
|
} // GetSimilarDialingLocationEntry
|
|
|
|
|
|
|
|
BOOLEAN
|
|
SetAddressLastFailedConnectTime(
|
|
IN LPTSTR pszAddress
|
|
)
|
|
{
|
|
PADDRESS_MAP_ENTRY pAddressMapEntry;
|
|
|
|
pAddressMapEntry = GetAddressMapEntry(pszAddress, TRUE);
|
|
if (pAddressMapEntry == NULL) {
|
|
RASAUTO_TRACE("SetAddressLastFailedConnectTime: GetAddressMapEntry failed");
|
|
return FALSE;
|
|
}
|
|
pAddressMapEntry->dwFailedConnectTicks = GetTickCount();
|
|
|
|
return TRUE;
|
|
} // SetAddressLastFailedConnectTime
|
|
|
|
|
|
|
|
BOOLEAN
|
|
GetAddressLastFailedConnectTime(
|
|
IN LPTSTR pszAddress,
|
|
OUT LPDWORD lpdwTicks
|
|
)
|
|
{
|
|
PADDRESS_MAP_ENTRY pAddressMapEntry;
|
|
|
|
pAddressMapEntry = GetAddressMapEntry(pszAddress, FALSE);
|
|
if (pAddressMapEntry == NULL) {
|
|
RASAUTO_TRACE("GetAddressLastFailedConnectTime: GetAddressMapEntry failed");
|
|
return FALSE;
|
|
}
|
|
*lpdwTicks = pAddressMapEntry->dwFailedConnectTicks;
|
|
|
|
return (*lpdwTicks != 0);
|
|
} // GetAddressLastFailedConnectTime
|
|
|
|
|
|
|
|
BOOLEAN
|
|
SetAddressTag(
|
|
IN LPTSTR pszAddress,
|
|
IN DWORD dwTag
|
|
)
|
|
{
|
|
PADDRESS_MAP_ENTRY pAddressMapEntry;
|
|
time_t clock = time(0);
|
|
|
|
pAddressMapEntry = GetAddressMapEntry(pszAddress, TRUE);
|
|
if (pAddressMapEntry == NULL) {
|
|
RASAUTO_TRACE("SetAddressWeight: GetAddressMapEntry failed");
|
|
return FALSE;
|
|
}
|
|
if (dwTag == ADDRMAP_TAG_LEARNED) {
|
|
LockNetworkMap();
|
|
dwTag =
|
|
ADDRMAP_TAG_LEARNED +
|
|
GetNetworkConnectionTag(
|
|
pAddressMapEntry->pszNetwork,
|
|
FALSE);
|
|
if (dwTag < pAddressMapEntry->params.dwTag) {
|
|
//
|
|
// We want to use this tag. Call
|
|
// GetNetworkConnectionTag(TRUE) to
|
|
// increment the next tag.
|
|
//
|
|
(void)GetNetworkConnectionTag(pAddressMapEntry->pszNetwork, TRUE);
|
|
}
|
|
UnlockNetworkMap();
|
|
}
|
|
//
|
|
// If there is no modified time associated with this
|
|
// address then it can only have a tag of ADDR_TAG_NONE.
|
|
//
|
|
if (!pAddressMapEntry->params.dwModifiedTime ||
|
|
dwTag >= pAddressMapEntry->params.dwTag)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
pAddressMapEntry->params.dwTag = dwTag;
|
|
pAddressMapEntry->params.dwModifiedTime = (DWORD)clock;
|
|
pAddressMapEntry->ulModifiedMask |= ADDRESS_MAP_FIELD_PARAMS;
|
|
|
|
return TRUE;
|
|
} // SetAddressTag
|
|
|
|
|
|
|
|
BOOLEAN
|
|
GetAddressTag(
|
|
IN LPTSTR pszAddress,
|
|
OUT LPDWORD lpdwTag
|
|
)
|
|
{
|
|
PADDRESS_MAP_ENTRY pAddressMapEntry;
|
|
|
|
pAddressMapEntry = GetAddressMapEntry(pszAddress, FALSE);
|
|
if (pAddressMapEntry == NULL) {
|
|
RASAUTO_TRACE("GetAddressWeight: GetAddressMapEntry failed");
|
|
return FALSE;
|
|
}
|
|
*lpdwTag = pAddressMapEntry->params.dwTag;
|
|
|
|
return TRUE;
|
|
} // GetAddressWeight
|
|
|
|
|
|
|
|
VOID
|
|
ResetLearnedAddressIndex()
|
|
{
|
|
dwLearnedAddressIndexG = 0;
|
|
} // ResetLearnedAddressIndex
|
|
|
|
|
|
|
|
BOOLEAN
|
|
GetAddressNetwork(
|
|
IN LPTSTR pszAddress,
|
|
OUT LPTSTR *ppszNetwork
|
|
)
|
|
{
|
|
PADDRESS_MAP_ENTRY pAddressMapEntry;
|
|
|
|
pAddressMapEntry = GetAddressMapEntry(pszAddress, FALSE);
|
|
if (pAddressMapEntry == NULL || pAddressMapEntry->pszNetwork == NULL)
|
|
return FALSE;
|
|
*ppszNetwork = CopyString(pAddressMapEntry->pszNetwork);
|
|
|
|
return TRUE;
|
|
} // GetAddressNetwork
|
|
|
|
|
|
|
|
BOOLEAN
|
|
SetAddressDialingLocationEntry(
|
|
IN LPTSTR pszAddress,
|
|
IN LPTSTR pszEntryName
|
|
)
|
|
{
|
|
DWORD dwErr, dwLocationID;
|
|
BOOLEAN fFound = FALSE;
|
|
PLIST_ENTRY pEntry;
|
|
PADDRESS_MAP_ENTRY pAddressMapEntry;
|
|
PADDRESS_DIALING_ENTRY pDialingEntry;
|
|
|
|
//
|
|
// Get the current dialing location.
|
|
//
|
|
dwErr = TapiCurrentDialingLocation(&dwLocationID);
|
|
if (dwErr)
|
|
return FALSE;
|
|
//
|
|
// Find the address map entry that
|
|
// corresponds to the address.
|
|
//
|
|
pAddressMapEntry = GetAddressMapEntry(pszAddress, TRUE);
|
|
if (pAddressMapEntry == NULL) {
|
|
RASAUTO_TRACE("SetAddressDialingLocationEntry: GetAddressMapEntry failed");
|
|
return FALSE;
|
|
}
|
|
//
|
|
// Search for the existing dialing
|
|
// information that maps to the current
|
|
// dialing location.
|
|
//
|
|
for (pEntry = pAddressMapEntry->locationHead.Flink;
|
|
pEntry != &pAddressMapEntry->locationHead;
|
|
pEntry = pEntry->Flink)
|
|
{
|
|
pDialingEntry = CONTAINING_RECORD(
|
|
pEntry,
|
|
ADDRESS_DIALING_ENTRY,
|
|
ListEntry);
|
|
|
|
if (pDialingEntry->location.dwLocation == dwLocationID) {
|
|
fFound = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
//
|
|
// If we didn't find one, then
|
|
// create a new one.
|
|
//
|
|
if (!fFound) {
|
|
pDialingEntry = LocalAlloc(LPTR, sizeof (ADDRESS_DIALING_ENTRY));
|
|
if (pDialingEntry == NULL) {
|
|
RASAUTO_TRACE("SetAddressDialingLocationEntry: LocalAlloc failed");
|
|
return FALSE;
|
|
}
|
|
pDialingEntry->location.dwLocation = dwLocationID;
|
|
InsertTailList(&pAddressMapEntry->locationHead, &pDialingEntry->ListEntry);
|
|
}
|
|
//
|
|
// Update the dialing location structure
|
|
// with the new values.
|
|
//
|
|
pDialingEntry->fChanged = TRUE;
|
|
if (pDialingEntry->location.pszEntryName != NULL)
|
|
LocalFree(pDialingEntry->location.pszEntryName);
|
|
pDialingEntry->location.pszEntryName = CopyString(pszEntryName);
|
|
pAddressMapEntry->ulModifiedMask |= ADDRESS_MAP_FIELD_DIALINGLOC;
|
|
|
|
return TRUE;
|
|
} // SetAddressDialingLocationEntry
|
|
|
|
|
|
|
|
VOID
|
|
ResetDisabledAddresses(VOID)
|
|
{
|
|
HKEY hkey = NULL;
|
|
DWORD dwErr, i, dwi, dwLength, dwDisp, dwcbDisabledAddresses, dwType;
|
|
LPTSTR pszStart, pszNull, pszDisabledAddresses;
|
|
|
|
RASAUTO_TRACE("resetting disabled addresses");
|
|
|
|
ClearTable(pDisabledAddressesG);
|
|
|
|
//
|
|
// Hold the impersonation lock because otherwise
|
|
// hkeycug may be free from under this function.
|
|
//
|
|
|
|
LockImpersonation();
|
|
|
|
//
|
|
// Make sure that we have hkcu
|
|
//
|
|
dwErr = DwGetHkcu();
|
|
|
|
if(ERROR_SUCCESS != dwErr)
|
|
{
|
|
goto done;
|
|
}
|
|
|
|
dwErr = RegCreateKeyEx(
|
|
hkeyCUG,
|
|
AUTODIAL_REGCONTROLBASE,
|
|
0,
|
|
NULL,
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_ALL_ACCESS,
|
|
NULL,
|
|
&hkey,
|
|
&dwDisp);
|
|
if (dwErr) {
|
|
RASAUTO_TRACE1("ResetDisabledAddresses: RegCreateKey failed (dwErr=%d)", dwErr);
|
|
goto done;
|
|
}
|
|
if (RegGetValue(
|
|
hkey,
|
|
AUTODIAL_REGDISABLEDADDRVALUE,
|
|
&pszDisabledAddresses,
|
|
&dwcbDisabledAddresses,
|
|
&dwType) &&
|
|
(REG_MULTI_SZ == dwType) &&
|
|
dwcbDisabledAddresses)
|
|
{
|
|
//
|
|
// The registry key exists. Load only the addresses
|
|
// found in the registry into the table.
|
|
//
|
|
pszStart = pszDisabledAddresses;
|
|
for (;;) {
|
|
if (*pszStart == TEXT('\0'))
|
|
break;
|
|
pszNull = _tcschr(pszStart, '\0');
|
|
RASAUTO_TRACE1(
|
|
"ResetDisabledAddresses: adding %S as a disabled address",
|
|
pszStart);
|
|
PutTableEntry(pDisabledAddressesG, pszStart, NULL);
|
|
pszStart = pszNull + 1;
|
|
}
|
|
LocalFree(pszDisabledAddresses);
|
|
}
|
|
else {
|
|
//
|
|
// Initialize the disabled address table
|
|
// with the list of default disabled addresses.
|
|
//
|
|
dwcbDisabledAddresses = 1; // account for extra NULL at the end
|
|
for (i = 0; i < MAX_DISABLED_ADDRESSES; i++) {
|
|
RASAUTO_TRACE1(
|
|
"ResetDisabledAddresses: adding %S as a disabled address",
|
|
szDisabledAddresses[i]);
|
|
PutTableEntry(pDisabledAddressesG, szDisabledAddresses[i], NULL);
|
|
dwcbDisabledAddresses += _tcslen(szDisabledAddresses[i]) + 1;
|
|
}
|
|
pszDisabledAddresses = LocalAlloc(
|
|
LPTR,
|
|
dwcbDisabledAddresses * sizeof (TCHAR));
|
|
if (pszDisabledAddresses != NULL) {
|
|
*pszDisabledAddresses = TEXT('\0');
|
|
//
|
|
// A REG_MULTI_SZ has the strings separated by
|
|
// a NULL character and two NULL characters at
|
|
// the end.
|
|
//
|
|
for (i = 0, dwi = 0; i < MAX_DISABLED_ADDRESSES; i++) {
|
|
_tcscpy(&pszDisabledAddresses[dwi], szDisabledAddresses[i]);
|
|
dwi += _tcslen(szDisabledAddresses[i]) + 1;
|
|
}
|
|
dwErr = RegSetValueEx(
|
|
hkey,
|
|
AUTODIAL_REGDISABLEDADDRVALUE,
|
|
0,
|
|
REG_MULTI_SZ,
|
|
(PVOID)pszDisabledAddresses,
|
|
dwcbDisabledAddresses * sizeof (TCHAR));
|
|
if (dwErr)
|
|
RASAUTO_TRACE1("ResetDisabledAddresses: RegSetValue failed (dwErr=%d)", dwErr);
|
|
LocalFree(pszDisabledAddresses);
|
|
}
|
|
}
|
|
|
|
done:
|
|
|
|
if(NULL != hkey)
|
|
{
|
|
RegCloseKey(hkey);
|
|
}
|
|
|
|
UnlockImpersonation();
|
|
} // ResetDisabledAddresses
|
|
|
|
//
|
|
// Handles a new user coming active in the system (either by logging in or by
|
|
// FUS.
|
|
//
|
|
DWORD
|
|
AcsHandleNewUser(
|
|
IN HANDLE* phProcess)
|
|
{
|
|
DWORD dwErr = NO_ERROR;
|
|
HANDLE hProcess = *phProcess;
|
|
DWORD i;
|
|
|
|
do
|
|
{
|
|
//
|
|
// make sure that we think there is no user currently
|
|
// active.
|
|
//
|
|
if (hProcess != NULL)
|
|
{
|
|
RASAUTO_TRACE(
|
|
"AcsHandleNewUser: spurious signal of RasAutodialNewLogonUser event!");
|
|
break;
|
|
}
|
|
|
|
RASAUTO_TRACE("AcsHandleNewUser: new user came active");
|
|
|
|
//
|
|
// Refresh the impersonation token for this thread with that of the
|
|
// newly logged-in user. You may have to wait for the shell to
|
|
// start up.
|
|
//
|
|
for (i = 0; i < 15; i++)
|
|
{
|
|
Sleep(1000);
|
|
hProcess = RefreshImpersonation(hProcess);
|
|
if (hProcess != NULL)
|
|
{
|
|
break;
|
|
}
|
|
RASAUTO_TRACE("AcsHandleNewUser: waiting for shell startup");
|
|
}
|
|
|
|
if (hProcess == NULL)
|
|
{
|
|
RASAUTO_TRACE("AcsHandleNewUser: wait for shell startup failed!");
|
|
dwErr = ERROR_CAN_NOT_COMPLETE;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Load in the list of permanently disabled addresses.
|
|
//
|
|
LockDisabledAddresses();
|
|
ResetDisabledAddresses();
|
|
UnlockDisabledAddresses();
|
|
|
|
//
|
|
// Load in the address map from the registry.
|
|
//
|
|
if (!ResetAddressMap(TRUE))
|
|
{
|
|
RASAUTO_TRACE("AcsHandleNewUser: ResetAddressMap failed");
|
|
dwErr = ERROR_CAN_NOT_COMPLETE;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Calculate the initial network connectivity.
|
|
//
|
|
if (!UpdateNetworkMap(TRUE))
|
|
{
|
|
RASAUTO_TRACE("AcsHandleNewUser: UpdateNetworkMap failed");
|
|
dwErr = ERROR_CAN_NOT_COMPLETE;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Reset the "disable autodial for this login session" flag.
|
|
//
|
|
SetAutodialParam(RASADP_LoginSessionDisable, 0);
|
|
|
|
//
|
|
// Create an event to monitor AutoDial
|
|
// registry changes.
|
|
//
|
|
dwErr = CreateAutoDialChangeEvent(&hAutodialRegChangeG);
|
|
if (dwErr)
|
|
{
|
|
RASAUTO_TRACE1("AcsHandleNewUser: CreateAutoDialChangeEvent failed (dwErr=%d)", dwErr);
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Enable the driver for notifications.
|
|
//
|
|
if (!EnableDriver())
|
|
{
|
|
RASAUTO_TRACE("AcsHandleNewUser: EnableDriver failed!");
|
|
dwErr = ERROR_CAN_NOT_COMPLETE;
|
|
break;
|
|
}
|
|
|
|
}while (FALSE);
|
|
|
|
// Cleanup
|
|
{
|
|
*phProcess = hProcess;
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
DWORD
|
|
AcsAddressMapThread(
|
|
LPVOID lpArg
|
|
)
|
|
|
|
/*++
|
|
|
|
DESCRIPTION
|
|
Periodically enumerate the disabled address list and
|
|
age-out (enable) old disabled addresses.
|
|
|
|
ARGUMENTS
|
|
None.
|
|
|
|
RETURN VALUE
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS status;
|
|
BOOLEAN bStatus;
|
|
DWORD dwNow, dwLastFlushTicks = 0, dwLastAgeTicks = 0;
|
|
DWORD dwFlushFlags, dwErr, dwTimeout, dwcEvents;
|
|
HANDLE hProcess = NULL;
|
|
HANDLE hEvents[8];
|
|
|
|
//
|
|
// Create the table that contains the disabled addresses
|
|
// for the user. These are addresses that never cause
|
|
// Autodial attempts.
|
|
//
|
|
LockDisabledAddresses();
|
|
pDisabledAddressesG = NewTable();
|
|
UnlockDisabledAddresses();
|
|
if (pDisabledAddressesG == NULL) {
|
|
RASAUTO_TRACE("AcsAddressMapThread: NewTable failed");
|
|
return GetLastError();
|
|
}
|
|
//
|
|
// We can't load the RAS DLLs in the main line
|
|
// of this system service's initialization, or
|
|
// we will cause a deadlock in the service
|
|
// controller, so we do it here.
|
|
//
|
|
if (!LoadRasDlls()) {
|
|
RASAUTO_TRACE("AcsAddressMapThread: LoadRasDlls failed");
|
|
return GetLastError();
|
|
}
|
|
//
|
|
// Initialize the first entry of our
|
|
// event array for WaitForMutlipleObjects
|
|
// below.
|
|
//
|
|
hEvents[0] = hTerminatingG;
|
|
hEvents[1] = hNewLogonUserG;
|
|
hEvents[2] = hNewFusG;
|
|
hEvents[3] = hPnpEventG;
|
|
hEvents[4] = hConnectionEventG;
|
|
|
|
//
|
|
// Manually set hNewLogonUserG before we
|
|
// start to force us to check for a user
|
|
// logged into the workstation. We need
|
|
// to do this because userinit.exe signals
|
|
// this event upon logon, but it may
|
|
// run before this service is started
|
|
// after boot.
|
|
//
|
|
if (RefreshImpersonation(NULL) != NULL)
|
|
SetEvent(hNewLogonUserG);
|
|
//
|
|
// Periodically write changes to the registry,
|
|
// and age timeout addresses.
|
|
//
|
|
for (;;) {
|
|
//
|
|
// Unload any user-based resources before
|
|
// a potentially long-term wait.
|
|
//
|
|
// PrepareForLongWait();
|
|
//
|
|
// Construct the event array for
|
|
// WaitForMultipleObjects.
|
|
//
|
|
if (hProcess != NULL) {
|
|
hEvents[5] = hTapiChangeG;
|
|
hEvents[6] = hAutodialRegChangeG;
|
|
hEvents[7] = hLogoffUserG;
|
|
dwcEvents = 8;
|
|
}
|
|
else {
|
|
hEvents[5] = NULL;
|
|
hEvents[6] = NULL;
|
|
hEvents[7] = NULL;
|
|
dwcEvents = 5;
|
|
}
|
|
|
|
RASAUTO_TRACE1("AcsAddressMapThread: waiting for events..dwcEvents = %d", dwcEvents);
|
|
status = WaitForMultipleObjects(
|
|
dwcEvents,
|
|
hEvents,
|
|
FALSE,
|
|
INFINITE);
|
|
RASAUTO_TRACE1(
|
|
"AcsAddressMapThread: WaitForMultipleObjects returned %d",
|
|
status);
|
|
//
|
|
// RASAUTO_TRACE() who we think the currently
|
|
// impersonated user is.
|
|
//
|
|
TraceCurrentUser();
|
|
//
|
|
// Process the WaitForMultipleObjects() results.
|
|
//
|
|
if (status == WAIT_OBJECT_0 || status == WAIT_FAILED) {
|
|
RASAUTO_TRACE1("AcsAddressMapThread: status=%d: shutting down", status);
|
|
break;
|
|
}
|
|
else if (status == WAIT_OBJECT_0 + 1)
|
|
{
|
|
AcsHandleNewUser(&hProcess);
|
|
}
|
|
else if (status == WAIT_OBJECT_0 + 2)
|
|
{
|
|
//
|
|
// A new user has fast-user-switched to the console.
|
|
//
|
|
// XP 353082
|
|
//
|
|
// The service control handler will have set the
|
|
// new active session id so we just need to refresh
|
|
// impersonation.
|
|
//
|
|
RevertImpersonation();
|
|
hProcess = NULL;
|
|
AcsHandleNewUser(&hProcess);
|
|
}
|
|
else if (status == WAIT_OBJECT_0 + 3)
|
|
{
|
|
//
|
|
// A pnp event has occured that may affect network
|
|
// connectivity
|
|
//
|
|
// XP 364593
|
|
//
|
|
// Recalculate what networks are up/down.
|
|
//
|
|
RASAUTO_TRACE("AcsAddressMapThread: pnp event signaled");
|
|
if (!ResetAddressMap(TRUE))
|
|
{
|
|
RASAUTO_TRACE("AcsAddressMapThread: ResetAddressMap failed");
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Calculate the initial network connectivity.
|
|
//
|
|
if (!UpdateNetworkMap(TRUE))
|
|
{
|
|
RASAUTO_TRACE("AcsAddressMapThread: UpdateNetworkMap failed");
|
|
continue;
|
|
}
|
|
|
|
if (!EnableDriver()) {
|
|
RASAUTO_TRACE("AcsAddressMapThread: EnableDriver failed!");
|
|
continue;
|
|
}
|
|
|
|
}
|
|
else if (status == WAIT_OBJECT_0 + 4) {
|
|
//
|
|
// A RAS connection has been created
|
|
// or destroyed. Flush the address
|
|
// map to the registry.
|
|
//
|
|
RASAUTO_TRACE("AcsAddressMapThread: RAS connection change");
|
|
if (hProcess != NULL) {
|
|
LockAddressMap();
|
|
FlushAddressMap();
|
|
UnlockAddressMap();
|
|
ResetAddressMap(FALSE);
|
|
|
|
if (!UpdateNetworkMap(FALSE))
|
|
RASAUTO_TRACE("AcsAddressMapThread: UpdateNetworkMap failed");
|
|
}
|
|
}
|
|
else if (status == WAIT_OBJECT_0 + 5) {
|
|
//
|
|
// Process the TAPI event that just ocurred.
|
|
//
|
|
RASAUTO_TRACE("AcsAddressMapThread: TAPI changed");
|
|
ProcessTapiChangeEvent();
|
|
//
|
|
// Enable the driver for notifications
|
|
// for possibly a new dialing location.
|
|
//
|
|
if (!EnableDriver()) {
|
|
RASAUTO_TRACE("AcsAddressMapThread: EnableDriver failed!");
|
|
continue;
|
|
}
|
|
}
|
|
else if (status == WAIT_OBJECT_0 + 6) {
|
|
//
|
|
// The Autodial registry changed. Reset the
|
|
// address map.
|
|
//
|
|
RASAUTO_TRACE("AcsAddressMapThread: registry changed");
|
|
if (ExternalAutoDialChangeEvent()) {
|
|
//
|
|
// We fake this today by making it appear
|
|
// a new user has logged in. We definitely
|
|
// could be smarter about how we do this
|
|
// in the future.
|
|
//
|
|
if (!ResetAddressMap(FALSE)) {
|
|
RASAUTO_TRACE("AcsAddressMapThread: ResetAddressMap failed");
|
|
continue;
|
|
}
|
|
}
|
|
//
|
|
// Re-register the change notification.
|
|
//
|
|
NotifyAutoDialChangeEvent(hAutodialRegChangeG);
|
|
//
|
|
// Enable the driver for notifications
|
|
// for possibly a new enabled value for
|
|
// the current dialing location.
|
|
//
|
|
if (!EnableDriver()) {
|
|
RASAUTO_TRACE("AcsAddressMapThread: EnableDriver failed!");
|
|
continue;
|
|
}
|
|
}
|
|
else if (status == WAIT_OBJECT_0 + 7) {
|
|
//
|
|
// The user is logging out.
|
|
//
|
|
RASAUTO_TRACE("AcsAddressThread: user is logging out");
|
|
//
|
|
// Write out the address map to the registry
|
|
// before we reset.
|
|
//
|
|
LockAddressMap();
|
|
FlushAddressMap();
|
|
ClearAddressMap();
|
|
UnlockAddressMap();
|
|
//
|
|
// Clear the network database.
|
|
//
|
|
LockNetworkMap();
|
|
ClearNetworkMap();
|
|
UnlockNetworkMap();
|
|
//
|
|
// Remove our registry change event.
|
|
//
|
|
CloseAutoDialChangeEvent(hAutodialRegChangeG);
|
|
hAutodialRegChangeG = NULL;
|
|
//
|
|
// Clear out the user tokens.
|
|
//
|
|
RevertImpersonation();
|
|
hProcess = NULL;
|
|
//
|
|
// Reset the driver.
|
|
//
|
|
ResetDriver();
|
|
//
|
|
// Unload HKEY_CURRENT_USER.
|
|
//
|
|
// PrepareForLongWait();
|
|
//
|
|
// Signal winlogon that we have flushed
|
|
// HKEY_CURRENT_USER.
|
|
//
|
|
SetEvent(hLogoffUserDoneG);
|
|
}
|
|
}
|
|
|
|
RASAUTO_TRACE("AcsAddressMapThread: exiting");
|
|
return 0;
|
|
} // AcsAddressMapThread
|
|
|
|
|
|
|