UINT CfgGetIp32(FOLDER *f, char *name)
{
IP p;
// Validate arguments
if (f == NULL || name == NULL)
{
return 0;
}
if (CfgGetIp(f, name, &p) == false)
{
return 0;
}
return IPToUINT(&p);
}
// End the tracking of the routing table
void RouteTrackingStop(SESSION *s, ROUTE_TRACKING *t)
{
ROUTE_ENTRY *e;
ROUTE_TABLE *table;
IP dns_ip;
bool network_has_changed = false;
bool do_not_delete_routing_entry = false;
// Validate arguments
if (s == NULL || t == NULL)
{
return;
}
Zero(&dns_ip, sizeof(dns_ip));
// Remove the default gateway added by the virtual LAN card
if (MsIsVista() == false)
{
if (t->DefaultGatewayByVLan != NULL)
{
Debug("Default Gateway by VLAN was deleted.\n");
DeleteRouteEntry(t->DefaultGatewayByVLan);
}
if (t->VistaOldDefaultGatewayByVLan != NULL)
{
FreeRouteEntry(t->VistaOldDefaultGatewayByVLan);
}
}
if (t->DefaultGatewayByVLan != NULL)
{
FreeRouteEntry(t->DefaultGatewayByVLan);
t->DefaultGatewayByVLan = 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);
}
if (MsIsNt() == false)
{
// Only in the case of Windows 9x, release the DHCP address of the virtual LAN card
Win32ReleaseDhcp9x(t->VLanInterfaceId, false);
}
// Clear the DNS cache
Win32FlushDnsCache();
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)
{
if (Cmp(tr->RouteToServer, t->RouteToServer, sizeof(ROUTE_ENTRY)) == 0)
{
do_not_delete_routing_entry = true;
}
}
}
}
}
Unlock(a->lock);
}
Lock(s->Account->lock);
}
if (do_not_delete_routing_entry == false)
{
// Delete the route that is added firstly
if (t->RouteToServerAlreadyExists == false)
{
DeleteRouteEntry(t->RouteToServer);
}
DeleteRouteEntry(t->RouteToDefaultDns);
DeleteRouteEntry(t->RouteToNatTServer);
DeleteRouteEntry(t->RouteToRealServerGlobal);
}
FreeRouteEntry(t->RouteToDefaultDns);
FreeRouteEntry(t->RouteToServer);
FreeRouteEntry(t->RouteToEight);
FreeRouteEntry(t->RouteToNatTServer);
FreeRouteEntry(t->RouteToRealServerGlobal);
t->RouteToDefaultDns = t->RouteToServer = t->RouteToEight =
t->RouteToNatTServer = t->RouteToRealServerGlobal = NULL;
if (s->Cedar->Client != NULL && s->Account != NULL)
{
Unlock(s->Account->lock);
}
#if 0
// Get the current DNS server
if (GetDefaultDns(&dns_ip))
{
if (IPToUINT(&t->OldDnsServer) != 0)
{
if (IPToUINT(&t->OldDnsServer) != IPToUINT(&dns_ip))
{
char s1[MAX_SIZE], s2[MAX_SIZE];
network_has_changed = true;
IPToStr(s1, sizeof(s1), &t->OldDnsServer);
IPToStr(s2, sizeof(s2), &dns_ip);
Debug("Old Dns: %s, New Dns: %s\n",
s1, s2);
}
}
}
if (network_has_changed == false)
{
Debug("Network: not changed.\n");
}
else
{
Debug("Network: Changed.\n");
}
#endif
// Get the current routing table
table = GetRouteTable();
// Restore the routing table which has been removed so far
while (e = GetNext(t->DeletedDefaultGateway))
{
bool restore = true;
UINT i;
// If the restoring routing entry is a default gateway and
// the existing routing table contains another default gateway
// on the interface, give up restoring the entry
if (IPToUINT(&e->DestIP) == 0 && IPToUINT(&e->DestMask) == 0)
{
for (i = 0;i < table->NumEntry;i++)
{
ROUTE_ENTRY *r = table->Entry[i];
if (IPToUINT(&r->DestIP) == 0 && IPToUINT(&r->DestMask) == 0)
{
if (r->InterfaceID == e->InterfaceID)
{
restore = false;
}
}
}
if (network_has_changed)
{
restore = false;
}
}
if (restore)
{
// Routing table restoration
AddRouteEntry(e);
}
// Memory release
FreeRouteEntry(e);
}
// Release
FreeRouteTable(table);
ReleaseQueue(t->DeletedDefaultGateway);
FreeRouteChange(t->RouteChange);
Free(t);
}
// 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();
}
}
// Attempts Radius authentication (with specifying retry interval and multiple server)
bool RadiusLogin(CONNECTION *c, char *server, UINT port, UCHAR *secret, UINT secret_size, wchar_t *username, char *password, UINT interval, UCHAR *mschap_v2_server_response_20)
{
UCHAR random[MD5_SIZE];
UCHAR id;
BUF *encrypted_password = NULL;
BUF *user_name = NULL;
//IP ip;
bool ret = false;
TOKEN_LIST *token;
UINT i;
LIST *ip_list;
IPC_MSCHAP_V2_AUTHINFO mschap;
bool is_mschap;
char client_ip_str[MAX_SIZE];
static UINT packet_id = 0;
// Validate arguments
if (server == NULL || port == 0 || (secret_size != 0 && secret == NULL) || username == NULL || password == NULL)
{
return false;
}
Zero(client_ip_str, sizeof(client_ip_str));
if (c != NULL && c->FirstSock != NULL)
{
IPToStr(client_ip_str, sizeof(client_ip_str), &c->FirstSock->RemoteIP);
}
// Parse the MS-CHAP v2 authentication data
Zero(&mschap, sizeof(mschap));
is_mschap = ParseAndExtractMsChapV2InfoFromPassword(&mschap, password);
// Split the server into tokens
token = ParseToken(server, " ,;\t");
// Get the IP address of the server
ip_list = NewListFast(NULL);
for(i = 0; i < token->NumTokens; i++)
{
IP *tmp_ip = Malloc(sizeof(IP));
if (GetIP(tmp_ip, token->Token[i]))
{
Add(ip_list, tmp_ip);
}
else if (GetIPEx(tmp_ip, token->Token[i], true))
{
Add(ip_list, tmp_ip);
}
else
{
Free(tmp_ip);
}
}
FreeToken(token);
if(LIST_NUM(ip_list) == 0)
{
ReleaseList(ip_list);
return false;
}
// Random number generation
Rand(random, sizeof(random));
// ID generation
id = (UCHAR)(packet_id % 254 + 1);
packet_id++;
if (is_mschap == false)
{
// Encrypt the password
encrypted_password = RadiusEncryptPassword(password, random, secret, secret_size);
if (encrypted_password == NULL)
{
// Encryption failure
ReleaseList(ip_list);
return false;
}
}
// Generate the user name packet
user_name = RadiusCreateUserName(username);
if (user_name != NULL)
{
// Generate a password packet
BUF *user_password = (is_mschap ? NULL : RadiusCreateUserPassword(encrypted_password->Buf, encrypted_password->Size));
BUF *nas_id = RadiusCreateNasId(CEDAR_SERVER_STR);
if (is_mschap || user_password != NULL)
{
UINT64 start;
UINT64 next_send_time;
UCHAR tmp[MAX_SIZE];
UINT recv_buf_size = 32768;
UCHAR *recv_buf = MallocEx(recv_buf_size, true);
// Generate an UDP packet
BUF *p = NewBuf();
UCHAR type = 1;
SOCK *sock;
USHORT sz = 0;
UINT pos = 0;
BOOL *finish = ZeroMallocEx(sizeof(BOOL) * LIST_NUM(ip_list), true);
Zero(tmp, sizeof(tmp));
WriteBuf(p, &type, 1);
WriteBuf(p, &id, 1);
WriteBuf(p, &sz, 2);
WriteBuf(p, random, 16);
WriteBuf(p, user_name->Buf, user_name->Size);
if (is_mschap == false)
{
UINT ui;
// PAP
WriteBuf(p, user_password->Buf, user_password->Size);
WriteBuf(p, nas_id->Buf, nas_id->Size);
// Service-Type
ui = Endian32(2);
RadiusAddValue(p, 6, 0, 0, &ui, sizeof(ui));
// NAS-Port-Type
ui = Endian32(5);
RadiusAddValue(p, 61, 0, 0, &ui, sizeof(ui));
// Tunnel-Type
ui = Endian32(1);
RadiusAddValue(p, 64, 0, 0, &ui, sizeof(ui));
// Tunnel-Medium-Type
ui = Endian32(1);
RadiusAddValue(p, 65, 0, 0, &ui, sizeof(ui));
// Calling-Station-Id
RadiusAddValue(p, 31, 0, 0, client_ip_str, StrLen(client_ip_str));
// Tunnel-Client-Endpoint
RadiusAddValue(p, 66, 0, 0, client_ip_str, StrLen(client_ip_str));
}
else
{
// MS-CHAP v2
static UINT session_id = 0;
USHORT us;
UINT ui;
char *ms_ras_version = "MSRASV5.20";
UCHAR ms_chapv2_response[50];
// Acct-Session-Id
us = Endian16(session_id % 254 + 1);
session_id++;
RadiusAddValue(p, 44, 0, 0, &us, sizeof(us));
// NAS-IP-Address
if (c != NULL && c->FirstSock != NULL && c->FirstSock->IPv6 == false)
{
ui = IPToUINT(&c->FirstSock->LocalIP);
RadiusAddValue(p, 4, 0, 0, &ui, sizeof(ui));
}
// Service-Type
ui = Endian32(2);
RadiusAddValue(p, 6, 0, 0, &ui, sizeof(ui));
// MS-RAS-Vendor
ui = Endian32(311);
RadiusAddValue(p, 26, 311, 9, &ui, sizeof(ui));
// MS-RAS-Version
RadiusAddValue(p, 26, 311, 18, ms_ras_version, StrLen(ms_ras_version));
// NAS-Port-Type
ui = Endian32(5);
RadiusAddValue(p, 61, 0, 0, &ui, sizeof(ui));
// Tunnel-Type
ui = Endian32(1);
RadiusAddValue(p, 64, 0, 0, &ui, sizeof(ui));
// Tunnel-Medium-Type
ui = Endian32(1);
RadiusAddValue(p, 65, 0, 0, &ui, sizeof(ui));
// Calling-Station-Id
RadiusAddValue(p, 31, 0, 0, client_ip_str, StrLen(client_ip_str));
// Tunnel-Client-Endpoint
RadiusAddValue(p, 66, 0, 0, client_ip_str, StrLen(client_ip_str));
// MS-RAS-Client-Version
RadiusAddValue(p, 26, 311, 35, ms_ras_version, StrLen(ms_ras_version));
// MS-RAS-Client-Name
RadiusAddValue(p, 26, 311, 34, client_ip_str, StrLen(client_ip_str));
// MS-CHAP-Challenge
RadiusAddValue(p, 26, 311, 11, mschap.MsChapV2_ServerChallenge, sizeof(mschap.MsChapV2_ServerChallenge));
// MS-CHAP2-Response
Zero(ms_chapv2_response, sizeof(ms_chapv2_response));
Copy(ms_chapv2_response + 2, mschap.MsChapV2_ClientChallenge, 16);
Copy(ms_chapv2_response + 2 + 16 + 8, mschap.MsChapV2_ClientResponse, 24);
RadiusAddValue(p, 26, 311, 25, ms_chapv2_response, sizeof(ms_chapv2_response));
// NAS-ID
WriteBuf(p, nas_id->Buf, nas_id->Size);
}
SeekBuf(p, 0, 0);
WRITE_USHORT(((UCHAR *)p->Buf) + 2, (USHORT)p->Size);
// Create a socket
sock = NewUDPEx(0, IsIP6(LIST_DATA(ip_list, pos)));
// Transmission process start
start = Tick64();
if(interval < RADIUS_RETRY_INTERVAL)
{
interval = RADIUS_RETRY_INTERVAL;
}
else if(interval > RADIUS_RETRY_TIMEOUT)
{
interval = RADIUS_RETRY_TIMEOUT;
}
next_send_time = start + (UINT64)interval;
while (true)
{
UINT server_port;
UINT recv_size;
//IP server_ip;
SOCKSET set;
UINT64 now;
SEND_RETRY:
//SendTo(sock, &ip, port, p->Buf, p->Size);
SendTo(sock, LIST_DATA(ip_list, pos), port, p->Buf, p->Size);
Debug("send to host:%u\n", pos);
next_send_time = Tick64() + (UINT64)interval;
RECV_RETRY:
now = Tick64();
if (next_send_time <= now)
{
// Switch the host to refer
pos++;
pos = pos % LIST_NUM(ip_list);
goto SEND_RETRY;
}
if ((start + RADIUS_RETRY_TIMEOUT) < now)
{
// Time-out
break;
}
InitSockSet(&set);
AddSockSet(&set, sock);
Select(&set, (UINT)(next_send_time - now), NULL, NULL);
recv_size = RecvFrom(sock, LIST_DATA(ip_list, pos), &server_port, recv_buf, recv_buf_size);
if (recv_size == 0)
{
Debug("Radius recv_size 0\n");
finish[pos] = TRUE;
for(i = 0; i < LIST_NUM(ip_list); i++)
{
if(finish[i] == FALSE)
{
// Switch the host to refer
pos++;
pos = pos % LIST_NUM(ip_list);
goto SEND_RETRY;
}
}
// Failure
break;
}
else if (recv_size == SOCK_LATER)
{
// Waiting
goto RECV_RETRY;
}
else
{
// Check such as the IP address
if (/*Cmp(&server_ip, &ip, sizeof(IP)) != 0 || */server_port != port)
{
goto RECV_RETRY;
}
// Success
if (recv_buf[0] == 2)
{
ret = true;
if (is_mschap && mschap_v2_server_response_20 != NULL)
{
// Cutting corners Zurukko
UCHAR signature[] = {0x1A, 0x33, 0x00, 0x00, 0x01, 0x37, 0x1A, 0x2D, 0x00, 0x53, 0x3D, };
UINT i = SearchBin(recv_buf, 0, recv_buf_size, signature, sizeof(signature));
if (i == INFINITE || ((i + sizeof(signature) + 40) > recv_buf_size))
{
ret = false;
}
else
{
char tmp[MAX_SIZE];
BUF *b;
Zero(tmp, sizeof(tmp));
Copy(tmp, recv_buf + i + sizeof(signature), 40);
b = StrToBin(tmp);
if (b != NULL && b->Size == 20)
{
WHERE;
Copy(mschap_v2_server_response_20, b->Buf, 20);
}
else
{
WHERE;
ret = false;
}
FreeBuf(b);
}
}
}
break;
}
}
Free(finish);
// Release the socket
ReleaseSock(sock);
FreeBuf(p);
FreeBuf(user_password);
Free(recv_buf);
}
FreeBuf(nas_id);
FreeBuf(user_name);
}
// Release the ip_list
for(i = 0; i < LIST_NUM(ip_list); i++)
{
IP *tmp_ip = LIST_DATA(ip_list, i);
Free(tmp_ip);
}
ReleaseList(ip_list);
// Release the memory
FreeBuf(encrypted_password);
return ret;
}
void NmEditVhOptionUpdate(HWND hWnd, SM_HUB *r)
{
VH_OPTION t;
bool ok = true;
// Validate arguments
if (hWnd == NULL || r == NULL)
{
return;
}
NmEditVhOptionFormToVH(hWnd, &t);
if (IsZero(t.MacAddress, 6))
{
ok = false;
}
if (IPToUINT(&t.Ip) == 0 || IPToUINT(&t.Mask) == 0)
{
ok = false;
}
if (IpIsFilled(hWnd, E_IP) == false || IpIsFilled(hWnd, E_MASK) == false)
{
ok = false;
}
if (IsHostIPAddress4(&t.Ip) == false || IsSubnetMask4(&t.Mask) == false)
{
ok = false;
}
if (t.UseNat)
{
if (t.Mtu < 64 || t.Mtu > 1500)
{
ok = false;
}
if (t.NatTcpTimeout < (NAT_TCP_MIN_TIMEOUT / 1000) || t.NatTcpTimeout > (NAT_TCP_MAX_TIMEOUT / 1000))
{
ok = false;
}
if (t.NatUdpTimeout < (NAT_UDP_MIN_TIMEOUT / 1000) || t.NatUdpTimeout > (NAT_UDP_MAX_TIMEOUT / 1000))
{
ok = false;
}
}
if (t.UseDhcp)
{
if (IpIsFilled(hWnd, E_DHCP_START) == false || IpIsFilled(hWnd, E_DHCP_END) == false ||
IpIsFilled(hWnd, E_DHCP_MASK) == false)
{
ok = false;
}
if (IpGetFilledNum(hWnd, E_GATEWAY) != 0 && IpGetFilledNum(hWnd, E_GATEWAY) != 4)
{
ok = false;
}
if (IpGetFilledNum(hWnd, E_DNS) != 0 && IpGetFilledNum(hWnd, E_DNS) != 4)
{
ok = false;
}
if (IpGetFilledNum(hWnd, E_DNS2) != 0 && IpGetFilledNum(hWnd, E_DNS2) != 4)
{
ok = false;
}
if (IPToUINT(&t.DhcpLeaseIPStart) == 0 || IPToUINT(&t.DhcpLeaseIPEnd) == 0 ||
IPToUINT(&t.DhcpSubnetMask) == 0)
{
ok = false;
}
if (t.DhcpExpireTimeSpan < 15)
{
ok = false;
}
if (Endian32(IPToUINT(&t.DhcpLeaseIPStart)) > Endian32(IPToUINT(&t.DhcpLeaseIPEnd)))
{
ok = false;
}
if (IsHostIPAddress4(&t.DhcpLeaseIPStart) == false ||
IsHostIPAddress4(&t.DhcpLeaseIPEnd) == false)
{
ok = false;
}
if (IsSubnetMask4(&t.DhcpSubnetMask) == false)
{
ok = false;
}
}
SetEnable(hWnd, E_MTU, t.UseNat);
SetEnable(hWnd, E_TCP, t.UseNat);
SetEnable(hWnd, E_UDP, t.UseNat);
SetEnable(hWnd, E_DHCP_START, t.UseDhcp);
SetEnable(hWnd, E_DHCP_END, t.UseDhcp);
SetEnable(hWnd, E_DHCP_MASK, t.UseDhcp);
SetEnable(hWnd, E_EXPIRES, t.UseDhcp);
SetEnable(hWnd, E_GATEWAY, t.UseDhcp);
SetEnable(hWnd, E_DNS, t.UseDhcp);
SetEnable(hWnd, E_DNS2, t.UseDhcp);
SetEnable(hWnd, E_DOMAIN, t.UseDhcp);
SetEnable(hWnd, IDOK, ok);
}
// Initialize
void NmEditVhOptionInit(HWND hWnd, SM_HUB *r)
{
char tmp[MAX_SIZE];
VH_OPTION t;
// Validate arguments
if (hWnd == NULL || r == NULL)
{
return;
}
SetIcon(hWnd, 0, ICO_ROUTER);
FormatText(hWnd, S_TITLE, r->HubName);
Zero(&t, sizeof(VH_OPTION));
StrCpy(t.HubName, sizeof(t.HubName), r->HubName);
if (CALL(hWnd, ScGetSecureNATOption(r->Rpc, &t)) == false)
{
EndDialog(hWnd, false);
return;
}
if (GetCapsBool(r->p->CapsList, "b_virtual_nat_disabled"))
{
SetEnable(hWnd, R_USE_NAT, false);
Check(hWnd, R_USE_NAT, false);
}
MacToStr(tmp, sizeof(tmp), t.MacAddress);
SetTextA(hWnd, E_MAC, tmp);
IpSet(hWnd, E_IP, IPToUINT(&t.Ip));
IpSet(hWnd, E_MASK, IPToUINT(&t.Mask));
Check(hWnd, R_USE_NAT, t.UseNat);
SetIntEx(hWnd, E_MTU, t.Mtu);
SetIntEx(hWnd, E_TCP, t.NatTcpTimeout);
SetIntEx(hWnd, E_UDP, t.NatUdpTimeout);
Check(hWnd, R_USE_DHCP, t.UseDhcp);
IpSet(hWnd, E_DHCP_START, IPToUINT(&t.DhcpLeaseIPStart));
IpSet(hWnd, E_DHCP_END, IPToUINT(&t.DhcpLeaseIPEnd));
IpSet(hWnd, E_DHCP_MASK, IPToUINT(&t.DhcpSubnetMask));
SetIntEx(hWnd, E_EXPIRES, t.DhcpExpireTimeSpan);
if (IPToUINT(&t.DhcpGatewayAddress) != 0)
{
IpSet(hWnd, E_GATEWAY, IPToUINT(&t.DhcpGatewayAddress));
}
if (IPToUINT(&t.DhcpDnsServerAddress) != 0)
{
IpSet(hWnd, E_DNS, IPToUINT(&t.DhcpDnsServerAddress));
}
if (IPToUINT(&t.DhcpDnsServerAddress2) != 0)
{
IpSet(hWnd, E_DNS2, IPToUINT(&t.DhcpDnsServerAddress2));
}
SetTextA(hWnd, E_DOMAIN, t.DhcpDomainName);
Check(hWnd, R_SAVE_LOG, t.SaveLog);
StrCpy(r->CurrentPushRouteStr, sizeof(r->CurrentPushRouteStr), t.DhcpPushRoutes);
if (GetCapsBool(r->p->CapsList, "b_suppport_push_route_config") == false)
{
Disable(hWnd, S_1);
Disable(hWnd, S_2);
Disable(hWnd, B_PUSH);
}
NmEditVhOptionUpdate(hWnd, r);
}
