// Routing table tracking main
void RouteTrackingMain(SESSION *s)
{
ROUTE_TRACKING *t;
UINT64 now;
ROUTE_TABLE *table;
ROUTE_ENTRY *rs;
bool changed = false;
bool check = false;
bool any_modified = false;
// Validate arguments
if (s == NULL)
{
return;
}
if (s->ClientModeAndUseVLan == false)
{
return;
}
// Get the state
t = ((VLAN *)s->PacketAdapter->Param)->RouteState;
if (t == NULL)
{
return;
}
// Current time
PROBE_STR("RouteTrackingMain 1");
now = Tick64();
if (t->RouteChange != NULL)
{
if (t->NextRouteChangeCheckTime == 0 ||
t->NextRouteChangeCheckTime <= now)
{
t->NextRouteChangeCheckTime = now + 1000ULL;
check = IsRouteChanged(t->RouteChange);
if (check)
{
Debug("*** Routing Table Changed ***\n");
t->NextTrackingTime = 0;
}
}
}
if (t->NextTrackingTime != 0 && t->NextTrackingTime > now)
{
if (s->UseUdpAcceleration && s->UdpAccel != NULL && s->UdpAccel->NatT_IP_Changed)
{
// Check always if the IP address of the NAT-T server has changed
}
else
{
PROBE_STR("RouteTrackingMain 2");
return;
}
}
PROBE_STR("RouteTrackingMain 3");
if (s->UseUdpAcceleration && s->UdpAccel != NULL)
{
IP nat_t_ip;
s->UdpAccel->NatT_IP_Changed = false;
Zero(&nat_t_ip, sizeof(nat_t_ip));
Lock(s->UdpAccel->NatT_Lock);
{
Copy(&nat_t_ip, &s->UdpAccel->NatT_IP, sizeof(IP));
}
Unlock(s->UdpAccel->NatT_Lock);
// Add a route to the NAT-T server
if (IsZeroIp(&nat_t_ip) == false)
{
if (t->RouteToNatTServer == NULL)
{
if (t->RouteToEight != NULL)
{
ROUTE_ENTRY *e = Clone(t->RouteToEight, sizeof(ROUTE_ENTRY));
char ip_str[64];
char ip_str2[64];
Copy(&e->DestIP, &nat_t_ip, sizeof(IP));
e->Metric = e->OldIfMetric;
IPToStr(ip_str, sizeof(ip_str), &e->DestIP);
IPToStr(ip_str2, sizeof(ip_str2), &e->GatewayIP);
t->RouteToNatTServer = e;
if (AddRouteEntry(t->RouteToNatTServer))
{
Debug("Adding Static Route to %s via %s metric %u: ok.\n", ip_str, ip_str2, e->Metric);
}
else
{
FreeRouteEntry(t->RouteToNatTServer);
t->RouteToNatTServer = NULL;
}
}
}
}
}
// Get the current routing table
table = GetRouteTable();
rs = t->RouteToServer;
if (table != NULL)
{
UINT i;
bool route_to_server_erased = true;
bool is_vlan_want_to_be_default_gateway = false;
UINT vlan_default_gatewat_metric = 0;
UINT other_if_default_gateway_metric_min = INFINITE;
// Get whether the routing table have been changed
if (t->LastRoutingTableHash != table->HashedValue)
{
t->LastRoutingTableHash = table->HashedValue;
changed = true;
}
//DebugPrintRouteTable(table);
// Scan the routing table
for (i = 0;i < table->NumEntry;i++)
{
ROUTE_ENTRY *e = table->Entry[i];
if (rs != NULL)
{
if (CmpIpAddr(&e->DestIP, &rs->DestIP) == 0 &&
CmpIpAddr(&e->DestMask, &rs->DestMask) == 0
// && CmpIpAddr(&e->GatewayIP, &rs->GatewayIP) == 0
// && e->InterfaceID == rs->InterfaceID &&
// e->LocalRouting == rs->LocalRouting &&
// e->Metric == rs->Metric
)
{
// Routing entry to the server that added at the time of connection is found
route_to_server_erased = false;
}
}
// Search for the default gateway
if (IPToUINT(&e->DestIP) == 0 &&
IPToUINT(&e->DestMask) == 0)
{
Debug("e->InterfaceID = %u, t->VLanInterfaceId = %u\n",
e->InterfaceID, t->VLanInterfaceId);
if (e->InterfaceID == t->VLanInterfaceId)
{
// The virtual LAN card think that he want to be a default gateway
is_vlan_want_to_be_default_gateway = true;
vlan_default_gatewat_metric = e->Metric;
if (vlan_default_gatewat_metric >= 2 &&
t->OldDefaultGatewayMetric == (vlan_default_gatewat_metric - 1))
{
// Restore because the PPP server rewrites
// the routing table selfishly
DeleteRouteEntry(e);
e->Metric--;
AddRouteEntry(e);
Debug("** Restore metric destroyed by PPP.\n");
any_modified = true;
}
// Keep this entry
if (t->DefaultGatewayByVLan != NULL)
{
// Delete if there is one added last time
FreeRouteEntry(t->DefaultGatewayByVLan);
}
t->DefaultGatewayByVLan = ZeroMalloc(sizeof(ROUTE_ENTRY));
Copy(t->DefaultGatewayByVLan, e, sizeof(ROUTE_ENTRY));
t->OldDefaultGatewayMetric = vlan_default_gatewat_metric;
}
else
{
// There are default gateway other than the virtual LAN card
// Save the metric value of the default gateway
if (other_if_default_gateway_metric_min > e->Metric)
{
// Ignore the metric value of all PPP connection in the case of Windows Vista
if (MsIsVista() == false || e->PPPConnection == false)
{
other_if_default_gateway_metric_min = e->Metric;
}
else
{
// a PPP is used to Connect to the network
// in using Windows Vista
t->VistaAndUsingPPP = true;
}
}
}
}
}
if (t->VistaAndUsingPPP)
{
if (t->DefaultGatewayByVLan != NULL)
{
if (is_vlan_want_to_be_default_gateway)
{
if (t->VistaOldDefaultGatewayByVLan == NULL || Cmp(t->VistaOldDefaultGatewayByVLan, t->DefaultGatewayByVLan, sizeof(ROUTE_ENTRY)) != 0)
{
ROUTE_ENTRY *e;
// Add the route of 0.0.0.0/1 and 128.0.0.0/1
// to the system if the virtual LAN card should be
// the default gateway in the case of the connection
// using PPP in Windows Vista
if (t->VistaOldDefaultGatewayByVLan != NULL)
{
FreeRouteEntry(t->VistaOldDefaultGatewayByVLan);
}
if (t->VistaDefaultGateway1 != NULL)
{
DeleteRouteEntry(t->VistaDefaultGateway1);
FreeRouteEntry(t->VistaDefaultGateway1);
DeleteRouteEntry(t->VistaDefaultGateway2);
FreeRouteEntry(t->VistaDefaultGateway2);
}
t->VistaOldDefaultGatewayByVLan = Clone(t->DefaultGatewayByVLan, sizeof(ROUTE_ENTRY));
e = Clone(t->DefaultGatewayByVLan, sizeof(ROUTE_ENTRY));
SetIP(&e->DestIP, 0, 0, 0, 0);
SetIP(&e->DestMask, 128, 0, 0, 0);
t->VistaDefaultGateway1 = e;
e = Clone(t->DefaultGatewayByVLan, sizeof(ROUTE_ENTRY));
SetIP(&e->DestIP, 128, 0, 0, 0);
SetIP(&e->DestMask, 128, 0, 0, 0);
t->VistaDefaultGateway2 = e;
AddRouteEntry(t->VistaDefaultGateway1);
AddRouteEntry(t->VistaDefaultGateway2);
Debug("Vista PPP Fix Route Table Added.\n");
any_modified = true;
}
}
else
{
if (t->VistaOldDefaultGatewayByVLan != NULL)
{
FreeRouteEntry(t->VistaOldDefaultGatewayByVLan);
t->VistaOldDefaultGatewayByVLan = NULL;
}
if (t->VistaDefaultGateway1 != NULL)
{
Debug("Vista PPP Fix Route Table Deleted.\n");
DeleteRouteEntry(t->VistaDefaultGateway1);
FreeRouteEntry(t->VistaDefaultGateway1);
DeleteRouteEntry(t->VistaDefaultGateway2);
FreeRouteEntry(t->VistaDefaultGateway2);
any_modified = true;
t->VistaDefaultGateway1 = t->VistaDefaultGateway2 = NULL;
}
}
}
}
// If the virtual LAN card want to be the default gateway and
// there is no LAN card with smaller metric of 0.0.0.0/0 than
// the virtual LAN card, delete other default gateway entries
// to elect the virtual LAN card as the default gateway
// Debug("is_vlan_want_to_be_default_gateway = %u, rs = %u, route_to_server_erased = %u, other_if_default_gateway_metric_min = %u, vlan_default_gatewat_metric = %u\n",
// is_vlan_want_to_be_default_gateway, rs, route_to_server_erased, other_if_default_gateway_metric_min, vlan_default_gatewat_metric);
if (is_vlan_want_to_be_default_gateway && (rs != NULL && route_to_server_erased == false) &&
other_if_default_gateway_metric_min >= vlan_default_gatewat_metric)
{
// Scan the routing table again
for (i = 0;i < table->NumEntry;i++)
{
ROUTE_ENTRY *e = table->Entry[i];
if (e->InterfaceID != t->VLanInterfaceId)
{
if (IPToUINT(&e->DestIP) == 0 &&
IPToUINT(&e->DestMask) == 0)
{
char str[64];
// Default gateway is found
ROUTE_ENTRY *r = ZeroMalloc(sizeof(ROUTE_ENTRY));
Copy(r, e, sizeof(ROUTE_ENTRY));
// Put in the queue
InsertQueue(t->DeletedDefaultGateway, r);
// Delete this gateway entry once
DeleteRouteEntry(e);
IPToStr(str, sizeof(str), &e->GatewayIP);
Debug("Default Gateway %s Deleted.\n", str);
any_modified = true;
}
}
}
}
if (rs != NULL && route_to_server_erased)
{
// Physical entry to the server has disappeared
Debug("Route to Server entry ERASED !!!\n");
// Forced disconnection (reconnection enabled)
s->RetryFlag = true;
s->Halt = true;
}
// Release the routing table
FreeRouteTable(table);
}
// Set the time to perform the next track
if (t->NextTrackingTimeAdd == 0 || changed)
{
t->NextTrackingTimeAdd = TRACKING_INTERVAL_INITIAL;
}
else
{
UINT64 max_value = TRACKING_INTERVAL_MAX;
if (t->RouteChange != NULL)
{
max_value = TRACKING_INTERVAL_MAX_RC;
}
t->NextTrackingTimeAdd += TRACKING_INTERVAL_ADD;
if (t->NextTrackingTimeAdd >= max_value)
{
t->NextTrackingTimeAdd = max_value;
}
}
//Debug("t->NextTrackingTimeAdd = %I64u\n", t->NextTrackingTimeAdd);
t->NextTrackingTime = now + t->NextTrackingTimeAdd;
if (any_modified)
{
// Clear the DNS cache
Win32FlushDnsCache();
}
}
/*
* AccLoadProg - create a new process for debugging
*/
trap_retval ReqProg_load( void )
{
char *parm;
char *src;
char *dst;
char *endsrc;
char exe_name[PATH_MAX];
char ch;
BOOL rc;
int len;
MYCONTEXT con;
thread_info *ti;
HANDLE handle;
prog_load_req *acc;
prog_load_ret *ret;
header_info hi;
WORD stack;
WORD version;
DWORD pid;
DWORD pid_started;
DWORD cr_flags;
char *buff = NULL;
size_t nBuffRequired = 0;
char *dll_name;
char *service_name;
char *dll_destination;
char *service_parm;
acc = GetInPtr( 0 );
ret = GetOutPtr( 0 );
parm = GetInPtr( sizeof( *acc ) );
/*
* reset status variables
*/
LastExceptionCode = -1;
DebugString = NULL;
DebugeeEnded = FALSE;
RemoveAllThreads();
FreeLibList();
DidWaitForDebugEvent = FALSE;
DebugeePid = 0;
DebugeeTid = 0;
SupportingExactBreakpoints = 0;
/*
* check if pid is specified
*/
ParseServiceStuff( parm, &dll_name, &service_name, &dll_destination, &service_parm );
pid = 0;
src = parm;
/*
// Just to be really safe!
*/
nBuffRequired = GetTotalSize() + PATH_MAX + 16;
if( NULL == ( buff = malloc( nBuffRequired ) ) ) {
ret->err = ERROR_NOT_ENOUGH_MEMORY;
return( sizeof( *ret ) );
}
if( *src == '#' ) {
src++;
pid = strtoul( src, &endsrc, 16 );
if( pid == 0 ) {
pid = -1;
}
strcpy( buff, endsrc );
} else {
while( isdigit( *src ) ) {
src++;
}
if( *src == 0 && src != parm ) {
pid = atoi( parm );
}
}
/*
* get program to debug. If the user has specified a pid, then
* skip directly to doing a DebugActiveProcess
*/
IsWOW = FALSE;
#if !defined( MD_x64 )
IsDOS = FALSE;
#endif
if( pid == 0 ) {
if( FindFilePath( parm, exe_name, ExtensionList ) != 0 ) {
ret->err = ERROR_FILE_NOT_FOUND;
goto error_exit;
}
/*
* Get type of application
*/
handle = CreateFile( (LPTSTR)exe_name, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
if( handle == INVALID_HANDLE_VALUE ) {
ret->err = GetLastError();
goto error_exit;
}
GetFullPathName( exe_name, MAX_PATH, CurrEXEName, NULL );
/*
* get the parm list
*/
if( strchr( CurrEXEName, ' ' ) != NULL ) {
strcpy( buff, "\"" );
strcat( buff, CurrEXEName );
strcat( buff, "\"" );
} else {
strcpy( buff, CurrEXEName );
}
dst = &buff[strlen( buff )];
src = parm;
while( *src != 0 ) {
++src;
}
// parm layout
// <--parameters-->0<--program_name-->0<--arguments-->0
//
for( len = GetTotalSize() - sizeof( *acc ) - (src - parm) - 1; len > 0; --len ) {
ch = *src;
if( ch == 0 ) {
ch = ' ';
}
*dst = ch;
++dst;
++src;
}
*dst = 0;
cr_flags = DEBUG_ONLY_THIS_PROCESS;
if( !GetEXEHeader( handle, &hi, &stack ) ) {
ret->err = GetLastError();
CloseHandle( handle );
goto error_exit;
}
if( hi.sig == EXE_PE ) {
if( IS_PE64( hi.u.peh ) ) {
DebugeeSubsystem = PE64( hi.u.peh ).subsystem;
} else {
DebugeeSubsystem = PE32( hi.u.peh ).subsystem;
#if defined( MD_x64 )
IsWOW = TRUE;
#endif
}
if( DebugeeSubsystem == SS_WINDOWS_CHAR ) {
cr_flags |= CREATE_NEW_CONSOLE;
}
#if !defined( MD_x64 )
} else if( hi.sig == EXE_NE ) {
IsWOW = TRUE;
/*
* find out the pid of WOW, if it is already running.
*/
pVDMEnumProcessWOW( EnumWOWProcessFunc, (LPARAM)&pid );
if( pid != 0 ) {
version = LOWORD( GetVersion() );
if( LOBYTE( version ) == 3 && HIBYTE( version ) < 50 ) {
int kill = MessageBox( NULL, TRP_NT_wow_warning, TRP_The_WATCOM_Debugger, MB_APPLMODAL + MB_YESNO );
if( kill == IDYES ) {
DWORD axs = PROCESS_TERMINATE+STANDARD_RIGHTS_REQUIRED;
HANDLE hprocess = OpenProcess( axs, FALSE, pid );
if( hprocess != 0 && TerminateProcess( hprocess, 0 ) ) {
CloseHandle( hprocess );
pid = 0;
}
}
} else {
cr_flags |= CREATE_SEPARATE_WOW_VDM;
pid = 0; // always start a new VDM.
}
}
if( pid != 0 ) {
ret->err = GetLastError();
CloseHandle( handle );
goto error_exit;
}
} else {
IsDOS = TRUE;
#endif
}
CloseHandle( handle );
}
/*
* start the debugee
*/
pid_started = pid;
if( *dll_name ) {
strcat( buff, LOAD_PROG_STR_DELIM );
strcat( buff, LOAD_PROG_STR_DLLNAME );
strcat( buff, dll_name );
}
if( *service_name ) {
strcat( buff, LOAD_PROG_STR_DELIM );
strcat( buff, LOAD_PROG_STR_SERVICE );
strcat( buff, service_name );
}
if( *dll_destination ) {
strcat( buff, LOAD_PROG_STR_DELIM );
strcat( buff, LOAD_PROG_STR_COPYDIR );
strcat( buff, dll_destination );
}
if( *service_parm ) {
strcat( buff, LOAD_PROG_STR_DELIM );
strcat( buff, LOAD_PROG_STR_SERVICEPARM );
strcat( buff, service_parm );
}
ret->err = StartControlThread( buff, &pid_started, cr_flags );
if( ret->err != 0 ) {
goto error_exit;
}
/*
* CREATE_PROCESS_DEBUG_EVENT will always be the first debug event.
* If it is not, then something is horribly wrong.
*/
rc = MyWaitForDebugEvent();
if( !rc || ( DebugEvent.dwDebugEventCode != CREATE_PROCESS_DEBUG_EVENT ) || ( DebugEvent.dwProcessId != pid_started ) ) {
ret->err = GetLastError();
goto error_exit;
}
ProcessInfo.pid = DebugEvent.dwProcessId;
ProcessInfo.process_handle = DebugEvent.u.CreateProcessInfo.hProcess;
ProcessInfo.base_addr = DebugEvent.u.CreateProcessInfo.lpBaseOfImage;
AddProcess( &hi );
AddThread( DebugEvent.dwThreadId, DebugEvent.u.CreateProcessInfo.hThread, DebugEvent.u.CreateProcessInfo.lpStartAddress );
DebugeePid = DebugEvent.dwProcessId;
DebugeeTid = DebugEvent.dwThreadId;
LastDebugEventTid = DebugEvent.dwThreadId;
#if defined( MD_x86 )
#ifdef WOW
if( IsWOW ) {
ret->flags = LD_FLAG_IS_PROT;
ret->err = 0;
ret->task_id = DebugeePid;
/*
* we use our own CS and DS as the Flat CS and DS, for lack
* of anything better
*/
FlatDS = GetDS();
FlatCS = GetCS();
if( !executeUntilVDMStart() ) {
ret->err = GetLastError();
goto error_exit;
}
if( pid ) {
addAllWOWModules();
} else {
addKERNEL();
}
/*
* we save the starting CS:IP of the WOW app, since we will use
* it to force execution of code later
*/
ti = FindThread( DebugeeTid );
MyGetThreadContext( ti, &con );
WOWAppInfo.segment = ( WORD ) con.SegCs;
WOWAppInfo.offset = ( WORD ) con.Eip;
con.SegSs = con.SegDs; // Wow lies about the stack segment. Reset it
con.Esp = stack;
MySetThreadContext( ti, &con );
} else if( IsDOS ) {
// TODO! Clean up this code
ret->flags = 0; //LD_FLAG_IS_PROT;
ret->err = 0;
ret->task_id = DebugeePid;
/*
* we use our own CS and DS as the Flat CS and DS, for lack
* of anything better
*/
FlatDS = GetDS();
FlatCS = GetCS();
if( !executeUntilVDMStart() ) {
ret->err = GetLastError();
goto error_exit;
}
#if 0
if( pid ) {
addAllWOWModules();
} else {
addKERNEL();
}
#endif
/*
* we save the starting CS:IP of the WOW app, since we will use
* it to force execution of code later
*/
ti = FindThread( DebugeeTid );
MyGetThreadContext( ti, &con );
WOWAppInfo.segment = ( WORD )con.SegCs;
WOWAppInfo.offset = ( WORD )con.Eip;
con.SegSs = con.SegDs; // Wow lies about the stack segment. Reset it
con.Esp = stack;
MySetThreadContext( ti, &con );
} else {
#else
{
#endif
#else
{
#endif
LPVOID base;
if( pid == 0 ) {
base = (LPVOID)DebugEvent.u.CreateProcessInfo.lpStartAddress;
} else {
base = 0;
}
ret->flags = LD_FLAG_IS_PROT;
ret->err = 0;
ret->task_id = DebugeePid;
if( executeUntilStart( pid != 0 ) ) {
LPVOID old;
/*
* make the application load our DLL, so that we can have it
* run code out of it. One small note: this will not work right
* if the app does not load our DLL at the same address the
* debugger loaded it at!!!
*/
ti = FindThread( DebugeeTid );
MyGetThreadContext( ti, &con );
old = (LPVOID)AdjustIP( &con, 0 );
if( base != 0 ) {
SetIP( &con, base );
}
MySetThreadContext( ti, &con );
SetIP( &con, old );
MySetThreadContext( ti, &con );
}
ti = FindThread( DebugeeTid );
MyGetThreadContext( ti, &con );
#if defined( MD_x86 )
FlatCS = con.SegCs;
FlatDS = con.SegDs;
#endif
ret->flags |= LD_FLAG_IS_BIG;
}
ret->flags |= LD_FLAG_HAVE_RUNTIME_DLLS;
if( pid != 0 ) {
ret->flags |= LD_FLAG_IS_STARTED;
}
ret->mod_handle = 0;
error_exit:
if( buff ) {
free( buff );
buff = NULL;
}
return( sizeof( *ret ) );
}
trap_retval ReqProg_kill( void )
{
prog_kill_ret *ret;
ret = GetOutPtr( 0 );
ret->err = 0;
DelProcess( TRUE );
StopControlThread();
return( sizeof( *ret ) );
}
int Sender::SetIP(char *ip, unsigned long defIP)
{
return SetIP(inet_addr(ip), defIP);
}
GstStereoNetVideoSource::GstStereoNetVideoSource(const core::string& ip )
{
m_providers = new GStreamVideoProvider();
SetIP(ip);
m_isStereo = true;
}
// Start tracking of the routing table
void RouteTrackingStart(SESSION *s)
{
VLAN *v;
ROUTE_TRACKING *t;
UINT if_id = 0;
ROUTE_ENTRY *e;
ROUTE_ENTRY *dns = NULL;
ROUTE_ENTRY *route_to_real_server_global = NULL;
char tmp[64];
UINT exclude_if_id = 0;
bool already_exists = false;
bool already_exists_by_other_account = false;
IP eight;
// Validate arguments
if (s == NULL)
{
return;
}
v = (VLAN *)s->PacketAdapter->Param;
if (v->RouteState != NULL)
{
return;
}
// Get the interface ID of the virtual LAN card
if_id = GetInstanceId(v->InstanceName);
Debug("[InstanceId of %s] = 0x%x\n", v->InstanceName, if_id);
if (MsIsVista())
{
// The routing table by the virtual LAN card body should be
// excluded explicitly in Windows Vista
exclude_if_id = if_id;
}
// Get the route to the server
e = GetBestRouteEntryEx(&s->ServerIP, exclude_if_id);
if (e == NULL)
{
// Acquisition failure
Debug("Failed to get GetBestRouteEntry().\n");
return;
}
IPToStr(tmp, sizeof(tmp), &e->GatewayIP);
Debug("GetBestRouteEntry() Succeed. [Gateway: %s]\n", tmp);
// Add a route
if (MsIsVista())
{
e->Metric = e->OldIfMetric;
}
if (AddRouteEntryEx(e, &already_exists) == false)
{
FreeRouteEntry(e);
e = NULL;
}
Debug("already_exists: %u\n", already_exists);
if (already_exists)
{
if (s->Cedar->Client != NULL && s->Account != NULL)
{
UINT i;
ACCOUNT *a;
for (i = 0;i < LIST_NUM(s->Cedar->Client->AccountList);i++)
{
a = LIST_DATA(s->Cedar->Client->AccountList, i);
Lock(a->lock);
{
SESSION *sess = a->ClientSession;
if (sess != NULL && sess != s)
{
VLAN *v = sess->PacketAdapter->Param;
if (v != NULL)
{
ROUTE_TRACKING *tr = v->RouteState;
if (tr != NULL && e != NULL)
{
if (Cmp(tr->RouteToServer, e, sizeof(ROUTE_ENTRY)) == 0)
{
already_exists_by_other_account = true;
}
}
}
}
}
Unlock(a->lock);
}
}
if (already_exists_by_other_account)
{
Debug("already_exists_by_other_account = %u\n", already_exists_by_other_account);
already_exists = false;
}
}
// Get the routing table to the DNS server
// (If the DNS server is this PC itself, there's no need to get)
if (IsZeroIP(&s->DefaultDns) == false)
{
if (IsMyIPAddress(&s->DefaultDns) == false)
{
dns = GetBestRouteEntryEx(&s->DefaultDns, exclude_if_id);
if (dns == NULL)
{
// Getting failure
Debug("Failed to get GetBestRouteEntry DNS.\n");
}
else
{
// Add a route
if (MsIsVista())
{
dns->Metric = dns->OldIfMetric;
if (AddRouteEntry(dns) == false)
{
FreeRouteEntry(dns);
dns = NULL;
}
}
}
}
}
if (s->IsAzureSession && IsZeroIP(&s->AzureRealServerGlobalIp) == false)
{
// Add also a static route to the real server in the case of via VPN Azure
if (IsMyIPAddress(&s->AzureRealServerGlobalIp) == false)
{
route_to_real_server_global = GetBestRouteEntryEx(&s->AzureRealServerGlobalIp, exclude_if_id);
if (route_to_real_server_global != NULL)
{
if (MsIsVista())
{
route_to_real_server_global->Metric = route_to_real_server_global->OldIfMetric;
}
if (AddRouteEntry(route_to_real_server_global) == false)
{
FreeRouteEntry(route_to_real_server_global);
route_to_real_server_global = NULL;
}
}
}
}
// Initialize
if (s->Cedar->Client != NULL && s->Account != NULL)
{
Lock(s->Account->lock);
}
t = ZeroMalloc(sizeof(ROUTE_TRACKING));
v->RouteState = t;
t->RouteToServerAlreadyExists = already_exists;
t->RouteToServer = e;
t->RouteToDefaultDns = dns;
t->RouteToRealServerGlobal = route_to_real_server_global;
t->VLanInterfaceId = if_id;
t->NextTrackingTime = 0;
t->DeletedDefaultGateway = NewQueue();
t->OldDefaultGatewayMetric = 0x7fffffff;
if (s->Cedar->Client != NULL && s->Account != NULL)
{
Unlock(s->Account->lock);
}
// Get the route to 8.8.8.8
SetIP(&eight, 8, 8, 8, 8);
t->RouteToEight = GetBestRouteEntryEx(&eight, exclude_if_id);
// Get the current default DNS server to detect network changes
GetDefaultDns(&t->OldDnsServer);
// Get as soon as releasing the IP address in the case of using DHCP
if (IsNt())
{
char tmp[MAX_SIZE];
MS_ADAPTER *a;
Format(tmp, sizeof(tmp), VLAN_ADAPTER_NAME_TAG, v->InstanceName);
a = MsGetAdapter(tmp);
if (a != NULL)
{
if (a->UseDhcp)
{
bool ret = Win32ReleaseAddressByGuidEx(a->Guid, 100);
Debug("*** Win32ReleaseAddressByGuidEx = %u\n", ret);
ret = Win32RenewAddressByGuidEx(a->Guid, 100);
Debug("*** Win32RenewAddressByGuidEx = %u\n", ret);
}
MsFreeAdapter(a);
}
}
else
{
// For Win9x
Win32RenewDhcp9x(if_id);
}
// Clear the DNS cache
Win32FlushDnsCache();
// Detect a change in the routing table (for only supported OS)
t->RouteChange = NewRouteChange();
Debug("t->RouteChange = 0x%p\n", t->RouteChange);
}
