// Evaluation whether the specified file exists
bool CmdEvalIsFile(CONSOLE *c, wchar_t *str, void *param)
{
wchar_t tmp[MAX_PATH];
// Validate arguments
if (c == NULL || str == NULL)
{
return false;
}
UniStrCpy(tmp, sizeof(tmp), str);
if (IsEmptyUniStr(tmp))
{
c->Write(c, _UU("CMD_FILE_NAME_EMPTY"));
return false;
}
if (IsFileExistsW(tmp) == false)
{
wchar_t tmp2[MAX_SIZE];
UniFormat(tmp2, sizeof(tmp2), _UU("CMD_FILE_NOT_FOUND"), tmp);
c->Write(c, tmp2);
return false;
}
return true;
}
// Main process
void MainNM()
{
UINT port;
char hostname[MAX_HOST_NAME_LEN + 1];
char *tmp =
RemoteDlg(NULL, NM_SETTING_REG_KEY, ICO_ROUTER,
_UU("NM_TITLE"), _UU("NM_CONNECT_TITLE"), NULL);
TOKEN_LIST *t;
Zero(hostname, sizeof(hostname));
if (tmp == NULL)
{
return;
}
t = ParseToken(tmp, ":");
port = DEFAULT_NAT_ADMIN_PORT;
if (t->NumTokens >= 2)
{
UINT i = ToInt(t->Token[1]);
if (i != 0)
{
port = i;
}
}
if (t->NumTokens >= 1)
{
RPC *rpc;
StrCpy(hostname, sizeof(hostname), t->Token[0]);
// Connection
Trim(hostname);
if (StrLen(hostname) != 0)
{
rpc = NmConnect(hostname, port);
if (rpc != NULL)
{
// Connected
NmMainDlg(rpc);
NatAdminDisconnect(rpc);
}
}
}
FreeToken(t);
Free(tmp);
}
// Update
void NmMainDlgRefresh(HWND hWnd, RPC *r)
{
#if 0
RPC_NAT_STATUS t;
wchar_t tmp[MAX_SIZE];
wchar_t tmp2[MAX_SIZE];
// Validate arguments
if (r == NULL || hWnd == NULL)
{
return;
}
Zero(&t, sizeof(RPC_NAT_STATUS));
CALL(hWnd, NcGetStatus(r, &t));
if (t.Online == false)
{
UniStrCpy(tmp, sizeof(tmp), _UU("NM_OFFLINE"));
Enable(hWnd, B_CONNECT);
Disable(hWnd, B_DISCONNECT);
}
else
{
if (t.Connected)
{
UniFormat(tmp, sizeof(tmp), _UU("NM_CONNECTED"), t.Status.ServerName);
}
else
{
if (t.LastError == ERR_NO_ERROR)
{
UniStrCpy(tmp, sizeof(tmp), _UU("NM_CONNECTING"));
}
else
{
UniFormat(tmp, sizeof(tmp), _UU("NM_CONNECT_ERROR"), t.LastError, _E(t.LastError));
}
}
Disable(hWnd, B_CONNECT);
Enable(hWnd, B_DISCONNECT);
}
UniFormat(tmp2, sizeof(tmp2), _UU("NM_STATUS_TAG"), tmp);
SetText(hWnd, S_STATUS, tmp2);
FreeRpcNatStatus(&t);
#endif
}
// Main screen
void EMMain(RPC *r)
{
RPC_BRIDGE_SUPPORT t;
// Validate arguments
if (r == NULL)
{
return;
}
// Examine the bridge support status of the server side first
Zero(&t, sizeof(t));
if (CALLEX(NULL, ScGetBridgeSupport(r, &t)) == ERR_NO_ERROR)
{
if (t.IsBridgeSupportedOs == false)
{
// OS does not support the bridge
MsgBox(NULL, MB_ICONEXCLAMATION, _UU("EM_UNSUPPORTED"));
return;
}
if (t.IsWinPcapNeeded)
{
if (r->Sock->RemoteIP.addr[0] != 127)
{
// WinPcap is required, but can not do anything because it is in remote management mode
MsgBox(NULL, MB_ICONINFORMATION, _UU("EM_WPCAP_REMOTE"));
return;
}
else
{
// WinPcap is required, and it's in local management mode
if (MsIsAdmin())
{
// Administrators
EmInstallWinPcap(NULL, r);
return;
}
else
{
// Non-Administrators
MsgBox(NULL, MB_ICONINFORMATION, _UU("EM_WPCAP_ROOT"));
return;
}
}
}
}
Dialog(NULL, D_EM_MAIN, EmMainDlg, r);
}
// Get policy description
wchar_t *GetPolicyDescription(UINT id)
{
char tmp[MAX_SIZE];
Format(tmp, sizeof(tmp), "POL_EX_%u", id);
return _UU(tmp);
}
// Read the password from the console
char *ConsoleLocalReadPassword(CONSOLE *c, wchar_t *prompt)
{
char tmp[64];
// Validate arguments
if (c == NULL)
{
return NULL;
}
if (prompt == NULL)
{
prompt = L"Password>";
}
UniPrint(L"%s", prompt);
ConsoleWriteOutFile(c, prompt, false);
if (PasswordPrompt(tmp, sizeof(tmp)))
{
ConsoleWriteOutFile(c, L"********", true);
return CopyStr(tmp);
}
else
{
ConsoleWriteOutFile(c, _UU("CON_USER_CANCEL"), true);
return NULL;
}
}
// Get policy title
wchar_t *GetPolicyTitle(UINT id)
{
char tmp[MAX_SIZE];
Format(tmp, sizeof(tmp), "POL_%u", id);
return _UU(tmp);
}
// 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);
}
// Speedometer dialog initialization
void UtSpeedMeterDlgInit(HWND hWnd)
{
// Validate arguments
if (hWnd == NULL)
{
return;
}
LvInitEx(hWnd, L_STATUS, true);
LvInsertColumn(hWnd, L_STATUS, 0, _UU("UT_SM_COLUMN_1"), 150);
LvInsertColumn(hWnd, L_STATUS, 1, _UU("UT_SM_COLUMN_2"), 290);
UtSpeedMeterDlgRefreshList(hWnd);
selected_adapter = GetTextA(hWnd, E_LIST);
UtSpeedMeterDlgRefreshStatus(hWnd);
UtSpeedMeterDlgUpdate(hWnd);
}
// Get the help string for parameter
void GetCommandParamHelpStr(char *command_name, char *param_name, wchar_t **description)
{
char tmp[160];
if (description == NULL)
{
return;
}
Format(tmp, sizeof(tmp), "CMD_%s_%s", command_name, param_name);
*description = _UU(tmp);
if (UniIsEmptyStr(*description))
{
*description = _UU("CMD_UNKNOWN_PARAM");
}
}
// Change Password dialog
UINT EmPasswordDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
{
RPC *r = (RPC *)param;
char pass1[MAX_PATH];
char pass2[MAX_PATH];
UCHAR hash[SHA1_SIZE];
RPC_SET_PASSWORD t;
// Validate arguments
if (hWnd == NULL)
{
return 0;
}
switch (msg)
{
case WM_INITDIALOG:
Focus(hWnd, E_PASSWORD1);
break;
case WM_COMMAND:
switch (wParam)
{
case IDOK:
GetTxtA(hWnd, E_PASSWORD1, pass1, sizeof(pass1));
Hash(hash, pass1, StrLen(pass1), true);
Zero(&t, sizeof(t));
Copy(t.HashedPassword, hash, SHA1_SIZE);
if (CALL(hWnd, EcSetPassword(r, &t)) == false)
{
break;
}
MsgBox(hWnd, MB_ICONINFORMATION, _UU("CM_PASSWORD_SET"));
EndDialog(hWnd, 1);
break;
case IDCANCEL:
Close(hWnd);
break;
}
switch (LOWORD(wParam))
{
case E_PASSWORD1:
case E_PASSWORD2:
GetTxtA(hWnd, E_PASSWORD1, pass1, sizeof(pass1));
GetTxtA(hWnd, E_PASSWORD2, pass2, sizeof(pass2));
SetEnable(hWnd, IDOK, StrCmp(pass1, pass2) == 0 ? true : false);
break;
}
break;
case WM_CLOSE:
EndDialog(hWnd, 0);
break;
}
return 0;
}
// Remote connection dialog
char *EmRemoteDlg()
{
WINUI_REMOTE r;
Zero(&r, sizeof(r));
r.RegKeyName = EM_REG_KEY;
r.Caption = _UU("EM_TITLE");
r.Title = _UU("EM_REMOTE_TITLE");
r.Icon = ICO_USER_ADMIN;
r.DefaultHostname = NULL;
if (Dialog(NULL, D_EM_REMOTE, EmRemoteDlgProc, &r) == false)
{
return NULL;
}
return r.Hostname;
}
// Initialize
void EmMainInit(HWND hWnd, RPC *r)
{
// Validate arguments
if (hWnd == NULL || r == NULL)
{
return;
}
LvInit(hWnd, L_LIST);
LvInsertColumn(hWnd, L_LIST, 0, _UU("EM_MAIN_COLUMN_1"), 300);
LvInsertColumn(hWnd, L_LIST, 1, _UU("EM_MAIN_COLUMN_2"), 150);
SetIcon(hWnd, 0, ICO_NIC_ONLINE);
EmMainRefresh(hWnd, r);
SetTimer(hWnd, 1, 1000, NULL);
}
// Change Password dialog
UINT NmChangePasswordProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
{
RPC *r = (RPC *)param;
char tmp1[MAX_SIZE];
char tmp2[MAX_SIZE];
RPC_SET_PASSWORD t;
// Validate arguments
if (hWnd == NULL)
{
return 0;
}
switch (msg)
{
case WM_INITDIALOG:
FormatText(hWnd, 0, r->Sock->RemoteHostname);
FormatText(hWnd, S_TITLE, r->Sock->RemoteHostname);
break;
case WM_COMMAND:
GetTxtA(hWnd, E_PASSWORD1, tmp1, sizeof(tmp1));
GetTxtA(hWnd, E_PASSWORD2, tmp2, sizeof(tmp2));
switch (LOWORD(wParam))
{
case E_PASSWORD1:
case E_PASSWORD2:
SetEnable(hWnd, IDOK, StrCmp(tmp1, tmp2) == 0);
break;
}
switch (wParam)
{
case IDOK:
Zero(&t, sizeof(t));
Hash(t.HashedPassword, tmp1, StrLen(tmp1), true);
if (CALL(hWnd, NcSetPassword(r, &t)))
{
MsgBox(hWnd, MB_ICONINFORMATION, _UU("NM_PASSWORD_MSG"));
EndDialog(hWnd, true);
}
break;
case IDCANCEL:
Close(hWnd);
break;
}
break;
case WM_CLOSE:
EndDialog(hWnd, false);
break;
}
return 0;
}
// Get the help string of command
void GetCommandHelpStr(char *command_name, wchar_t **description, wchar_t **args, wchar_t **help)
{
char tmp1[128], tmp2[128], tmp3[128];
Format(tmp1, sizeof(tmp1), "CMD_%s", command_name);
Format(tmp2, sizeof(tmp2), "CMD_%s_ARGS", command_name);
Format(tmp3, sizeof(tmp3), "CMD_%s_HELP", command_name);
if (description != NULL)
{
*description = _UU(tmp1);
if (UniIsEmptyStr(*description))
{
*description = _UU("CMD_UNKNOWM");
}
}
if (args != NULL)
{
*args = _UU(tmp2);
if (UniIsEmptyStr(*args))
{
*args = _UU("CMD_UNKNOWN_ARGS");
}
}
if (help != NULL)
{
*help = _UU(tmp3);
if (UniIsEmptyStr(*help))
{
*help = _UU("CMD_UNKNOWN_HELP");
}
}
}
// Evaluate whether it is SafeStr
bool CmdEvalSafe(CONSOLE *c, wchar_t *str, void *param)
{
wchar_t *p = (param == NULL) ? _UU("CMD_EVAL_SAFE") : (wchar_t *)param;
if (IsSafeUniStr(str))
{
return true;
}
c->Write(c, p);
return false;
}
// Evaluation of integer
bool CmdEvalInt1(CONSOLE *c, wchar_t *str, void *param)
{
wchar_t *p = (param == NULL) ? _UU("CMD_EVAL_INT") : (wchar_t *)param;
if (UniToInt(str) == 0)
{
c->Write(c, p);
return false;
}
return true;
}
// Evaluation of the parameters that a blank cannot be specified to
bool CmdEvalNotEmpty(CONSOLE *c, wchar_t *str, void *param)
{
wchar_t *p = (param == NULL) ? _UU("CMD_EVAL_NOT_EMPTY") : (wchar_t *)param;
if (UniIsEmptyStr(str) == false)
{
return true;
}
c->Write(c, p);
return false;
}
// Evaluation function for minimum / maximum value of the parameter
bool CmdEvalMinMax(CONSOLE *c, wchar_t *str, void *param)
{
CMD_EVAL_MIN_MAX *e;
wchar_t *tag;
UINT v;
// Validate arguments
if (param == NULL)
{
return false;
}
e = (CMD_EVAL_MIN_MAX *)param;
if (e->StrName == NULL)
{
tag = _UU("CMD_EVAL_MIN_MAX");
}
else
{
tag = _UU(e->StrName);
}
v = UniToInt(str);
if (v >= e->MinValue && v <= e->MaxValue)
{
return true;
}
else
{
wchar_t tmp[MAX_SIZE];
UniFormat(tmp, sizeof(tmp), tag, e->MinValue, e->MaxValue);
c->Write(c, tmp);
return false;
}
}
// Get description string for range of the policy value
void GetPolicyValueRangeStr(wchar_t *str, UINT size, UINT id)
{
POLICY_ITEM *p;
// Validate arguments
if (str == NULL)
{
return;
}
p = GetPolicyItem(id);
if (p->TypeInt == false)
{
// bool type
UniStrCpy(str, size, _UU("CMD_PolicyList_Range_Bool"));
}
else
{
wchar_t *tag;
wchar_t tmp1[256], tmp2[256];
// int type
if (p->AllowZero)
{
tag = _UU("CMD_PolicyList_Range_Int_2");
}
else
{
tag = _UU("CMD_PolicyList_Range_Int_1");
}
UniFormat(tmp1, sizeof(tmp1), _UU(p->FormatStr), p->MinValue);
UniFormat(tmp2, sizeof(tmp2), _UU(p->FormatStr), p->MaxValue);
UniFormat(str, size, tag, tmp1, tmp2);
}
}
// NAT enumeration initialization
void NmNatInit(HWND hWnd, SM_HUB *r)
{
// Validate arguments
if (hWnd == NULL || r == NULL)
{
return;
}
SetIcon(hWnd, 0, ICO_PROTOCOL);
LvInit(hWnd, L_TABLE);
LvInsertColumn(hWnd, L_TABLE, 0, _UU("NM_NAT_ID"), 50);
LvInsertColumn(hWnd, L_TABLE, 1, _UU("NM_NAT_PROTOCOL"), 80);
LvInsertColumn(hWnd, L_TABLE, 2, _UU("NM_NAT_SRC_HOST"), 100);
LvInsertColumn(hWnd, L_TABLE, 3, _UU("NM_NAT_SRC_PORT"), 80);
LvInsertColumn(hWnd, L_TABLE, 4, _UU("NM_NAT_DST_HOST"), 150);
LvInsertColumn(hWnd, L_TABLE, 5, _UU("NM_NAT_DST_PORT"), 80);
LvInsertColumn(hWnd, L_TABLE, 6, _UU("NM_NAT_CREATED"), 200);
LvInsertColumn(hWnd, L_TABLE, 7, _UU("NM_NAT_LAST_COMM"), 200);
LvInsertColumn(hWnd, L_TABLE, 8, _UU("NM_NAT_SIZE"), 120);
LvInsertColumn(hWnd, L_TABLE, 9, _UU("NM_NAT_TCP_STATUS"), 120);
NmNatRefresh(hWnd, r);
}
// Format policy value
void FormatPolicyValue(wchar_t *str, UINT size, UINT id, UINT value)
{
POLICY_ITEM *p;
// Validate arguments
if (str == NULL)
{
return;
}
p = GetPolicyItem(id);
if (p->TypeInt == false)
{
// bool type
if (value == 0)
{
UniStrCpy(str, size, L"No");
}
else
{
UniStrCpy(str, size, L"Yes");
}
}
else
{
// int type
if (value == 0 && p->AllowZero)
{
UniStrCpy(str, size, _UU("CMD_NO_SETTINGS"));
}
else
{
UniFormat(str, size, _UU(p->FormatStr), value);
}
}
}
// Read one line from the console
wchar_t *ConsoleLocalReadLine(CONSOLE *c, wchar_t *prompt, bool nofile)
{
wchar_t *ret;
LOCAL_CONSOLE_PARAM *p;
// Validate arguments
if (c == NULL)
{
return NULL;
}
p = (LOCAL_CONSOLE_PARAM *)c->Param;
if (prompt == NULL)
{
prompt = L">";
}
ConsoleWriteOutFile(c, prompt, false);
if (nofile == false && p->InBuf != NULL)
{
// Read the next line from the file
ret = ConsoleReadNextFromInFile(c);
if (ret != NULL)
{
// Display the pseudo prompt
UniPrint(L"%s", prompt);
// Display on the screen
UniPrint(L"%s\n", ret);
}
}
else
{
// Read the following line from the console
ret = Prompt(prompt);
}
if (ret != NULL)
{
ConsoleWriteOutFile(c, ret, true);
}
else
{
ConsoleWriteOutFile(c, _UU("CON_USER_CANCEL"), true);
}
return ret;
}
// Get an error string in Unicode
wchar_t *GetUniErrorStr(UINT err)
{
wchar_t *ret;
char name[MAX_SIZE];
Format(name, sizeof(name), "ERR_%u", err);
ret = GetTableUniStr(name);
if (UniStrLen(ret) != 0)
{
return ret;
}
else
{
return _UU("ERR_UNKNOWN");
}
}
// Initialize
void InitNM()
{
if (nm != NULL)
{
// Already initialized
return;
}
nm = ZeroMalloc(sizeof(NM));
InitWinUi(_UU("NM_TITLE"), _SS("DEFAULT_FONT"), _II("DEFAULT_FONT_SIZE"));
nm->Cedar = NewCedar(NULL, NULL);
InitCM(false);
InitSM();
}
// DHCP enumeration initialization
void NmDhcpInit(HWND hWnd, SM_HUB *r)
{
// Validate arguments
if (hWnd == NULL || r == NULL)
{
return;
}
SetIcon(hWnd, 0, ICO_INTERNET);
LvInit(hWnd, L_TABLE);
LvInsertColumn(hWnd, L_TABLE, 0, _UU("DHCP_DHCP_ID"), 50);
LvInsertColumn(hWnd, L_TABLE, 1, _UU("DHCP_LEASED_TIME"), 200);
LvInsertColumn(hWnd, L_TABLE, 2, _UU("DHCP_EXPIRE_TIME"), 200);
LvInsertColumn(hWnd, L_TABLE, 3, _UU("DHCP_MAC_ADDRESS"), 130);
LvInsertColumn(hWnd, L_TABLE, 4, _UU("DHCP_IP_ADDRESS"), 100);
LvInsertColumn(hWnd, L_TABLE, 5, _UU("DHCP_HOSTNAME"), 150);
NmDhcpRefresh(hWnd, r);
}
// 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);
}
// License dialog initialization
void EmLicenseDlgInit(HWND hWnd, RPC *s)
{
// Validate arguments
if (hWnd == NULL || s == NULL)
{
return;
}
SetIcon(hWnd, 0, ICO_CERT);
DlgFont(hWnd, S_BOLD, 0, true);
DlgFont(hWnd, S_BOLD2, 0, true);
LvInit(hWnd, L_LIST);
LvSetStyle(hWnd, L_LIST, LVS_EX_GRIDLINES);
LvInsertColumn(hWnd, L_LIST, 0, _UU("SM_LICENSE_COLUMN_1"), 50);
LvInsertColumn(hWnd, L_LIST, 1, _UU("SM_LICENSE_COLUMN_2"), 100);
LvInsertColumn(hWnd, L_LIST, 2, _UU("SM_LICENSE_COLUMN_3"), 290);
LvInsertColumn(hWnd, L_LIST, 3, _UU("SM_LICENSE_COLUMN_4"), 150);
LvInsertColumn(hWnd, L_LIST, 4, _UU("SM_LICENSE_COLUMN_5"), 120);
LvInsertColumn(hWnd, L_LIST, 5, _UU("SM_LICENSE_COLUMN_6"), 250);
LvInsertColumn(hWnd, L_LIST, 6, _UU("SM_LICENSE_COLUMN_7"), 100);
LvInsertColumn(hWnd, L_LIST, 7, _UU("SM_LICENSE_COLUMN_8"), 100);
LvInsertColumn(hWnd, L_LIST, 8, _UU("SM_LICENSE_COLUMN_9"), 100);
LvInitEx(hWnd, L_STATUS, true);
LvInsertColumn(hWnd, L_STATUS, 0, _UU("SM_STATUS_COLUMN_1"), 100);
LvInsertColumn(hWnd, L_STATUS, 1, _UU("SM_STATUS_COLUMN_2"), 100);
EmLicenseDlgRefresh(hWnd, s);
}
// License dialog
UINT EmLicenseDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
{
RPC *s = (RPC *)param;
NMHDR *n;
// Validate arguments
if (hWnd == NULL)
{
return 0;
}
switch (msg)
{
case WM_INITDIALOG:
EmLicenseDlgInit(hWnd, s);
break;
case WM_NOTIFY:
n = (NMHDR *)lParam;
switch (n->code)
{
case LVN_ITEMCHANGED:
switch (n->idFrom)
{
case L_LIST:
case L_STATUS:
EmLicenseDlgUpdate(hWnd, s);
break;
}
break;
}
break;
case WM_COMMAND:
switch (wParam)
{
case IDOK:
if (IsEnable(hWnd, IDOK))
{
UINT i = LvGetSelected(hWnd, L_LIST);
if (i != INFINITE)
{
char *s = LvGetStrA(hWnd, L_LIST, i, 5);
char tmp[MAX_SIZE];
Format(tmp, sizeof(tmp), _SS("LICENSE_SUPPORT_URL"), s);
ShellExecute(hWnd, "open", tmp, NULL, NULL, SW_SHOW);
Free(s);
}
}
break;
case B_OBTAIN:
ShellExecute(hWnd, "open", _SS("LICENSE_INFO_URL"), NULL, NULL, SW_SHOW);
break;
case B_ADD:
if (EmLicenseAdd(hWnd, s))
{
EmLicenseDlgRefresh(hWnd, s);
}
break;
case B_DEL:
if (IsEnable(hWnd, B_DEL))
{
UINT id = (UINT)LvGetParam(hWnd, L_LIST, LvGetSelected(hWnd, L_LIST));
if (id != 0)
{
if (MsgBox(hWnd, MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2, _UU("SM_LICENSE_DELETE_MSG")) == IDYES)
{
RPC_TEST t;
Zero(&t, sizeof(t));
t.IntValue = id;
if (CALL(hWnd, EcDelLicenseKey(s, &t)))
{
EmLicenseDlgRefresh(hWnd, s);
}
}
}
}
break;
case IDCANCEL:
Close(hWnd);
break;
}
break;
case WM_CLOSE:
EndDialog(hWnd, 0);
break;
}
LvStandardHandler(hWnd, msg, wParam, lParam, L_LIST);
return 0;
}
// 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);
}
