// DHCP enumeration
void NmDhcpRefresh(HWND hWnd, SM_HUB *r)
{
LVB *b;
RPC_ENUM_DHCP t;
UINT i;
// Validate arguments
if (hWnd == NULL || r == NULL)
{
Close(hWnd);
return;
}
Zero(&t, sizeof(t));
StrCpy(t.HubName, sizeof(t.HubName), r->HubName);
if (CALL(hWnd, ScEnumDHCP(r->Rpc, &t)) == false)
{
return;
}
b = LvInsertStart();
for (i = 0;i < t.NumItem;i++)
{
RPC_ENUM_DHCP_ITEM *e = &t.Items[i];
wchar_t tmp0[MAX_SIZE];
wchar_t tmp1[MAX_SIZE];
wchar_t tmp2[MAX_SIZE];
wchar_t tmp3[MAX_SIZE];
wchar_t tmp4[MAX_SIZE];
wchar_t tmp5[MAX_SIZE];
char str[MAX_SIZE];
// ID
UniToStru(tmp0, e->Id);
// Time
GetDateTimeStrEx64(tmp1, sizeof(tmp1), SystemToLocal64(e->LeasedTime), NULL);
GetDateTimeStrEx64(tmp2, sizeof(tmp2), SystemToLocal64(e->ExpireTime), NULL);
MacToStr(str, sizeof(str), e->MacAddress);
StrToUni(tmp3, sizeof(tmp3), str);
IPToStr32(str, sizeof(str), e->IpAddress);
StrToUni(tmp4, sizeof(tmp4), str);
StrToUni(tmp5, sizeof(tmp5), e->Hostname);
LvInsertAdd(b, ICO_INTERNET, NULL, 6,
tmp0, tmp1, tmp2, tmp3, tmp4, tmp5);
}
LvInsertEnd(b, hWnd, L_TABLE);
FreeRpcEnumDhcp(&t);
}
bool LoadTableW(wchar_t *filename)
{
bool ret;
BUF *b;
wchar_t replace_name[MAX_PATH];
Zero(replace_name, sizeof(replace_name));
TrackingDisable();
b = ReadDump("@table_name.txt");
if (b != NULL)
{
char *s = CfgReadNextLine(b);
if (s != NULL)
{
if (IsEmptyStr(s) == false)
{
StrToUni(replace_name, sizeof(replace_name), s);
filename = replace_name;
}
Free(s);
}
FreeBuf(b);
}
ret = LoadTableMain(filename);
TrackingEnable();
return ret;
}
// Generate the Unicode string cache file name
void GenerateUnicodeCacheFileName(wchar_t *name, UINT size, wchar_t *strfilename, UINT strfilesize, UCHAR *filehash)
{
wchar_t tmp[MAX_SIZE];
wchar_t hashstr[64];
wchar_t hashtemp[MAX_SIZE];
wchar_t exe[MAX_SIZE];
UCHAR hash[SHA1_SIZE];
// Validate arguments
if (name == NULL || strfilename == NULL || filehash == NULL)
{
return;
}
GetExeDirW(exe, sizeof(exe));
UniStrCpy(hashtemp, sizeof(hashtemp), strfilename);
BinToStrW(tmp, sizeof(tmp), filehash, MD5_SIZE);
UniStrCat(hashtemp, sizeof(hashtemp), tmp);
UniStrCat(hashtemp, sizeof(hashtemp), exe);
UniStrLower(hashtemp);
Hash(hash, hashtemp, UniStrLen(hashtemp) * sizeof(wchar_t), true);
BinToStrW(hashstr, sizeof(hashstr), hash, 4);
UniFormat(tmp, sizeof(tmp), UNICODE_CACHE_FILE, hashstr);
UniStrLower(tmp);
#ifndef OS_WIN32
UniStrCpy(exe, sizeof(exe), L"/tmp");
#else // OS_WIN32
StrToUni(exe, sizeof(exe), MsGetTempDir());
#endif // OS_WIN32
UniFormat(name, size, L"%s/%s", exe, tmp);
NormalizePathW(name, size, name);
}
// Update the adapter list
void UtSpeedMeterDlgRefreshList(HWND hWnd)
{
wchar_t *old;
MS_ADAPTER_LIST *o;
UINT i;
// Validate arguments
if (hWnd == NULL)
{
return;
}
if (g_ut_adapter_list_updating)
{
return;
}
g_ut_adapter_list_updating = true;
// Get the current selection
old = GetText(hWnd, E_LIST);
if (old != NULL)
{
if (UniStrLen(old) == 0)
{
Free(old);
old = NULL;
}
}
o = MsCreateAdapterList();
CbReset(hWnd, E_LIST);
CbSetHeight(hWnd, E_LIST, 18);
for (i = 0;i < o->Num;i++)
{
wchar_t tmp[MAX_SIZE];
MS_ADAPTER *a = o->Adapters[i];
if (a->Info)
{
StrToUni(tmp, sizeof(tmp), a->Title);
CbAddStr(hWnd, E_LIST, tmp, 0);
}
}
// Re-select the previous selection
if (old != NULL)
{
CbSelectIndex(hWnd, E_LIST, CbFindStr(hWnd, E_LIST, old));
Free(old);
}
MsFreeAdapterList(o);
g_ut_adapter_list_updating = false;
}
// Show the HTML
void ShowHtml(HWND hWnd, char *url, wchar_t *option)
{
wchar_t tmp[MAX_SIZE];
// Validate arguments
if (url == NULL || option == NULL)
{
return;
}
StrToUni(tmp, sizeof(tmp), url);
ShowHTMLDialogFromURL(hWnd, tmp, NULL, option, NULL);
}
// Show the status of the router
bool NmStatus(HWND hWnd, SM_SERVER *s, void *param)
{
LVB *b;
RPC_NAT_STATUS t;
wchar_t tmp[MAX_SIZE];
SM_HUB *h = (SM_HUB *)param;
// Validate arguments
if (hWnd == NULL || s == NULL)
{
return false;
}
Zero(&t, sizeof(t));
StrCpy(t.HubName, sizeof(t.HubName), h->HubName);
if (CALL(hWnd, ScGetSecureNATStatus(s->Rpc, &t)) == false)
{
return false;
}
b = LvInsertStart();
StrToUni(tmp, sizeof(tmp), h->HubName);
LvInsertAdd(b, ICO_HUB, NULL, 2, _UU("SM_HUB_COLUMN_1"), tmp);
UniFormat(tmp, sizeof(tmp), _UU("SM_SNAT_NUM_SESSION"), t.NumTcpSessions);
LvInsertAdd(b, ICO_PROTOCOL, NULL, 2, _UU("NM_STATUS_TCP"), tmp);
UniFormat(tmp, sizeof(tmp), _UU("SM_SNAT_NUM_SESSION"), t.NumUdpSessions);
LvInsertAdd(b, ICO_PROTOCOL, NULL, 2, _UU("NM_STATUS_UDP"), tmp);
UniFormat(tmp, sizeof(tmp), _UU("SM_SNAT_NUM_SESSION"), t.NumIcmpSessions);
LvInsertAdd(b, ICO_PROTOCOL, NULL, 2, _UU("NM_STATUS_ICMP"), tmp);
UniFormat(tmp, sizeof(tmp), _UU("SM_SNAT_NUM_SESSION"), t.NumDnsSessions);
LvInsertAdd(b, ICO_PROTOCOL, NULL, 2, _UU("NM_STATUS_DNS"), tmp);
UniFormat(tmp, sizeof(tmp), _UU("SM_SNAT_NUM_CLIENT"), t.NumDhcpClients);
LvInsertAdd(b, ICO_PROTOCOL_DHCP, NULL, 2, _UU("NM_STATUS_DHCP"), tmp);
LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_SNAT_IS_KERNEL"), t.IsKernelMode ? _UU("SEC_YES") : _UU("SEC_NO"));
LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_SNAT_IS_RAW"), t.IsRawIpMode ? _UU("SEC_YES") : _UU("SEC_NO"));
LvInsertEnd(b, hWnd, L_STATUS);
FreeRpcNatStatus(&t);
return true;
}
// アダプタリストの更新
void UtSpeedMeterDlgRefreshList(HWND hWnd)
{
wchar_t *old;
MS_ADAPTER_LIST *o;
UINT i;
// 引数チェック
if (hWnd == NULL)
{
return;
}
// 現在の選択を取得
old = GetText(hWnd, E_LIST);
if (old != NULL)
{
if (UniStrLen(old) == 0)
{
Free(old);
old = NULL;
}
}
o = MsCreateAdapterList();
CbReset(hWnd, E_LIST);
CbSetHeight(hWnd, E_LIST, 18);
for (i = 0;i < o->Num;i++)
{
wchar_t tmp[MAX_SIZE];
MS_ADAPTER *a = o->Adapters[i];
if (a->Info)
{
StrToUni(tmp, sizeof(tmp), a->Title);
CbAddStr(hWnd, E_LIST, tmp, 0);
}
}
// 前回の選択を再選択
if (old != NULL)
{
CbSelectIndex(hWnd, E_LIST, CbFindStr(hWnd, E_LIST, old));
Free(old);
}
MsFreeAdapterList(o);
}
// Update
void EmMainRefresh(HWND hWnd, RPC *r)
{
RPC_ENUM_DEVICE t;
// Validate arguments
if (hWnd == NULL || r == NULL)
{
return;
}
Zero(&t, sizeof(t));
if (CALL(hWnd, EcEnumDevice(r, &t)))
{
UINT i;
LVB *b;
b = LvInsertStart();
for (i = 0;i < t.NumItem;i++)
{
wchar_t tmp[MAX_PATH];
RPC_ENUM_DEVICE_ITEM *dev = &t.Items[i];
StrToUni(tmp, sizeof(tmp), dev->DeviceName);
LvInsertAdd(b,
dev->Active ? ICO_NIC_ONLINE : ICO_NIC_OFFLINE,
NULL,
2,
tmp,
dev->Active ? _UU("EM_MAIN_OK") : _UU("EM_MAIN_ERROR"));
}
LvInsertEnd(b, hWnd, L_LIST);
FreeRpcEnumDevice(&t);
SetShow(hWnd, B_LICENSE, t.IsLicenseSupported);
}
else
{
Close(hWnd);
}
EmMainUpdate(hWnd, r);
}
void BinToStrW(wchar_t *str, UINT str_size, void *data, UINT data_size)
{
char *tmp;
UINT tmp_size;
// Validate arguments
if (str == NULL || data == NULL)
{
if (str != NULL)
{
str[0] = 0;
}
return;
}
tmp_size = (data_size * 2 + 4) * sizeof(wchar_t);
tmp = ZeroMalloc(tmp_size);
BinToStr(tmp, tmp_size, data, data_size);
StrToUni(str, str_size, tmp);
Free(tmp);
}
// Adding a string type
ITEM *CfgAddStr(FOLDER *f, char *name, char *str)
{
wchar_t *tmp;
UINT tmp_size;
ITEM *t;
// Validate arguments
if (f == NULL || name == NULL || str == NULL)
{
return NULL;
}
// Convert to a Unicode string
tmp_size = CalcStrToUni(str);
if (tmp_size == 0)
{
return NULL;
}
tmp = Malloc(tmp_size);
StrToUni(tmp, tmp_size, str);
t = CfgAddUniStr(f, name, tmp);
Free(tmp);
return t;
}
// Plaintext password authentication of user
bool SamAuthUserByPlainPassword(CONNECTION *c, HUB *hub, char *username, char *password, bool ast, UCHAR *mschap_v2_server_response_20, RADIUS_LOGIN_OPTION *opt)
{
bool b = false;
wchar_t *name = NULL;
bool auth_by_nt = false;
HUB *h;
// Validate arguments
if (hub == NULL || c == NULL || username == NULL)
{
return false;
}
if (GetGlobalServerFlag(GSF_DISABLE_RADIUS_AUTH) != 0)
{
return false;
}
h = hub;
AddRef(h->ref);
// Get the user name on authentication system
AcLock(hub);
{
USER *u;
u = AcGetUser(hub, ast == false ? username : "******");
if (u)
{
Lock(u->lock);
{
if (u->AuthType == AUTHTYPE_RADIUS)
{
// Radius authentication
AUTHRADIUS *auth = (AUTHRADIUS *)u->AuthData;
if (ast || auth->RadiusUsername == NULL || UniStrLen(auth->RadiusUsername) == 0)
{
name = CopyStrToUni(username);
}
else
{
name = CopyUniStr(auth->RadiusUsername);
}
auth_by_nt = false;
}
else if (u->AuthType == AUTHTYPE_NT)
{
// NT authentication
AUTHNT *auth = (AUTHNT *)u->AuthData;
if (ast || auth->NtUsername == NULL || UniStrLen(auth->NtUsername) == 0)
{
name = CopyStrToUni(username);
}
else
{
name = CopyUniStr(auth->NtUsername);
}
auth_by_nt = true;
}
}
Unlock(u->lock);
ReleaseUser(u);
}
}
AcUnlock(hub);
if (name != NULL)
{
if (auth_by_nt == false)
{
// Radius authentication
char radius_server_addr[MAX_SIZE];
UINT radius_server_port;
char radius_secret[MAX_SIZE];
char suffix_filter[MAX_SIZE];
wchar_t suffix_filter_w[MAX_SIZE];
UINT interval;
Zero(suffix_filter, sizeof(suffix_filter));
Zero(suffix_filter_w, sizeof(suffix_filter_w));
// Get the Radius server information
if (GetRadiusServerEx2(hub, radius_server_addr, sizeof(radius_server_addr), &radius_server_port, radius_secret, sizeof(radius_secret), &interval, suffix_filter, sizeof(suffix_filter)))
{
Unlock(hub->lock);
StrToUni(suffix_filter_w, sizeof(suffix_filter_w), suffix_filter);
if (UniIsEmptyStr(suffix_filter_w) || UniEndWith(name, suffix_filter_w))
{
// Attempt to login
b = RadiusLogin(c, radius_server_addr, radius_server_port,
radius_secret, StrLen(radius_secret),
name, password, interval, mschap_v2_server_response_20, opt);
}
Lock(hub->lock);
}
else
{
HLog(hub, "LH_NO_RADIUS_SETTING", name);
}
}
else
{
// NT authentication (Not available for non-Win32)
#ifdef OS_WIN32
IPC_MSCHAP_V2_AUTHINFO mschap;
Unlock(hub->lock);
if (ParseAndExtractMsChapV2InfoFromPassword(&mschap, password) == false)
{
// Plaintext password authentication
b = MsCheckLogon(name, password);
}
else
{
UCHAR challenge8[8];
UCHAR nt_pw_hash_hash[16];
char nt_name[MAX_SIZE];
UniToStr(nt_name, sizeof(nt_name), name);
// MS-CHAPv2 authentication
MsChapV2_GenerateChallenge8(challenge8, mschap.MsChapV2_ClientChallenge,
mschap.MsChapV2_ServerChallenge,
mschap.MsChapV2_PPPUsername);
Debug("MsChapV2_PPPUsername = %s, nt_name = %s\n", mschap.MsChapV2_PPPUsername, nt_name);
b = MsPerformMsChapV2AuthByLsa(nt_name, challenge8, mschap.MsChapV2_ClientResponse, nt_pw_hash_hash);
if (b)
{
if (mschap_v2_server_response_20 != NULL)
{
MsChapV2Server_GenerateResponse(mschap_v2_server_response_20, nt_pw_hash_hash,
mschap.MsChapV2_ClientResponse, challenge8);
}
}
}
Lock(hub->lock);
#else // OS_WIN32
// Nothing to do other than Win32
#endif // OS_WIN32
}
// Memory release
Free(name);
}
ReleaseHub(h);
return b;
}
// Download thread
void ViDownloadThread(THREAD *thread, void *param)
{
VI_INSTALL_DLG *d;
VI_SETTING_ARCH *a;
HWND hWnd;
UINT num_files = 2;
VI_DOWNLOAD_FILE files[2];
VI_DOWNLOAD_FILE *f;
UINT i;
// Validate arguments
if (thread == NULL || param == NULL)
{
return;
}
d = (VI_INSTALL_DLG *)param;
hWnd = d->hWnd;
Zero(files, sizeof(files));
a = ViGetSuitableArchForCpu();
// File body
f = &files[0];
StrCpy(f->SrcPath, sizeof(f->SrcPath), a->Path);
// Configuration file
if (IsEmptyStr(setting.SettingPath) == false)
{
f = &files[1];
StrCpy(f->SrcPath, sizeof(f->SrcPath), setting.SettingPath);
}
else
{
// No configuration file
num_files = 1;
}
for (i = 0;i < num_files;i++)
{
bool b = true;
if (i == 0 && setting.DownloadNotRequired)
{
b = false;
}
if (b)
{
wchar_t tmp[MAX_SIZE];
IO *dest = NULL;
VI_FILE *down;
UINT ret;
UINT totalsize;
UINT currentsize;
wchar_t filename_w[MAX_PATH];
f = &files[i];
GetFileNameFromFilePath(f->FileName, sizeof(f->FileName), f->SrcPath);
MakeSafeFileName(f->FileName, sizeof(f->FileName), f->FileName);
StrToUni(filename_w, sizeof(filename_w), f->FileName);
ConbinePathW(f->DestPathW, sizeof(f->DestPathW), MsGetMyTempDirW(), filename_w);
ViInstallDlgSetPos(hWnd, 0);
UniFormat(tmp, sizeof(tmp), _U(IDS_DOWNLOADSTART+skip), f->FileName);
ViInstallDlgSetText(d, hWnd, S_STATUS, tmp);
down = ViOpenFile(f->SrcPath);
if (down == NULL)
{
MsgBoxEx(hWnd, MB_ICONSTOP, _U(IDS_DOWNLOAD_ERROR+skip), f->FileName);
ViInstallDlgCancel(hWnd);
return;
}
dest = FileCreateW(f->DestPathW);
if (dest == NULL)
{
MsgBoxEx(hWnd, MB_ICONSTOP, _U(IDS_TEMP_ERROR+skip), f->DestPathW);
ViCloseFile(down);
ViInstallDlgCancel(hWnd);
return;
}
totalsize = ViGetFileSize(down);
currentsize = 0;
UniFormat(tmp, sizeof(tmp), _U(IDS_DOWNLOADING3+skip), f->FileName);
ViInstallDlgSetText(d, hWnd, S_STATUS, tmp);
while (true)
{
UINT pos = 0;
if (d->Halt)
{
// User cancel
FileClose(dest);
ViCloseFile(down);
return;
}
UniFormat(tmp, sizeof(tmp), _U(IDS_DOWNLOADING3+skip), f->FileName);
ViInstallDlgSetText(d, hWnd, IDS_DOWNLOADING3+skip, tmp);
ret = ViReadFile(down, d->Buf, d->BufSize);
if (ret == INFINITE)
{
// Communication error
MsgBoxEx(hWnd, MB_ICONSTOP, _U(IDS_DOWNLOAD_ERROR+skip), f->FileName);
FileClose(dest);
ViCloseFile(down);
ViInstallDlgCancel(hWnd);
return;
}
// Draw progress
currentsize += ret;
if (totalsize != 0)
{
UniFormat(tmp, sizeof(tmp), _U(IDS_DOWNLOADING+skip),
((float)totalsize) / 1024.0f / 1024.0f,
((float)currentsize) / 1024.0f / 1024.0f);
pos = (UINT)(((float)currentsize) * 100.0f / ((float)totalsize));
}
else
{
UniFormat(tmp, sizeof(tmp), _U(IDS_DOWNLOADING2+skip),
((float)currentsize) / 1024.0f / 1024.0f);
pos = (UINT)(((float)currentsize) * 100.0f / (1024.0f * 1024.0f * 10.0f));
}
ViInstallDlgSetText(d, hWnd, S_SIZEINFO, tmp);
ViInstallDlgSetPos(hWnd, pos);
if (ret == 0)
{
// Download Complete
break;
}
else
{
FileWrite(dest, d->Buf, ret);
}
}
ViCloseFile(down);
FileClose(dest);
}
}
UniStrCpy(setting.DownloadedInstallerPathW, sizeof(setting.DownloadedInstallerPathW),
files[0].DestPathW);
if (num_files >= 2)
{
UniStrCpy(setting.DownloadedSettingPathW, sizeof(setting.DownloadedSettingPathW),
files[1].DestPathW);
}
PostMessageA(hWnd, WM_VI_DOWNLOAD_FINISHED, 0, 0);
}
// Start the installation process
void ViInstallProcessStart(HWND hWnd, VI_INSTALL_DLG *d)
{
wchar_t *exew;
bool ok;
char instdir[MAX_PATH];
char hamcore[MAX_PATH];
// Validate arguments
if (hWnd == NULL || d == NULL)
{
return;
}
ViGenerateVpnSMgrTempDirName(instdir, sizeof(instdir), ViGetSuitableArchForCpu()->Build);
ConbinePath(hamcore, sizeof(hamcore), instdir, "hamcore.se2");
exew = setting.DownloadedInstallerPathW;
d->NoClose = true;
Hide(hWnd, IDCANCEL);
SetPos(hWnd, P_PROGRESS, 100);
Hide(hWnd, P_PROGRESS);
Hide(hWnd, S_SIZEINFO);
SetText(hWnd, S_STATUS, _U(IDS_INSTALLSTART+skip));
ok = true;
if (setting.DownloadNotRequired == false)
{
if (setting.WebMode && ViCheckExeSign(hWnd, exew) == false)
{
// The digital signature is not reliable
ok = false;
}
else
{
// Installation
HANDLE hProcess;
SHELLEXECUTEINFOW info;
// Run
Zero(&info, sizeof(info));
info.cbSize = sizeof(info);
info.lpVerb = L"open";
info.lpFile = exew;
info.fMask = SEE_MASK_NOCLOSEPROCESS;
info.lpParameters = L"/HIDESTARTCOMMAND:1 /DISABLEAUTOIMPORT:1 /ISWEBINSTALLER:1";
info.nShow = SW_SHOWNORMAL;
if (ShellExecuteExW(&info) == false)
{
MsgBox(hWnd, MB_ICONSTOP, _U(IDS_INSTALLSTART_ERROR+skip));
ok = false;
}
else
{
hProcess = info.hProcess;
// Wait for the install process to complete
while (true)
{
if (WaitForSingleObject(hProcess, 50) != WAIT_TIMEOUT)
{
break;
}
DoEvents(hWnd);
}
CloseHandle(hProcess);
}
}
}
if (ok && d->WindowsShutdowning == false)
{
VI_SETTING_ARCH *a = ViGetSuitableArchForCpu();
wchar_t arg[MAX_PATH];
wchar_t exe[MAX_PATH];
char *arg1 = "/easy";
// Hide the screen
Hide(hWnd, 0);
if (setting.NormalMode)
{
arg1 = "/normal";
}
// (Just in case) start the VPN Client service
if (MsIsServiceRunning("vpnclient") == false)
{
MsStartService("vpnclient");
}
// Wait for that the service becomes available
SwWaitForVpnClientPortReady(0);
if (UniIsEmptyStr(setting.DownloadedSettingPathW) == false)
{
// Start a connection by importing the configuration file into the VPN Client
UniFormat(arg, sizeof(arg), L"%S \"%s\"", arg1, setting.DownloadedSettingPathW);
}
else
{
// Just start the Connection Manager
UniFormat(arg, sizeof(arg), L"%S", arg1);
}
// Get the installation state
ViLoadCurrentInstalledStatusForArch(a);
if (a->CurrentInstalled)
{
HANDLE h;
wchar_t filename[MAX_PATH];
StrToUni(filename, sizeof(filename), a->VpnCMgrExeFileName);
ConbinePathW(exe, sizeof(exe), a->CurrentInstalledPathW, filename);
// Start the Connection Manager
h = MsRunAsUserExW(exe, arg, false);
if (h != NULL)
{
if (UniIsEmptyStr(setting.DownloadedSettingPathW) == false)
{
sleep_before_exit = true;
}
CloseHandle(h);
}
}
}
d->NoClose = false;
Close(hWnd);
}
// Initialize
void EmAddInit(HWND hWnd, EM_ADD *p)
{
// Validate arguments
if (hWnd == NULL || p == NULL)
{
return;
}
// Initialize controls
CbAddStr(hWnd, C_PACKET_SWITCH, _UU("SM_LOG_SWITCH_0"), 0);
CbAddStr(hWnd, C_PACKET_SWITCH, _UU("SM_LOG_SWITCH_1"), 1);
CbAddStr(hWnd, C_PACKET_SWITCH, _UU("SM_LOG_SWITCH_2"), 2);
CbAddStr(hWnd, C_PACKET_SWITCH, _UU("SM_LOG_SWITCH_3"), 3);
CbAddStr(hWnd, C_PACKET_SWITCH, _UU("SM_LOG_SWITCH_4"), 4);
CbAddStr(hWnd, C_PACKET_SWITCH, _UU("SM_LOG_SWITCH_5"), 5);
if (p->NewMode)
{
// Newly creation mode
RPC_ENUM_DEVICE t;
HUB_LOG g;
Zero(&g, sizeof(g));
g.PacketLogSwitchType = LOG_SWITCH_DAY;
g.PacketLogConfig[PACKET_LOG_TCP_CONN] = g.PacketLogConfig[PACKET_LOG_DHCP] = 1;
EmHubLogToDlg(hWnd, &g);
Zero(&t, sizeof(t));
if (CALL(hWnd, EcEnumAllDevice(p->Rpc, &t)))
{
UINT i;
CbSetHeight(hWnd, C_DEVICE, 18);
for (i = 0;i < t.NumItem;i++)
{
RPC_ENUM_DEVICE_ITEM *dev = &t.Items[i];
wchar_t tmp[MAX_SIZE];
StrToUni(tmp, sizeof(tmp), dev->DeviceName);
CbAddStr(hWnd, C_DEVICE, tmp, 0);
}
FreeRpcEnumDevice(&t);
}
SetText(hWnd, 0, _UU("EM_ADD_NEW"));
}
else
{
// Edit mode (to obtain a configuration)
wchar_t tmp[MAX_PATH];
RPC_ADD_DEVICE t;
Hide(hWnd, R_PROMISCUS);
Zero(&t, sizeof(t));
StrCpy(t.DeviceName, sizeof(t.DeviceName), p->DeviceName);
if (CALL(hWnd, EcGetDevice(p->Rpc, &t)))
{
EmHubLogToDlg(hWnd, &t.LogSetting);
}
else
{
Close(hWnd);
}
StrToUni(tmp, sizeof(tmp), p->DeviceName);
CbAddStr(hWnd, C_DEVICE, tmp, 0);
Disable(hWnd, C_DEVICE);
SetText(hWnd, 0, _UU("EM_ADD_EDIT"));
}
EmAddUpdate(hWnd, p);
}
// Read a string table from the buffer
bool LoadTableFromBuf(BUF *b)
{
char *tmp;
char prefix[MAX_SIZE];
LIST *replace_list = NULL;
UINT i;
// Validate arguments
if (b == NULL)
{
return false;
}
// If the table already exists, delete it
FreeTable();
// Create a list
TableList = NewList(CmpTableName);
Zero(prefix, sizeof(prefix));
replace_list = NewListFast(NULL);
// Read the contents of the buffer line by line
while (true)
{
TABLE *t;
bool ok = true;
tmp = CfgReadNextLine(b);
if (tmp == NULL)
{
break;
}
if (tmp[0] == '$')
{
char key[128];
char value[MAX_SIZE];
if (GetKeyAndValue(tmp, key, sizeof(key), value, sizeof(value), " \t"))
{
if (StartWith(key, "$") && EndWith(key, "$") && StrLen(key) >= 3)
{
TABLE *t;
wchar_t univalue[MAX_SIZE];
wchar_t uniname[MAX_SIZE];
t = ZeroMalloc(sizeof(TABLE));
Zero(univalue, sizeof(univalue));
Utf8ToUni(univalue, sizeof(univalue), value, StrLen(value));
StrToUni(uniname, sizeof(uniname), key);
t->name = (char *)CopyUniStr(uniname);
t->unistr = CopyUniStr(univalue);
Add(replace_list, t);
// Found a replacement definition
ok = false;
}
}
}
if (ok)
{
t = ParseTableLine(tmp, prefix, sizeof(prefix), replace_list);
if (t != NULL)
{
// Register
Insert(TableList, t);
}
}
Free(tmp);
}
for (i = 0;i < LIST_NUM(replace_list);i++)
{
TABLE *t = LIST_DATA(replace_list, i);
Free(t->name);
Free(t->str);
Free(t->unistr);
Free(t);
}
ReleaseList(replace_list);
return true;
}
// Update status
void UtSpeedMeterDlgRefreshStatus(HWND hWnd)
{
char *title;
MS_ADAPTER *a;
UINT i;
// Validate arguments
if (hWnd == NULL)
{
return;
}
title = selected_adapter;
a = MsGetAdapter(title);
if (a == NULL)
{
LbReset(hWnd, L_STATUS);
Disable(hWnd, L_STATUS);
}
else
{
LVB *b;
wchar_t tmp[MAX_SIZE];
wchar_t tmp2[MAX_SIZE];
char str[MAX_SIZE];
b = LvInsertStart();
UniStrCpy(tmp, sizeof(tmp), a->TitleW);
LvInsertAdd(b, 0, NULL, 2, _UU("UT_SM_ST_TITLE"), tmp);
StrToUni(tmp, sizeof(tmp), a->Guid);
LvInsertAdd(b, 0, NULL, 2, _UU("UT_SM_ST_GUID"), tmp);
LvInsertAdd(b, 0, NULL, 2, _UU("UT_SM_ST_TYPE"), MsGetAdapterTypeStr(a->Type));
LvInsertAdd(b, 0, NULL, 2, _UU("UT_SM_ST_TYPE2"), (!a->IsNotEthernetLan ? _UU("SEC_YES") : _UU("SEC_NO")));
LvInsertAdd(b, 0, NULL, 2, _UU("UT_SM_ST_STATUS"), MsGetAdapterStatusStr(a->Status));
UniToStr3(tmp, sizeof(tmp), a->Mtu);
LvInsertAdd(b, 0, NULL, 2, _UU("UT_SM_ST_MTU"), tmp);
UniToStr3(tmp, sizeof(tmp), a->Speed);
LvInsertAdd(b, 0, NULL, 2, _UU("UT_SM_ST_SPEED"), tmp);
Zero(str, sizeof(str));
BinToStrEx2(str, sizeof(str), a->Address, a->AddressSize, '-');
StrToUni(tmp, sizeof(tmp), str);
LvInsertAdd(b, 0, NULL, 2, _UU("UT_SM_ST_ADDRESS"), tmp);
UniToStr3(tmp, sizeof(tmp), a->RecvBytes);
LvInsertAdd(b, 0, NULL, 2, _UU("UT_SM_ST_RECV_BYTES"), tmp);
UniToStr3(tmp, sizeof(tmp), a->RecvPacketsBroadcast);
LvInsertAdd(b, 0, NULL, 2, _UU("UT_SM_ST_RECV_BCASTS"), tmp);
UniToStr3(tmp, sizeof(tmp), a->RecvPacketsUnicast);
LvInsertAdd(b, 0, NULL, 2, _UU("UT_SM_ST_RECV_UNICASTS"), tmp);
UniToStr3(tmp, sizeof(tmp), a->SendBytes);
LvInsertAdd(b, 0, NULL, 2, _UU("UT_SM_ST_SEND_BYTES"), tmp);
UniToStr3(tmp, sizeof(tmp), a->SendPacketsBroadcast);
LvInsertAdd(b, 0, NULL, 2, _UU("UT_SM_ST_SEND_BCASTS"), tmp);
UniToStr3(tmp, sizeof(tmp), a->SendPacketsUnicast);
LvInsertAdd(b, 0, NULL, 2, _UU("UT_SM_ST_SEND_UNICASTS"), tmp);
for (i = 0;i < a->NumIpAddress;i++)
{
UniFormat(tmp2, sizeof(tmp2), _UU("UT_SM_ST_IP"), i + 1);
IPToUniStr(tmp, sizeof(tmp), &a->IpAddresses[i]);
LvInsertAdd(b, 0, NULL, 2, tmp2, tmp);
UniFormat(tmp2, sizeof(tmp2), _UU("UT_SM_ST_SUBNET"), i + 1);
IPToUniStr(tmp, sizeof(tmp), &a->SubnetMasks[i]);
LvInsertAdd(b, 0, NULL, 2, tmp2, tmp);
}
for (i = 0;i < a->NumGateway;i++)
{
UniFormat(tmp2, sizeof(tmp2), _UU("UT_SM_ST_GATEWAY"), i + 1);
IPToUniStr(tmp, sizeof(tmp), &a->Gateways[i]);
LvInsertAdd(b, 0, NULL, 2, tmp2, tmp);
}
if (a->UseDhcp)
{
IPToUniStr(tmp, sizeof(tmp), &a->DhcpServer);
LvInsertAdd(b, 0, NULL, 2, _UU("UT_SM_ST_DHCP"), tmp);
GetDateTimeStrEx64(tmp, sizeof(tmp), a->DhcpLeaseStart, NULL);
LvInsertAdd(b, 0, NULL, 2, _UU("UT_SM_ST_DHCP_1"), tmp);
GetDateTimeStrEx64(tmp, sizeof(tmp), a->DhcpLeaseExpires, NULL);
LvInsertAdd(b, 0, NULL, 2, _UU("UT_SM_ST_DHCP_2"), tmp);
}
if (a->UseWins)
{
IPToUniStr(tmp, sizeof(tmp), &a->PrimaryWinsServer);
LvInsertAdd(b, 0, NULL, 2, _UU("UT_SM_ST_WINS_1"), tmp);
IPToUniStr(tmp, sizeof(tmp), &a->SecondaryWinsServer);
LvInsertAdd(b, 0, NULL, 2, _UU("UT_SM_ST_WINS_2"), tmp);
}
LvInsertEnd(b, hWnd, L_STATUS);
Enable(hWnd, L_STATUS);
MsFreeAdapter(a);
}
}
// License dialog update
void EmLicenseDlgRefresh(HWND hWnd, RPC *s)
{
RPC_ENUM_LICENSE_KEY t;
RPC_EL_LICENSE_STATUS st;
UINT i;
wchar_t tmp[MAX_SIZE];
LVB *b;
// Validate arguments
if (hWnd == NULL || s == NULL)
{
return;
}
Zero(&t, sizeof(t));
if (CALL(hWnd, EcEnumLicenseKey(s, &t)) == false)
{
Close(hWnd);
return;
}
b = LvInsertStart();
for (i = 0;i < t.NumItem;i++)
{
wchar_t tmp1[32], tmp2[LICENSE_KEYSTR_LEN + 1], tmp3[LICENSE_MAX_PRODUCT_NAME_LEN + 1],
*tmp4, tmp5[128], tmp6[LICENSE_LICENSEID_STR_LEN + 1], tmp7[64],
tmp8[64], tmp9[64];
RPC_ENUM_LICENSE_KEY_ITEM *e = &t.Items[i];
UniToStru(tmp1, e->Id);
StrToUni(tmp2, sizeof(tmp2), e->LicenseKey);
StrToUni(tmp3, sizeof(tmp3), e->LicenseName);
tmp4 = LiGetLicenseStatusStr(e->Status);
if (e->Expires == 0)
{
UniStrCpy(tmp5, sizeof(tmp5), _UU("SM_LICENSE_NO_EXPIRES"));
}
else
{
GetDateStrEx64(tmp5, sizeof(tmp5), e->Expires, NULL);
}
StrToUni(tmp6, sizeof(tmp6), e->LicenseId);
UniToStru(tmp7, e->ProductId);
UniFormat(tmp8, sizeof(tmp8), L"%I64u", e->SystemId);
UniToStru(tmp9, e->SerialId);
LvInsertAdd(b,
e->Status == LICENSE_STATUS_OK ? ICO_PASS : ICO_DISCARD,
(void *)e->Id, 9,
tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8, tmp9);
}
LvInsertEnd(b, hWnd, L_LIST);
FreeRpcEnumLicenseKey(&t);
Zero(&st, sizeof(st));
if (CALL(hWnd, EcGetLicenseStatus(s, &st)) == false)
{
Close(hWnd);
return;
}
b = LvInsertStart();
if (st.Valid == false)
{
LvInsertAdd(b, 0, NULL, 2, _UU("EM_NO_LICENSE_COLUMN"), _UU("EM_NO_LICENSE"));
}
else
{
// Current system ID
UniFormat(tmp, sizeof(tmp), L"%I64u", st.SystemId);
LvInsertAdd(b, 0, NULL, 2, _UU("SM_LICENSE_STATUS_SYSTEM_ID"), tmp);
// Expiration date of the current license product
if (st.SystemExpires == 0)
{
UniStrCpy(tmp, sizeof(tmp), _UU("SM_LICENSE_NO_EXPIRES"));
}
else
{
GetDateStrEx64(tmp, sizeof(tmp), st.SystemExpires, NULL);
}
LvInsertAdd(b, 0, NULL, 2, _UU("SM_LICENSE_STATUS_EXPIRES"), tmp);
}
LvInsertEnd(b, hWnd, L_STATUS);
if (LvNum(hWnd, L_STATUS) >= 1)
{
LvAutoSize(hWnd, L_STATUS);
}
EmLicenseDlgUpdate(hWnd, s);
}
// Create a shortcut
bool CreateLinkInnerA(char *filename, char *target, char *workdir, char *args,
char *comment, char *icon, UINT icon_index)
{
HRESULT r;
wchar_t tmp[MAX_SIZE];
IShellLinkA* pShellLink;
IPersistFile* pPersistFile;
r = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLinkA, (void **)&pShellLink);
if (FAILED(r))
{
return false;
}
r = pShellLink->QueryInterface(IID_IPersistFile,(void **)&pPersistFile);
if (FAILED(r))
{
pShellLink->Release();
return false;
}
r = pShellLink->SetPath(target);
if (FAILED(r))
{
pShellLink->Release();
pPersistFile->Release();
return false;
}
if (workdir != NULL)
{
r = pShellLink->SetWorkingDirectory(workdir);
if (FAILED(r))
{
pShellLink->Release();
pPersistFile->Release();
return false;
}
}
if (args != NULL)
{
r = pShellLink->SetArguments(args);
if (FAILED(r))
{
pShellLink->Release();
pPersistFile->Release();
return false;
}
}
if (comment != NULL)
{
r = pShellLink->SetDescription(comment);
if (FAILED(r))
{
pShellLink->Release();
pPersistFile->Release();
return false;
}
}
if (icon != NULL)
{
r = pShellLink->SetIconLocation(icon, icon_index);
if (FAILED(r))
{
pShellLink->Release();
pPersistFile->Release();
return false;
}
}
StrToUni(tmp, sizeof(tmp), filename);
r = pPersistFile->Save(tmp, true);
if (FAILED(r))
{
pShellLink->Release();
pPersistFile->Release();
return false;
}
pShellLink->Release();
pPersistFile->Release();
return true;
}
// Add a UPnP port
bool Win32UPnPAddPort(UINT outside_port, UINT inside_port, bool udp, char *local_ip, wchar_t *description, bool remove_before_add)
{
bool ret = false;
HRESULT hr;
IUPnPNAT *nat = NULL;
wchar_t ip_str[MAX_SIZE];
BSTR bstr_ip, bstr_description, bstr_protocol;
wchar_t *protocol_str = (udp ? L"UDP" : L"TCP");
// Validate arguments
if (outside_port == 0 || outside_port >= 65536 || inside_port == 0 || inside_port >= 65536 ||
IsEmptyStr(local_ip) || UniIsEmptyStr(description))
{
return false;
}
StrToUni(ip_str, sizeof(ip_str), local_ip);
bstr_ip = SysAllocString(ip_str);
bstr_description = SysAllocString(description);
bstr_protocol = SysAllocString(protocol_str);
hr = CoCreateInstance(CLSID_UPnPNAT, NULL, CLSCTX_INPROC_SERVER, IID_IUPnPNAT, (void **)&nat);
if (SUCCEEDED(hr))
{
if (nat != NULL)
{
IStaticPortMappingCollection *collection = NULL;
hr = nat->get_StaticPortMappingCollection(&collection);
if (SUCCEEDED(hr))
{
if (collection != NULL)
{
IStaticPortMapping *mapping = NULL;
if (remove_before_add)
{
hr = collection->Remove((long)outside_port, bstr_protocol);
}
hr = collection->Add((long)outside_port, bstr_protocol, (long)inside_port,
bstr_ip, VARIANT_TRUE, bstr_description, &mapping);
if (SUCCEEDED(hr))
{
ret = true;
if (mapping != NULL)
{
mapping->Release();
}
}
collection->Release();
}
else
{
WHERE;
}
}
else
{
WHERE;
}
nat->Release();
}
else
{
WHERE;
}
}
else
{
WHERE;
}
SysFreeString(bstr_ip);
SysFreeString(bstr_description);
SysFreeString(bstr_protocol);
return ret;
}
bool IPsecWin7InitDriverInner()
{
char sys_filename[MAX_PATH];
bool install_driver = true;
HANDLE hEngine;
UINT ret;
FWPM_SESSION0 session;
UINT id;
FWPM_CALLOUT0 callout;
Format(sys_filename, sizeof(sys_filename), IPSEC_WIN7_DST_SYS, MsGetSystem32Dir());
if (IsFileExists(sys_filename) && MsIsServiceInstalled(IPSEC_WIN7_DRIVER_NAME))
{
if (GetCurrentIPsecWin7DriverBuild() >= CEDAR_BUILD)
{
// Not to install since the latest version has been already installed
install_driver = false;
}
}
if (install_driver)
{
char src_filename[MAX_PATH];
if (MsIsWindows10() == false)
{
Format(src_filename, sizeof(src_filename),
"|DriverPackages\\Wfp\\%s\\pxwfp_%s.sys",
(MsIsX64() ? "x64" : "x86"), (MsIsX64() ? "x64" : "x86"));
}
else
{
Format(src_filename, sizeof(src_filename),
"|DriverPackages\\Wfp_Win10\\%s\\pxwfp_%s.sys",
(MsIsX64() ? "x64" : "x86"), (MsIsX64() ? "x64" : "x86"));
}
// Copy the driver
if (FileCopy(src_filename, sys_filename) == false)
{
Debug("%s copy failed. %u\n", sys_filename, GetLastError());
if (IsFileExists(sys_filename) == false)
{
Debug("%s failed. Abort.\n", sys_filename);
return false;
}
}
else
{
Debug("%s copied.\n", sys_filename);
}
// Set the build number
SetCurrentIPsecWin7DriverBuild();
}
// Get whether the device drivers is already installed
if (MsIsServiceInstalled(IPSEC_WIN7_DRIVER_NAME) == false)
{
wchar_t sys_filename_w[MAX_PATH];
StrToUni(sys_filename_w, sizeof(sys_filename_w), sys_filename);
// Run a new installation
if (MsInstallDeviceDriverW(IPSEC_WIN7_DRIVER_NAME, IPSEC_WIN7_DRIVER_TITLE,
sys_filename_w, NULL) == false)
{
// Installation failed
Debug("MsInstallDeviceDriverW failed.\n");
return false;
}
}
// Start if the device driver is stopped
if (MsIsServiceRunning(IPSEC_WIN7_DRIVER_NAME) == false)
{
if (MsStartService(IPSEC_WIN7_DRIVER_NAME) == false)
{
// Start failure
Debug("MsStartService failed.\n");
return false;
}
Debug("%s service started.\n", IPSEC_WIN7_DRIVER_NAME);
}
else
{
Debug("%s service was already started.\n", IPSEC_WIN7_DRIVER_NAME);
}
// Open the WFP
Zero(&session, sizeof(session));
ret = api->FwpmEngineOpen0(NULL, RPC_C_AUTHN_DEFAULT, NULL, &session, &hEngine);
if (ret)
{
Debug("FwpmEngineOpen0 failed.\n");
return false;
}
// Create the Callout Driver (IPv4)
Zero(&callout, sizeof(callout));
callout.calloutKey = GUID_WFP_CALLOUT_DRIVER_V4;
callout.applicableLayer = FWPM_LAYER_INBOUND_IPPACKET_V4;
callout.displayData.name = IPSEC_WIN7_DRIVER_TITLE_V4;
ret = api->FwpmCalloutAdd0(hEngine, &callout, NULL, &id);
if (ret)
{
Debug("FwpmCalloutAdd0 for IPv4 Failed: 0x%X\n", ret);
}
else
{
Debug("FwpmCalloutAdd0 for IPv4 Ok.\n");
}
// Create the Callout Driver (IPv6)
Zero(&callout, sizeof(callout));
callout.calloutKey = GUID_WFP_CALLOUT_DRIVER_V6;
callout.applicableLayer = FWPM_LAYER_INBOUND_IPPACKET_V6;
callout.displayData.name = IPSEC_WIN7_DRIVER_TITLE_V6;
ret = api->FwpmCalloutAdd0(hEngine, &callout, NULL, &id);
if (ret)
{
Debug("FwpmCalloutAdd0 for IPv6 Failed: 0x%X\n", ret);
}
else
{
Debug("FwpmCalloutAdd0 for IPv6 Ok.\n");
}
api->FwpmEngineClose0(hEngine);
return true;
}
// Show the information of the router
bool NmInfo(HWND hWnd, SM_SERVER *s, void *param)
{
LVB *b;
RPC_NAT_INFO t;
wchar_t tmp[MAX_SIZE];
// Validate arguments
if (hWnd == NULL || s == NULL)
{
return false;
}
Zero(&t, sizeof(t));
if (CALL(hWnd, NcGetInfo(s->Rpc, &t)) == false)
{
return false;
}
b = LvInsertStart();
StrToUni(tmp, sizeof(tmp), t.NatProductName);
LvInsertAdd(b, ICO_ROUTER, NULL, 2, _UU("NM_INFO_PRODUCT_NAME"), tmp);
StrToUni(tmp, sizeof(tmp), t.NatVersionString);
LvInsertAdd(b, ICO_INFORMATION, NULL, 2, _UU("NM_INFO_VERSION_STR"), tmp);
StrToUni(tmp, sizeof(tmp), t.NatBuildInfoString);
LvInsertAdd(b, ICO_INFORMATION, NULL, 2, _UU("NM_INFO_BUILD_INFO"), tmp);
StrToUni(tmp, sizeof(tmp), t.NatHostName);
LvInsertAdd(b, ICO_TOWER, NULL, 2, _UU("NM_INFO_HOSTNAME"), tmp);
// OS
StrToUni(tmp, sizeof(tmp), t.OsInfo.OsSystemName);
LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_OS_SYSTEM_NAME"), tmp);
StrToUni(tmp, sizeof(tmp), t.OsInfo.OsProductName);
LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_OS_PRODUCT_NAME"), tmp);
if (t.OsInfo.OsServicePack != 0)
{
UniFormat(tmp, sizeof(tmp), _UU("SM_OS_SP_TAG"), t.OsInfo.OsServicePack);
LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_OS_SERVICE_PACK"), tmp);
}
StrToUni(tmp, sizeof(tmp), t.OsInfo.OsVendorName);
LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_OS_VENDER_NAME"), tmp);
StrToUni(tmp, sizeof(tmp), t.OsInfo.OsVersion);
LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_OS_VERSION"), tmp);
StrToUni(tmp, sizeof(tmp), t.OsInfo.KernelName);
LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_OS_KERNEL_NAME"), tmp);
StrToUni(tmp, sizeof(tmp), t.OsInfo.KernelVersion);
LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_OS_KERNEL_VERSION"), tmp);
// Memory information
if (t.MemInfo.TotalMemory != 0)
{
char vv[128];
ToStr3(vv, sizeof(vv), t.MemInfo.TotalMemory);
UniFormat(tmp, sizeof(tmp), _UU("SM_ST_RAM_SIZE_KB"), vv);
LvInsertAdd(b, ICO_MEMORY, NULL, 2, _UU("SM_ST_TOTAL_MEMORY"), tmp);
ToStr3(vv, sizeof(vv), t.MemInfo.UsedMemory);
UniFormat(tmp, sizeof(tmp), _UU("SM_ST_RAM_SIZE_KB"), vv);
LvInsertAdd(b, ICO_MEMORY, NULL, 2, _UU("SM_ST_USED_MEMORY"), tmp);
ToStr3(vv, sizeof(vv), t.MemInfo.FreeMemory);
UniFormat(tmp, sizeof(tmp), _UU("SM_ST_RAM_SIZE_KB"), vv);
LvInsertAdd(b, ICO_MEMORY, NULL, 2, _UU("SM_ST_FREE_MEMORY"), tmp);
ToStr3(vv, sizeof(vv), t.MemInfo.TotalPhys);
UniFormat(tmp, sizeof(tmp), _UU("SM_ST_RAM_SIZE_KB"), vv);
LvInsertAdd(b, ICO_MEMORY, NULL, 2, _UU("SM_ST_TOTAL_PHYS"), tmp);
ToStr3(vv, sizeof(vv), t.MemInfo.UsedPhys);
UniFormat(tmp, sizeof(tmp), _UU("SM_ST_RAM_SIZE_KB"), vv);
LvInsertAdd(b, ICO_MEMORY, NULL, 2, _UU("SM_ST_USED_PHYS"), tmp);
ToStr3(vv, sizeof(vv), t.MemInfo.FreePhys);
UniFormat(tmp, sizeof(tmp), _UU("SM_ST_RAM_SIZE_KB"), vv);
LvInsertAdd(b, ICO_MEMORY, NULL, 2, _UU("SM_ST_FREE_PHYS"), tmp);
}
LvInsertEnd(b, hWnd, L_STATUS);
FreeRpcNatInfo(&t);
return true;
}
// NAT enumeration
void NmNatRefresh(HWND hWnd, SM_HUB *r)
{
LVB *b;
RPC_ENUM_NAT t;
UINT i;
// Validate arguments
if (hWnd == NULL || r == NULL)
{
return;
}
Zero(&t, sizeof(t));
StrCpy(t.HubName, sizeof(t.HubName), r->HubName);
if (CALL(hWnd, ScEnumNAT(r->Rpc, &t)) == false)
{
Close(hWnd);
return;
}
b = LvInsertStart();
for (i = 0;i < t.NumItem;i++)
{
RPC_ENUM_NAT_ITEM *e = &t.Items[i];
wchar_t tmp0[MAX_SIZE];
wchar_t *tmp1 = L"";
wchar_t tmp2[MAX_SIZE];
wchar_t tmp3[MAX_SIZE];
wchar_t tmp4[MAX_SIZE];
wchar_t tmp5[MAX_SIZE];
wchar_t tmp6[MAX_SIZE];
wchar_t tmp7[MAX_SIZE];
wchar_t tmp8[MAX_SIZE];
wchar_t *tmp9 = L"";
char v1[128], v2[128];
// ID
UniToStru(tmp0, e->Id);
// Protocol
switch (e->Protocol)
{
case NAT_TCP:
tmp1 = _UU("NM_NAT_PROTO_TCP");
break;
case NAT_UDP:
tmp1 = _UU("NM_NAT_PROTO_UDP");
break;
case NAT_DNS:
tmp1 = _UU("NM_NAT_PROTO_DNS");
break;
case NAT_ICMP:
tmp1 = _UU("NM_NAT_PROTO_ICMP");
break;
}
// Source host
StrToUni(tmp2, sizeof(tmp2), e->SrcHost);
// Source port
UniToStru(tmp3, e->SrcPort);
// Destination host
StrToUni(tmp4, sizeof(tmp4), e->DestHost);
// Destination port
UniToStru(tmp5, e->DestPort);
// Creation date and time of the session
GetDateTimeStrEx64(tmp6, sizeof(tmp6), SystemToLocal64(e->CreatedTime), NULL);
// Last communication date and time
GetDateTimeStrEx64(tmp7, sizeof(tmp7), SystemToLocal64(e->LastCommTime), NULL);
// Communication amount
ToStr3(v1, sizeof(v1), e->RecvSize);
ToStr3(v2, sizeof(v2), e->SendSize);
UniFormat(tmp8, sizeof(tmp8), L"%S / %S", v1, v2);
// TCP state
if (e->Protocol == NAT_TCP)
{
switch (e->TcpStatus)
{
case NAT_TCP_CONNECTING:
tmp9 = _UU("NAT_TCP_CONNECTING");
break;
case NAT_TCP_SEND_RESET:
tmp9 = _UU("NAT_TCP_SEND_RESET");
break;
case NAT_TCP_CONNECTED:
tmp9 = _UU("NAT_TCP_CONNECTED");
break;
case NAT_TCP_ESTABLISHED:
tmp9 = _UU("NAT_TCP_ESTABLISHED");
break;
case NAT_TCP_WAIT_DISCONNECT:
tmp9 = _UU("NAT_TCP_WAIT_DISCONNECT");
break;
}
}
LvInsertAdd(b, ICO_PROTOCOL, NULL, 10,
tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8, tmp9);
}
LvInsertEnd(b, hWnd, L_TABLE);
FreeRpcEnumNat(&t);
}