debmon
/
softether-vpn
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
softether-vpn/src/Cedar/CM.c

12529 lines
263 KiB
C
Raw Blame History

// SoftEther VPN Source Code - Stable Edition Repository
// Cedar Communication Module
//
// SoftEther VPN Server, Client and Bridge are free software under GPLv2.
//
// Copyright (c) Daiyuu Nobori.
// Copyright (c) SoftEther VPN Project, University of Tsukuba, Japan.
// Copyright (c) SoftEther Corporation.
//
// All Rights Reserved.
//
// http://www.softether.org/
//
// Author: Daiyuu Nobori, Ph.D.
// Contributors:
// - ELIN (https://github.com/el1n)
// Comments: Tetsuo Sugiyama, Ph.D.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// version 2 as published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License version 2
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
// THE LICENSE AGREEMENT IS ATTACHED ON THE SOURCE-CODE PACKAGE
// AS "LICENSE.TXT" FILE. READ THE TEXT FILE IN ADVANCE TO USE THE SOFTWARE.
//
//
// THIS SOFTWARE IS DEVELOPED IN JAPAN, AND DISTRIBUTED FROM JAPAN,
// UNDER JAPANESE LAWS. YOU MUST AGREE IN ADVANCE TO USE, COPY, MODIFY,
// MERGE, PUBLISH, DISTRIBUTE, SUBLICENSE, AND/OR SELL COPIES OF THIS
// SOFTWARE, THAT ANY JURIDICAL DISPUTES WHICH ARE CONCERNED TO THIS
// SOFTWARE OR ITS CONTENTS, AGAINST US (SOFTETHER PROJECT, SOFTETHER
// CORPORATION, DAIYUU NOBORI OR OTHER SUPPLIERS), OR ANY JURIDICAL
// DISPUTES AGAINST US WHICH ARE CAUSED BY ANY KIND OF USING, COPYING,
// MODIFYING, MERGING, PUBLISHING, DISTRIBUTING, SUBLICENSING, AND/OR
// SELLING COPIES OF THIS SOFTWARE SHALL BE REGARDED AS BE CONSTRUED AND
// CONTROLLED BY JAPANESE LAWS, AND YOU MUST FURTHER CONSENT TO
// EXCLUSIVE JURISDICTION AND VENUE IN THE COURTS SITTING IN TOKYO,
// JAPAN. YOU MUST WAIVE ALL DEFENSES OF LACK OF PERSONAL JURISDICTION
// AND FORUM NON CONVENIENS. PROCESS MAY BE SERVED ON EITHER PARTY IN
// THE MANNER AUTHORIZED BY APPLICABLE LAW OR COURT RULE.
//
// USE ONLY IN JAPAN. DO NOT USE THIS SOFTWARE IN ANOTHER COUNTRY UNLESS
// YOU HAVE A CONFIRMATION THAT THIS SOFTWARE DOES NOT VIOLATE ANY
// CRIMINAL LAWS OR CIVIL RIGHTS IN THAT PARTICULAR COUNTRY. USING THIS
// SOFTWARE IN OTHER COUNTRIES IS COMPLETELY AT YOUR OWN RISK. THE
// SOFTETHER VPN PROJECT HAS DEVELOPED AND DISTRIBUTED THIS SOFTWARE TO
// COMPLY ONLY WITH THE JAPANESE LAWS AND EXISTING CIVIL RIGHTS INCLUDING
// PATENTS WHICH ARE SUBJECTS APPLY IN JAPAN. OTHER COUNTRIES' LAWS OR
// CIVIL RIGHTS ARE NONE OF OUR CONCERNS NOR RESPONSIBILITIES. WE HAVE
// NEVER INVESTIGATED ANY CRIMINAL REGULATIONS, CIVIL LAWS OR
// INTELLECTUAL PROPERTY RIGHTS INCLUDING PATENTS IN ANY OF OTHER 200+
// COUNTRIES AND TERRITORIES. BY NATURE, THERE ARE 200+ REGIONS IN THE
// WORLD, WITH DIFFERENT LAWS. IT IS IMPOSSIBLE TO VERIFY EVERY
// COUNTRIES' LAWS, REGULATIONS AND CIVIL RIGHTS TO MAKE THE SOFTWARE
// COMPLY WITH ALL COUNTRIES' LAWS BY THE PROJECT. EVEN IF YOU WILL BE
// SUED BY A PRIVATE ENTITY OR BE DAMAGED BY A PUBLIC SERVANT IN YOUR
// COUNTRY, THE DEVELOPERS OF THIS SOFTWARE WILL NEVER BE LIABLE TO
// RECOVER OR COMPENSATE SUCH DAMAGES, CRIMINAL OR CIVIL
// RESPONSIBILITIES. NOTE THAT THIS LINE IS NOT LICENSE RESTRICTION BUT
// JUST A STATEMENT FOR WARNING AND DISCLAIMER.
//
//
// SOURCE CODE CONTRIBUTION
// ------------------------
//
// Your contribution to SoftEther VPN Project is much appreciated.
// Please send patches to us through GitHub.
// Read the SoftEther VPN Patch Acceptance Policy in advance:
// http://www.softether.org/5-download/src/9.patch
//
//
// DEAR SECURITY EXPERTS
// ---------------------
//
// If you find a bug or a security vulnerability please kindly inform us
// about the problem immediately so that we can fix the security problem
// to protect a lot of users around the world as soon as possible.
//
// Our e-mail address for security reports is:
// softether-vpn-security [at] softether.org
//
// Please note that the above e-mail address is not a technical support
// inquiry address. If you need technical assistance, please visit
// http://www.softether.org/ and ask your question on the users forum.
//
// Thank you for your cooperation.
//
//
// NO MEMORY OR RESOURCE LEAKS
// ---------------------------
//
// The memory-leaks and resource-leaks verification under the stress
// test has been passed before release this source code.
// CM.c
// VPN Client Connection Manager for Win32
#include <GlobalConst.h>
#ifdef WIN32
#define CM_C
#define SM_C
#define MICROSOFT_C
#define _WIN32_WINNT 0x0502
#define WINVER 0x0502
#include <winsock2.h>
#include <windows.h>
#include <Iphlpapi.h>
#include <tlhelp32.h>
#include <shlobj.h>
#include <commctrl.h>
#include <Dbghelp.h>
#include <setupapi.h>
#include <regstr.h>
#include <process.h>
#include <psapi.h>
#include <wtsapi32.h>
#include <Ntsecapi.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <wchar.h>
#include <stdarg.h>
#include <time.h>
#include <errno.h>
#include <Mayaqua/Mayaqua.h>
#include <Cedar/Cedar.h>
#include "CMInner.h"
#include "SMInner.h"
#include "NMInner.h"
#include "EMInner.h"
#include "../PenCore/resource.h"
// Get the proxy server settings from the registry string of IE
bool CmGetProxyServerNameAndPortFromIeProxyRegStr(char *name, UINT name_size, UINT *port, char *str, char *server_type)
{
TOKEN_LIST *t;
UINT i;
bool ret = false;
// Validate arguments
if (name == NULL || port == NULL || str == NULL || server_type == NULL)
{
return false;
}
t = ParseToken(str, ";");
for (i = 0;i < t->NumTokens;i++)
{
char *s = t->Token[i];
UINT i;
Trim(s);
i = SearchStrEx(s, "=", 0, false);
if (i != INFINITE)
{
char tmp[MAX_PATH];
StrCpy(name, name_size, s);
name[i] = 0;
if (StrCmpi(name, server_type) == 0)
{
char *host;
StrCpy(tmp, sizeof(tmp), s + i + 1);
if (ParseHostPort(tmp, &host, port, 0))
{
StrCpy(name, name_size, host);
Free(host);
if (*port != 0)
{
ret = true;
}
break;
}
}
}
}
FreeToken(t);
return ret;
}
// Reflect the contents of the proxy settings to the connection settings
void CmProxyDlgSet(HWND hWnd, CLIENT_OPTION *o, CM_INTERNET_SETTING *setting)
{
// Validate arguments
if(hWnd == NULL || setting == NULL)
{
return;
}
// Make check in check-box
Check(hWnd, R_DIRECT_TCP, setting->ProxyType == PROXY_DIRECT);
Check(hWnd, R_HTTPS, setting->ProxyType == PROXY_HTTP);
Check(hWnd, R_SOCKS, setting->ProxyType == PROXY_SOCKS);
// Proxy Settings
if(setting->ProxyType != PROXY_DIRECT)
{
StrCpy(o->ProxyName, sizeof(setting->ProxyHostName), setting->ProxyHostName);
o->ProxyPort = setting->ProxyPort;
}
}
// Get the proxy settings of IE
void CmGetSystemInternetSetting(CM_INTERNET_SETTING *setting)
{
bool use_proxy;
// Validate arguments
if (setting == NULL)
{
return;
}
Zero(setting, sizeof(CM_INTERNET_SETTING));
use_proxy = MsRegReadInt(REG_CURRENT_USER,
"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings",
"ProxyEnable");
if (use_proxy)
{
char *str = MsRegReadStr(REG_CURRENT_USER,
"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings",
"ProxyServer");
if (str != NULL)
{
char name[MAX_HOST_NAME_LEN + 1];
UINT port;
if (CmGetProxyServerNameAndPortFromIeProxyRegStr(name, sizeof(name),
&port, str, "https"))
{
setting->ProxyType = PROXY_HTTP;
StrCpy(setting->ProxyHostName, sizeof(setting->ProxyHostName), name);
setting->ProxyPort = port;
}
else if (CmGetProxyServerNameAndPortFromIeProxyRegStr(name, sizeof(name),
&port, str, "http"))
{
setting->ProxyType = PROXY_HTTP;
StrCpy(setting->ProxyHostName, sizeof(setting->ProxyHostName), name);
setting->ProxyPort = port;
}
else if (CmGetProxyServerNameAndPortFromIeProxyRegStr(name, sizeof(name),
&port, str, "socks"))
{
setting->ProxyType = PROXY_SOCKS;
StrCpy(setting->ProxyHostName, sizeof(setting->ProxyHostName), name);
setting->ProxyPort = port;
}
else
{
if (SearchStrEx(str, "=", 0, false) == INFINITE)
{
char *host;
UINT port;
if (ParseHostPort(str, &host, &port, 0))
{
if (port != 0)
{
setting->ProxyType = PROXY_HTTP;
StrCpy(setting->ProxyHostName, sizeof(setting->ProxyHostName), host);
setting->ProxyPort = port;
}
Free(host);
}
}
}
Free(str);
}
}
}
// For the proxy settings to go through, use the IE settings
void CmProxyDlgUseForIE(HWND hWnd, CLIENT_OPTION *o)
{
CM_INTERNET_SETTING s;
// Validate arguments
if(hWnd == NULL)
{
return;
}
Zero(&s, sizeof(s));
CmGetSystemInternetSetting(&s);
CmProxyDlgSet(hWnd, o, &s);
}
// Determine the bitmap ID of the smart card authentication screen
UINT CmGetSecureBitmapId(char *dest_hostname)
{
// Validate arguments
if (dest_hostname == NULL)
{
return 0;
}
if (EndWith(dest_hostname, ".cc.tsukuba.ac.jp"))
{
return BMP_TSUKUBA;
}
return 0;
}
// Activate the window of UAC
void CmSetUacWindowActive()
{
HWND hWnd;
if (MsIsVista() == false)
{
return;
}
hWnd = FindWindowA("$$$Secure UAP Dummy Window Class For Interim Dialog", NULL);
if (hWnd == NULL)
{
return;
}
SwitchToThisWindow(hWnd, true);
}
// UAC helper thread
void CmUacHelperThread(THREAD *thread, void *param)
{
CM_UAC_HELPER *c = (CM_UAC_HELPER *)param;
// Validate arguments
if (c == NULL)
{
return;
}
while (c->Halt == false)
{
CmSetUacWindowActive();
Wait(c->HaltEvent, 200);
}
}
// Start the UAC helper
void *CmStartUacHelper()
{
CM_UAC_HELPER *c = ZeroMalloc(sizeof(CM_UAC_HELPER));
c->HaltEvent = NewEvent();
c->Thread = NewThread(CmUacHelperThread, c);
return (void *)c;
}
// Stop the UAC helper
void CmStopUacHelper(void *p)
{
CM_UAC_HELPER *c = (CM_UAC_HELPER *)p;
// Validate arguments
if (c == NULL)
{
return;
}
c->Halt = true;
Set(c->HaltEvent);
WaitThread(c->Thread, INFINITE);
ReleaseEvent(c->HaltEvent);
ReleaseThread(c->Thread);
Free(c);
}
// Command invocation of the simple connection manager
void CmEasyDlgOnCommand(HWND hWnd, CM_EASY_DLG *d, WPARAM wParam, LPARAM lParam)
{
// Validate arguments
if (hWnd == NULL || d == NULL)
{
return;
}
switch (wParam)
{
case B_MODE:
Command(hWnd, CMD_CM_SETTING);
return;
case B_STATUS:
Command(hWnd, CMD_STATUS);
return;
case IDCANCEL:
Close(hWnd);
return;
}
if (wParam == CMD_CONNECT)
{
cm->ConnectStartedFlag = false;
}
CmMainWindowOnCommandEx(hWnd, wParam, lParam, true);
if (wParam == CMD_CONNECT && cm->ConnectStartedFlag)
{
// Close the window when the connection started successfully
Close(hWnd);
}
}
// Keyboard pressing of the simple connection manager
void CmEasyDlgOnKey(HWND hWnd, CM_EASY_DLG *d, bool ctrl, bool alt, UINT key)
{
// Validate arguments
if (hWnd == NULL)
{
return;
}
// Single key
switch (key)
{
case VK_RETURN:
Command(hWnd, IDOK);
break;
case VK_DELETE:
// Delete
if (IsFocus(hWnd, L_ACCOUNT))
{
// Operation on the account list
Command(hWnd, CMD_DELETE);
}
else
{
// Operation on the virtual LAN card list
Command(hWnd, CMD_DELETE_VLAN);
}
break;
case VK_F2:
// Change the name
Command(hWnd, CMD_RENAME);
break;
case VK_F5:
// Update the status
Command(hWnd, CMD_REFRESH);
break;
}
if (alt)
{
switch (key)
{
case 'Q':
// Close
Command(hWnd, CMD_QUIT);
break;
}
}
if (ctrl)
{
switch (key)
{
case 'G':
// Smart Card Manager
Command(hWnd, CMD_SECURE_MANAGER);
break;
case 'S':
// Show the status
Command(hWnd, CMD_STATUS);
break;
case 'I':
// Disconnect all connections
Command(hWnd, CMD_DISCONNECT_ALL);
break;
case 'D':
// Disconnect
Command(hWnd, CMD_DISCONNECT);
break;
case 'N':
// Create a new connection setting
Command(hWnd, CMD_NEW);
break;
case 'C':
// Creating a copy
Command(hWnd, CMD_CLONE);
break;
case 'T':
// Set to start-up connection
Command(hWnd, CMD_STARTUP);
break;
case 'A':
// Select all
Command(hWnd, CMD_SELECT_ALL);
break;
case 'L':
// Create a new virtual LAN card
Command(hWnd, CMD_NEW_VLAN);
break;
case 'P':
// Set the password
Command(hWnd, CMD_PASSWORD);
break;
case 'O':
// Option settings
Command(hWnd, CMD_TRAFFIC);
break;
case 'R':
// Certificate management
Command(hWnd, CMD_TRUST);
break;
case 'Q':
// Throughput
Command(hWnd, CMD_TRAFFIC);
break;
}
}
}
// Operation on the list view of the simple connection manager
void CmEasyDlgOnNotify(HWND hWnd, CM_EASY_DLG *d, NMHDR *n)
{
NMLVDISPINFOW *disp_info;
NMLVKEYDOWN *key;
// Validate arguments
if (hWnd == NULL || n == NULL)
{
return;
}
switch (n->idFrom)
{
case L_ACCOUNT:
switch (n->code)
{
case LVN_ITEMCHANGED:
CmEasyDlgUpdate(hWnd, d);
break;
case NM_DBLCLK:
// Double click
Command(hWnd, CMD_EASY_DBLCLICK);
break;
case NM_RCLICK:
// Right click
CmAccountListRightClick(hWnd);
break;
case LVN_ENDLABELEDITW:
// Change the name
disp_info = (NMLVDISPINFOW *)n;
if (disp_info->item.pszText != NULL)
{
wchar_t *new_name = disp_info->item.pszText;
wchar_t *old_name = LvGetStr(hWnd, L_ACCOUNT, disp_info->item.iItem, 0);
if (old_name != NULL)
{
if (UniStrCmp(new_name, old_name) != 0 && UniIsEmptyStr(new_name) == false)
{
RPC_RENAME_ACCOUNT a;
Zero(&a, sizeof(a));
UniStrCpy(a.OldName, sizeof(a.OldName), old_name);
UniStrCpy(a.NewName, sizeof(a.NewName), new_name);
if (CALL(hWnd, CcRenameAccount(cm->Client, &a)))
{
LvSetItem(hWnd, L_ACCOUNT, disp_info->item.iItem, 0, new_name);
}
}
Free(old_name);
}
}
break;
case LVN_KEYDOWN:
// Key-press
key = (NMLVKEYDOWN *)n;
if (key != NULL)
{
bool ctrl, alt;
UINT code = key->wVKey;
ctrl = (GetKeyState(VK_CONTROL) & 0x8000) == 0 ? false : true;
alt = (GetKeyState(VK_MENU) & 0x8000) == 0 ? false : true;
CmEasyDlgOnKey(hWnd, d, ctrl, alt, code);
}
break;
}
break;
}
}
// Send an update notification to the Simple Connection Manager
void CmRefreshEasy()
{
if (cm->hEasyWnd == NULL)
{
return;
}
SendMessage(cm->hEasyWnd, WM_CM_EASY_REFRESH, 0, 0);
}
// Initialze the Simple Connect Manager
void CmEasyDlgInit(HWND hWnd, CM_EASY_DLG *d)
{
HFONT hFontForList;
HFONT hFontButton;
HFONT hFontTitle;
HFONT hFontInfo;
HFONT hFontOther;
UINT i, num, num2, j;
bool b = false;
char *font_name = NULL;
bool font_bold = true;
// Validate arguments
if (hWnd == NULL || d == NULL)
{
return;
}
SetIcon(hWnd, 0, ICO_VPN);
// Window handle registration
cm->hEasyWnd = hWnd;
// Show in the center
Center(hWnd);
// Update the account list
CmInitAccountListEx(hWnd, true);
// Font settings of the list
if (cm->VistaStyle)
{
if (_GETLANG() == 0)
{
font_name = "Meiryo";
font_bold = false;
}
else if (_GETLANG() == 2)
{
font_name = "Microsoft YaHei";
font_bold = false;
}
}
hFontForList = GetFont(font_name, 14, font_bold, false, false, false);
hFontButton = GetFont(font_name, 13, font_bold, false, false, false);
hFontTitle = GetFont(font_name, 14, font_bold, false, false, false);
hFontInfo = GetFont(font_name, 11, font_bold, false, false, false);
hFontOther = GetDialogDefaultFont();
if (cm->VistaStyle)
{
hFontOther = GetMeiryoFont();
}
SetFont(hWnd, L_ACCOUNT, hFontForList);
SetFont(hWnd, IDOK, hFontButton);
SetFont(hWnd, S_TITLE, hFontTitle);
SetFont(hWnd, S_INFO, hFontInfo);
SetFont(hWnd, B_MODE, hFontOther);
SetFont(hWnd, IDCANCEL, hFontOther);
SetFont(hWnd, B_VGC, hFontOther);
SetShow(hWnd, B_VGC, cm->Client->IsVgcSupported);
CmEasyDlgRefresh(hWnd, d);
num = LvNum(hWnd, L_ACCOUNT);
num2 = 0;
j = 0;
for (i = 0;i < num;i++)
{
wchar_t *str = LvGetStr(hWnd, L_ACCOUNT, i, 1);
if (str != NULL)
{
if (UniStrCmpi(str, _UU("CM_ACCOUNT_ONLINE")) == 0 || UniStrCmpi(str, _UU("CM_ACCOUNT_CONNECTING")) == 0)
{
num2++;
j = i;
}
Free(str);
}
}
if (num2 == 1)
{
LvSelect(hWnd, L_ACCOUNT, j);
b = true;
}
if (b == false)
{
if (UniIsEmptyStr(cm->EasyLastSelectedAccountName) == false)
{
i = LvSearchStr(hWnd, L_ACCOUNT, 0, cm->EasyLastSelectedAccountName);
if (i != INFINITE)
{
LvSelect(hWnd, L_ACCOUNT, i);
b = true;
}
}
}
if (b == false)
{
if (LvNum(hWnd, L_ACCOUNT) != 0)
{
LvSelect(hWnd, L_ACCOUNT, 0);
}
}
Focus(hWnd, L_ACCOUNT);
CmEasyDlgUpdate(hWnd, d);
}
// Update the Simple Connection Manager control
void CmEasyDlgUpdate(HWND hWnd, CM_EASY_DLG *d)
{
bool ok = true;
bool show_status = false;
wchar_t *button_str = _UU("CM_EASY_CONNECT_BUTTON_1");
wchar_t *info_str = _UU("CM_EASY_INFO_1");
wchar_t *title_str = _UU("CM_EASY_TITLE");
// Validate arguments
if (hWnd == NULL || d == NULL)
{
return;
}
if (LvIsSingleSelected(hWnd, L_ACCOUNT) == false)
{
ok = false;
}
if (ok)
{
UINT i = LvGetSelected(hWnd, L_ACCOUNT);
wchar_t *str = LvGetStr(hWnd, L_ACCOUNT, i, 1);
info_str = _UU("CM_EASY_INFO_2");
if (str != NULL)
{
if (UniStrCmpi(str, _UU("CM_ACCOUNT_ONLINE")) == 0 || UniStrCmpi(str, _UU("CM_ACCOUNT_CONNECTING")) == 0)
{
button_str = _UU("CM_EASY_CONNECT_BUTTON_2");
show_status = true;
info_str = _UU("CM_EASY_INFO_3");
if (UniStrCmpi(str, _UU("CM_ACCOUNT_ONLINE")) == 0)
{
title_str = _UU("CM_EASY_CONNECTED");
}
else
{
title_str = _UU("CM_EASY_CONNECTING");
}
}
Free(str);
}
}
SetShow(hWnd, B_STATUS, show_status);
SetText(hWnd, IDOK, button_str);
SetText(hWnd, S_INFO, info_str);
SetText(hWnd, S_TITLE, title_str);
SetShow(hWnd, IDOK, ok);
}
// Update the Simple Connect Manager content
void CmEasyDlgRefresh(HWND hWnd, CM_EASY_DLG *d)
{
// Validate arguments
if (hWnd == NULL || d == NULL)
{
return;
}
// Update the account list
CmRefreshAccountListEx(hWnd, true);
CmEasyDlgUpdate(hWnd, d);
}
// Dialog procedure of the simple connection manager
UINT CmEasyDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
{
CM_EASY_DLG *d = (CM_EASY_DLG *)param;
NMHDR *n;
UINT i;
// Validate arguments
if (hWnd == NULL)
{
return 0;
}
switch (msg)
{
case WM_INITDIALOG:
CmEasyDlgInit(hWnd, d);
SetTimer(hWnd, 1, 10, NULL);
break;
case WM_TIMER:
switch (wParam)
{
case 1:
KillTimer(hWnd, 1);
SetForegroundWindow(hWnd);
SetActiveWindow(hWnd);
break;
}
break;
case WM_CM_EASY_REFRESH:
CmEasyDlgRefresh(hWnd, d);
break;
case WM_COMMAND:
CmEasyDlgOnCommand(hWnd, d, wParam, lParam);
break;
case WM_NOTIFY:
n = (NMHDR *)lParam;
CmEasyDlgOnNotify(hWnd, d, n);
break;
case WM_CLOSE:
i = LvGetSelected(hWnd, L_ACCOUNT);
if (i != INFINITE)
{
wchar_t *s = LvGetStr(hWnd, L_ACCOUNT, i, 0);
if (s != NULL)
{
UniStrCpy(cm->EasyLastSelectedAccountName, sizeof(cm->EasyLastSelectedAccountName),
s);
Free(s);
}
}
else
{
Zero(cm->EasyLastSelectedAccountName, sizeof(cm->EasyLastSelectedAccountName));
}
EndDialog(hWnd, false);
break;
}
return 0;
}
// Show the window of the simple connection manager (This is called by a delaying timer)
void CmMainWindowOnShowEasy(HWND hWnd)
{
CM_EASY_DLG d;
Zero(&d, sizeof(d));
if (cm->CmSetting.EasyMode == false)
{
// Not in simple mode
return;
}
if (cm->hEasyWnd != NULL)
{
// It is shown already
SetForegroundWindow(cm->hEasyWnd);
SetActiveWindow(cm->hEasyWnd);
return;
}
Dialog(NULL, D_CM_EASY, CmEasyDlg, &d);
cm->hEasyWnd = NULL;
}
// Show the window of the simple connection manager
void CmShowEasy()
{
SetTimer(cm->hMainWnd, 4, 2, NULL);
}
// Close the window of the simple connection manager
void CmCloseEasy()
{
if (cm->hEasyWnd == NULL)
{
return;
}
SendMessage(cm->hEasyWnd, WM_CLOSE, 0, 0);
}
// Message processing for such as clicking on the tray icon
void CmMainWindowOnTrayClicked(HWND hWnd, WPARAM wParam, LPARAM lParam)
{
bool easymode = cm->CmSetting.EasyMode;
switch (wParam)
{
case 1:
switch (lParam)
{
case WM_LBUTTONDOWN:
case WM_RBUTTONDOWN:
// Click
if (easymode == false)
{
if (IsEnable(hWnd, 0))
{
CmShowTrayMenu(hWnd);
}
else
{
CmShowOrHideWindow(hWnd);
}
}
else
{
if (cm->hEasyWnd == NULL || IsEnable(cm->hEasyWnd, 0))
{
CmShowTrayMenu(hWnd);
}
else
{
//CmShowOrHideWindow(hWnd);
}
}
break;
case WM_LBUTTONDBLCLK:
case WM_RBUTTONDBLCLK:
// Double click
if (easymode == false)
{
if (IsEnable(hWnd, 0))
{
CmShowOrHideWindow(hWnd);
}
}
else
{
if (cm->hEasyWnd == NULL)
{
CmShowEasy();
}
else
{
SetForegroundWindow(cm->hEasyWnd);
SetActiveWindow(cm->hEasyWnd);
}
}
break;
}
break;
}
}
// Apply the setting of the operation mode
void CmApplyCmSetting()
{
CM_SETTING a;
bool changed = false;
if (cm->CmSettingSupported == false)
{
return;
}
// Get the configuration of the current vpnclient
Zero(&a, sizeof(a));
CcGetCmSetting(cm->Client, &a);
// Check whether there is change point as compared to the previous CM_SETTING
if (cm->CmSetting.EasyMode != a.EasyMode)
{
changed = true;
}
if (cm->CmSetting.LockMode != a.LockMode)
{
changed = true;
}
Copy(&cm->CmSetting, &a, sizeof(CM_SETTING));
if (changed == false)
{
return;
}
if (cm->StartupFinished)
{
if (IsShow(cm->hMainWnd, 0) && cm->CmSetting.EasyMode)
{
// Close the main window if it is shown
Hide(cm->hMainWnd, 0);
}
else
{
WINDOWPLACEMENT current_pos;
if (cm->CmSetting.EasyMode == false && IsShow(cm->hMainWnd, 0) == false)
{
// When restored to normal mode, restore the main window
if (IsZero(&cm->FakeWindowPlacement, sizeof(cm->FakeWindowPlacement)) == false)
{
cm->FakeWindowPlacement.flags = cm->FakeWindowPlacement.flags & ~SW_MINIMIZE;
SetWindowPlacement(cm->hMainWnd, &cm->FakeWindowPlacement);
Zero(&cm->FakeWindowPlacement, sizeof(cm->FakeWindowPlacement));
Hide(cm->hMainWnd, 0);
}
CmShowOrHideWindow(cm->hMainWnd);
}
if (cm->CmSetting.EasyMode == false)
{
if (GetWindowPlacement(cm->hMainWnd, &current_pos))
{
if (current_pos.rcNormalPosition.right < 0 ||
current_pos.rcNormalPosition.bottom < 0)
{
// If the window is off the screen for some reason,
// return it in a visible place
SetWindowPos(cm->hMainWnd, NULL, 0, 0, CM_DEFAULT_WIDTH, CM_DEFAULT_HEIGHT, SWP_NOREDRAW | SWP_SHOWWINDOW);
Center(cm->hMainWnd);
}
}
}
}
Command(cm->hMainWnd, CMD_REFRESH);
}
if (cm->CmSetting.EasyMode)
{
if (cm->StartupFinished == false && cm->StartupMode)
{
// Don't show in the case of /startup
}
else
{
CmShowEasy();
}
}
else
{
CmCloseEasy();
}
}
// Initialize the operation mode changing dialog
void CmSettingDlgInit(HWND hWnd, CM_SETTING_DLG *d)
{
CM_SETTING a;
// Validate arguments
if (hWnd == NULL || d == NULL)
{
return;
}
// Get the configuration of the current vpnclient
Zero(&a, sizeof(a));
CcGetCmSetting(cm->Client, &a);
Check(hWnd, R_EASY, a.EasyMode);
Check(hWnd, R_NORMAL, a.EasyMode == false);
if (a.EasyMode == false)
{
Focus(hWnd, R_NORMAL);
}
else
{
Focus(hWnd, R_EASY);
}
Check(hWnd, R_LOCK, a.LockMode);
SetEnable(hWnd, R_EASY, cm->CmEasyModeSupported);
if (a.LockMode)
{
if (IsZero(a.HashedPassword, sizeof(a.HashedPassword)) == false)
{
// Password is set
SetText(hWnd, S_PASSWORD1, _UU("CM_SETTING_PASSWORD"));
Hide(hWnd, S_PASSWORD3);
Hide(hWnd, E_PASSWORD2);
d->CheckPassword = true;
Copy(d->HashedPassword, a.HashedPassword, sizeof(d->HashedPassword));
}
}
SetShow(hWnd, S_VGS1, cm->Client->IsVgcSupported);
SetShow(hWnd, S_VGS2, cm->Client->IsVgcSupported);
SetShow(hWnd, S_VGS3, cm->Client->IsVgcSupported);
SetShow(hWnd, B_VGS, cm->Client->IsVgcSupported);
CmSettingDlgUpdate(hWnd, d);
}
// Update the operation mode changing dialog
void CmSettingDlgUpdate(HWND hWnd, CM_SETTING_DLG *d)
{
bool ok = true;
char tmp1[MAX_SIZE], tmp2[MAX_SIZE];
// Validate arguments
if (hWnd == NULL || d == NULL)
{
return;
}
GetTxtA(hWnd, E_PASSWORD1, tmp1, sizeof(tmp1));
GetTxtA(hWnd, E_PASSWORD2, tmp2, sizeof(tmp2));
if (d->CheckPassword == false)
{
if (IsChecked(hWnd, R_LOCK))
{
if (StrCmp(tmp1, tmp2) != 0)
{
ok = false;
}
}
}
else
{
bool password_ok = false;
UCHAR hash[SHA1_SIZE];
Hash(hash, tmp1, StrLen(tmp1), true);
if (Cmp(hash, d->HashedPassword, sizeof(hash)) == 0)
{
password_ok = true;
}
if (password_ok == false)
{
Check(hWnd, R_LOCK, true);
Disable(hWnd, R_LOCK);
}
else
{
Enable(hWnd, R_LOCK);
}
}
SetEnable(hWnd, S_PASSWORD1, IsChecked(hWnd, R_LOCK));
SetEnable(hWnd, S_PASSWORD2, IsChecked(hWnd, R_LOCK));
SetEnable(hWnd, S_PASSWORD3, IsChecked(hWnd, R_LOCK));
SetEnable(hWnd, E_PASSWORD1, IsChecked(hWnd, R_LOCK));
SetEnable(hWnd, E_PASSWORD2, IsChecked(hWnd, R_LOCK));
SetEnable(hWnd, IDOK, ok);
}
// Operation mode changing dialog OK
void CmSettingDlgOnOk(HWND hWnd, CM_SETTING_DLG *d)
{
CM_SETTING a;
char tmp1[MAX_SIZE], tmp2[MAX_SIZE];
// Validate arguments
if (hWnd == NULL || d == NULL)
{
return;
}
GetTxtA(hWnd, E_PASSWORD1, tmp1, sizeof(tmp1));
GetTxtA(hWnd, E_PASSWORD2, tmp2, sizeof(tmp2));
Zero(&a, sizeof(a));
a.EasyMode = IsChecked(hWnd, R_EASY);
a.LockMode = IsChecked(hWnd, R_LOCK);
if (a.LockMode)
{
if (d->CheckPassword && IsEnable(hWnd, R_LOCK) == false)
{
Copy(a.HashedPassword, d->HashedPassword, sizeof(a.HashedPassword));
}
else
{
if (StrLen(tmp1) >= 1)
{
Hash(a.HashedPassword, tmp1, StrLen(tmp1), true);
}
}
}
CcSetCmSetting(cm->Client, &a);
EndDialog(hWnd, true);
}
// Operation mode changing dialog
UINT CmSettingDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
{
CM_SETTING_DLG *d = (CM_SETTING_DLG *)param;
// Validate arguments
if (hWnd == NULL)
{
return 0;
}
switch (msg)
{
case WM_INITDIALOG:
CmSettingDlgInit(hWnd, d);
break;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case R_EASY:
case R_NORMAL:
case R_LOCK:
case E_PASSWORD1:
case E_PASSWORD2:
case IDOK:
case IDCANCEL:
CmSettingDlgUpdate(hWnd, d);
break;
}
switch (wParam)
{
case IDOK:
CmSettingDlgOnOk(hWnd, d);
break;
case IDCANCEL:
Close(hWnd);
break;
case R_LOCK:
if (IsChecked(hWnd, R_LOCK))
{
if (IsEmpty(hWnd, E_PASSWORD1))
{
Focus(hWnd, E_PASSWORD1);
}
}
break;
}
break;
case WM_CLOSE:
EndDialog(hWnd, false);
break;
}
return 0;
}
// Change operation mode
bool CmSetting(HWND hWnd)
{
CM_SETTING_DLG d;
Zero(&d, sizeof(d));
return Dialog(hWnd, D_CM_SETTING, CmSettingDlg, &d);
}
// Attempting thread for starting the UI Helper
void CmTryToExecUiHelperThread(THREAD *thread, void *param)
{
bool first_flag = true;
while (cm->TryExecUiHelperHalt == false && cm->WindowsShutdowning == false)
{
if (first_flag == false)
{
// Wait a little for other than the first time
Wait(cm->TryExecUiHelperHaltEvent, CM_TRY_EXEC_UI_HELPER_INTERVAL * 2);
if (cm->TryExecUiHelperHalt || cm->WindowsShutdowning)
{
break;
}
}
first_flag = false;
if (cm->TryExecUiHelperHalt == false && cm->WindowsShutdowning == false)
{
if (cm->TryExecUiHelperProcessHandle == NULL)
{
CmTryToExecUiHelper();
}
}
if (cm->TryExecUiHelperHalt || cm->WindowsShutdowning)
{
break;
}
if (cm->TryExecUiHelperProcessHandle == NULL)
{
Wait(cm->TryExecUiHelperHaltEvent, CM_TRY_EXEC_UI_HELPER_INTERVAL);
}
else
{
HANDLE handles[2];
handles[0] = cm->TryExecUiHelperProcessHandle;
handles[1] = (HANDLE)cm->TryExecUiHelperHaltEvent->pData;
WaitForMultipleObjects(2, handles, false, CM_TRY_EXEC_UI_HELPER_INTERVAL);
if (WaitForSingleObject(cm->TryExecUiHelperProcessHandle, 0) != WAIT_TIMEOUT)
{
CloseHandle(cm->TryExecUiHelperProcessHandle);
cm->TryExecUiHelperProcessHandle = NULL;
if (cm->TryExecUiHelperHalt || cm->WindowsShutdowning)
{
break;
}
Wait(cm->TryExecUiHelperHaltEvent, CM_TRY_EXEC_UI_HELPER_INTERVAL * 2);
}
}
}
}
// Stop the UI Helper
void CmFreeTryToExecUiHelper()
{
cm->TryExecUiHelperHalt = true;
Set(cm->TryExecUiHelperHaltEvent);
WaitThread(cm->TryExecUiHelperThread, INFINITE);
ReleaseThread(cm->TryExecUiHelperThread);
cm->TryExecUiHelperThread = NULL;
ReleaseEvent(cm->TryExecUiHelperHaltEvent);
cm->TryExecUiHelperHaltEvent = NULL;
cm->TryExecUiHelperHalt = false;
cm->TryExecUiHelperProcessHandle = NULL;
}
// Initialize the UI Helper starting
void CmInitTryToExecUiHelper()
{
cm->TryExecUiHelperProcessHandle = NULL;
cm->TryExecUiHelperHalt = false;
cm->TryExecUiHelperHaltEvent = NewEvent();
cm->TryExecUiHelperThread = NewThread(CmTryToExecUiHelperThread, NULL);
}
// Start the UI Helper
void *CmExecUiHelperMain()
{
HANDLE h;
wchar_t tmp[MAX_SIZE];
UniFormat(tmp, sizeof(tmp), L"%s\\%S", MsGetExeDirNameW(), CiGetVpnClientExeFileName());
// Start
h = Win32RunExW(tmp, SVC_ARG_UIHELP_W, false);
return (void *)h;
}
// Attempt to start the UI Helper
void CmTryToExecUiHelper()
{
HANDLE h;
// Check that it isn't already running
if (CnCheckAlreadyExists(false))
{
// It have already started
return;
}
h = (HANDLE)CmExecUiHelperMain();
if (h != NULL)
{
cm->TryExecUiHelperProcessHandle = h;
}
}
// Initialize the dialog
void CmTrafficResultDlgInit(HWND hWnd, TT_RESULT *res)
{
LVB *ct;
wchar_t tmp[MAX_SIZE];
wchar_t tmp1[MAX_SIZE];
wchar_t tmp2[MAX_SIZE];
char str[MAX_SIZE];
// Validate arguments
if (hWnd == NULL || res == NULL)
{
return;
}
SetIcon(hWnd, 0, ICO_SWITCH);
SetFont(hWnd, L_STATUS, GetFont(_SS("DEFAULT_FONT_2"), 10, false, false, false, false));
LvInit(hWnd, L_STATUS);
LvSetStyle(hWnd, L_STATUS, LVS_EX_GRIDLINES);
LvInsertColumn(hWnd, L_STATUS, 0, _UU("TTC_RES_COLUMN_1"), 100);
LvInsertColumn(hWnd, L_STATUS, 1, _UU("TTC_RES_COLUMN_2"), 100);
LvInsertColumn(hWnd, L_STATUS, 2, _UU("TTC_RES_COLUMN_3"), 100);
ct = LvInsertStart();
// Time that was used to measure
GetSpanStrMilli(str, sizeof(str), res->Span);
StrToUni(tmp, sizeof(tmp), str);
LvInsertAdd(ct, ICO_DATETIME, NULL, 3, _UU("TTC_RES_SPAN"), tmp, L"");
// Correct the data for Ethernet frame
LvInsertAdd(ct, ICO_INFORMATION, NULL, 3, _UU("TTC_RES_ETHER"), res->Raw ? _UU("SEC_NO") : _UU("SEC_YES"), L"");
// Amount of communication data of download direction
ToStr3(str, sizeof(str), res->NumBytesDownload);
UniFormat(tmp1, sizeof(tmp1), L"%S Bytes", str);
ToStrByte1000(str, sizeof(str), res->NumBytesDownload);
StrToUni(tmp2, sizeof(tmp2), str);
LvInsertAdd(ct, ICO_INFORMATION, NULL, 3, _UU("TTC_RES_BYTES_DOWNLOAD"), tmp1, tmp2);
// Amount of communication data of upload direction
ToStr3(str, sizeof(str), res->NumBytesUpload);
UniFormat(tmp1, sizeof(tmp1), L"%S Bytes", str);
ToStrByte1000(str, sizeof(str), res->NumBytesUpload);
StrToUni(tmp2, sizeof(tmp2), str);
LvInsertAdd(ct, ICO_INFORMATION, NULL, 3, _UU("TTC_RES_BYTES_UPLOAD"), tmp1, tmp2);
// Total amount of communication data
ToStr3(str, sizeof(str), res->NumBytesTotal);
UniFormat(tmp1, sizeof(tmp1), L"%S Bytes", str);
ToStrByte1000(str, sizeof(str), res->NumBytesTotal);
StrToUni(tmp2, sizeof(tmp2), str);
LvInsertAdd(ct, ICO_INFORMATION, NULL, 3, _UU("TTC_RES_BYTES_TOTAL"), tmp1, tmp2);
// Calculate the total throughput of input and output of the relay equipment
LvInsertAdd(ct, ICO_INFORMATION, NULL, 3, _UU("TTC_RES_DOUBLE"), (res->Double == false) ? _UU("SEC_NO") : _UU("SEC_YES"), L"");
// Average throughput of download direction
ToStr3(str, sizeof(str), res->BpsDownload);
UniFormat(tmp1, sizeof(tmp1), L"%S bps", str);
ToStrByte1000(str, sizeof(str), res->BpsDownload);
ReplaceStr(str, sizeof(str), str, "Bytes", "bps");
StrToUni(tmp2, sizeof(tmp2), str);
LvInsertAdd(ct, ICO_INFORMATION, NULL, 3, _UU("TTC_RES_BPS_DOWNLOAD"), tmp1, tmp2);
// Average throughput of upload direction
ToStr3(str, sizeof(str), res->BpsUpload);
UniFormat(tmp1, sizeof(tmp1), L"%S bps", str);
ToStrByte1000(str, sizeof(str), res->BpsUpload);
ReplaceStr(str, sizeof(str), str, "Bytes", "bps");
StrToUni(tmp2, sizeof(tmp2), str);
LvInsertAdd(ct, ICO_INFORMATION, NULL, 3, _UU("TTC_RES_BPS_UPLOAD"), tmp1, tmp2);
// Total average throughput
ToStr3(str, sizeof(str), res->BpsTotal);
UniFormat(tmp1, sizeof(tmp1), L"%S bps", str);
ToStrByte1000(str, sizeof(str), res->BpsTotal);
ReplaceStr(str, sizeof(str), str, "Bytes", "bps");
StrToUni(tmp2, sizeof(tmp2), str);
LvInsertAdd(ct, ICO_INFORMATION, NULL, 3, _UU("TTC_RES_BPS_TOTAL"), tmp1, tmp2);
LvInsertEnd(ct, hWnd, L_STATUS);
LvAutoSize(hWnd, L_STATUS);
}
// Dialog procedure to display results of traffic measurements
UINT CmTrafficResultDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
{
TT_RESULT *r = (TT_RESULT *)param;
// Validate arguments
if (hWnd == NULL)
{
return 0;
}
switch (msg)
{
case WM_INITDIALOG:
CmTrafficResultDlgInit(hWnd, r);
break;
case WM_COMMAND:
switch (wParam)
{
case IDOK:
case IDCANCEL:
Close(hWnd);
break;
}
break;
case WM_CLOSE:
EndDialog(hWnd, 0);
break;
}
return 0;
}
// Display results of traffic measurement
void CmTrafficResult(HWND hWnd, TT_RESULT *r)
{
// Validate arguments
if (r == NULL)
{
return;
}
Dialog(hWnd, D_CM_TRAFFIC_RESULT, CmTrafficResultDlg, r);
}
// Thread to wait for the termination of the client
void CmTrafficRunDlgClientWaitThread(THREAD *t, void *param)
{
CM_TRAFFIC_DLG *d = (CM_TRAFFIC_DLG *)param;
TT_RESULT result;
UINT ret;
// Validate arguments
if (t == NULL || param == NULL)
{
return;
}
Zero(&result, sizeof(result));
ret = FreeTtc(d->Ttc, &result);
d->Ttc = NULL;
d->RetCode = ret;
Copy(&d->Result, &result, sizeof(TT_RESULT));
PostMessage(d->hWnd, WM_APP + 66, 0, 0);
}
// Append the string
void CmTrafficRunDlgAddStr(HWND hWnd, wchar_t *str)
{
wchar_t *tmp;
UINT tmp_size;
tmp_size = UniStrSize(str) + 32;
tmp = Malloc(tmp_size);
UniStrCpy(tmp, tmp_size, str);
if (UniEndWith(str, L"\n") == false)
{
UniStrCat(tmp, tmp_size, L"\n");
}
UniReplaceStrEx(tmp, tmp_size, tmp, L"\r\n", L"\n", false);
UniReplaceStrEx(tmp, tmp_size, tmp, L"\n", L"\r\n", false);
if (MsIsNt())
{
SendMsg(hWnd, E_EDIT, EM_SETSEL, 0x7fffffff, 0x7fffffff);
SendMsg(hWnd, E_EDIT, EM_REPLACESEL, false, (LPARAM)tmp);
}
else
{
char *s = CopyUniToStr(tmp);
UINT len;
len = GetWindowTextLength(DlgItem(hWnd, E_EDIT));
SendMsg(hWnd, E_EDIT, EM_SETSEL, 0x7fffffff, 0x7fffffff);
SendMsg(hWnd, E_EDIT, EM_SETSEL, len, len);
SendMsg(hWnd, E_EDIT, EM_REPLACESEL, false, (LPARAM)s);
Free(s);
}
Free(tmp);
}
// Show the string
void CmTrafficRunDlgPrintProc(void *param, wchar_t *str)
{
CM_TRAFFIC_DLG *d = (CM_TRAFFIC_DLG *)param;
HWND hWnd;
// Validate arguments
if (param == NULL || str == NULL)
{
return;
}
hWnd = d->hWnd;
PostMessage(hWnd, WM_APP + 64, 0, (LPARAM)UniCopyStr(str));
}
// Thread for stop the measurement program
void CmTrafficRunDlgHaltThread(THREAD *t, void *param)
{
CM_TRAFFIC_DLG *d = (CM_TRAFFIC_DLG *)param;
// Validate arguments
if (t == NULL || param == NULL)
{
return;
}
if (d->Setting->ServerMode)
{
// Stop the server
d->RetCode = FreeTts(d->Tts);
PostMessage(d->hWnd, WM_APP + 65, 0, 0);
}
}
// Stop the measurement program
void CmTrafficRunDlgHalt(HWND hWnd, CM_TRAFFIC_DLG *d)
{
// Validate arguments
if (hWnd == NULL || d == NULL)
{
return;
}
if (d->Started == false)
{
return;
}
if (d->Setting->ServerMode)
{
if (d->HaltThread == NULL)
{
Disable(hWnd, IDCANCEL);
d->HaltThread = NewThread(CmTrafficRunDlgHaltThread, d);
}
}
else
{
if (d->ClientEndWaitThread != NULL)
{
StopTtc(d->Ttc);
}
else
{
EndDialog(hWnd, 0);
}
}
}
// Start the operation of traffic measurement
void CmTrafficRunDlgStart(HWND hWnd, CM_TRAFFIC_DLG *d)
{
// Validate arguments
if (hWnd == NULL || d == NULL)
{
return;
}
if (d->Setting->ServerMode)
{
// Start the measurement server
d->Tts = NewTts(d->Setting->Port, d, CmTrafficRunDlgPrintProc);
}
else
{
// Start the measurement client
d->Ttc = NewTtc(d->Setting->Host, d->Setting->Port,
d->Setting->NumTcp, d->Setting->Type, d->Setting->Span * 1000ULL,
d->Setting->Double, d->Setting->Raw, CmTrafficRunDlgPrintProc, d);
d->ClientEndWaitThread = NewThread(CmTrafficRunDlgClientWaitThread, d);
}
d->Started = true;
}
// Traffic measurement operation dialog initialization
void CmTrafficRunDlgInit(HWND hWnd, CM_TRAFFIC_DLG *d)
{
// Validate arguments
if (hWnd == NULL || d == NULL)
{
return;
}
d->hWnd = hWnd;
SetIcon(hWnd, 0, ICO_SWITCH);
DlgFont(hWnd, S_INFO, 11, false);
SetFont(hWnd, E_EDIT, GetFont(_SS("DEFAULT_FONT_2"), 0, false, false,
false, false));
Focus(hWnd, IDCANCEL);
}
// Traffic measurement operation dialog procedure
UINT CmTrafficRunDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
{
CM_TRAFFIC_DLG *d = (CM_TRAFFIC_DLG *)param;
wchar_t *s;
// Validate arguments
if (hWnd == NULL)
{
return 0;
}
switch (msg)
{
case WM_INITDIALOG:
CmTrafficRunDlgInit(hWnd, d);
SetTimer(hWnd, 1, 10, NULL);
break;
case WM_APP + 64:
// Add a string
s = (wchar_t *)lParam;
if (s != NULL)
{
CmTrafficRunDlgAddStr(hWnd, s);
Free(s);
}
break;
case WM_APP + 65:
// Stopping complete
if (d->HaltThread != NULL)
{
WaitThread(d->HaltThread, INFINITE);
ReleaseThread(d->HaltThread);
d->HaltThread = NULL;
EndDialog(hWnd, 0);
}
break;
case WM_APP + 66:
// Show results
if (d->RetCode == ERR_NO_ERROR)
{
CmTrafficResult(hWnd, &d->Result);
}
if (d->ClientEndWaitThread != NULL)
{
WaitThread(d->ClientEndWaitThread, INFINITE);
ReleaseThread(d->ClientEndWaitThread);
d->ClientEndWaitThread = NULL;
}
if (d->CloseDialogAfter)
{
EndDialog(hWnd, 0);
}
break;
case WM_TIMER:
switch (wParam)
{
case 1:
KillTimer(hWnd, 1);
CmTrafficRunDlgStart(hWnd, d);
break;
}
break;
case WM_COMMAND:
switch (wParam)
{
case IDOK:
case IDCANCEL:
Close(hWnd);
break;
}
break;
case WM_CLOSE:
d->CloseDialogAfter = true;
CmTrafficRunDlgHalt(hWnd, d);
return 1;
}
return 0;
}
// Execute a traffic measurement
void CmExecTraffic(HWND hWnd, CM_TRAFFIC *t)
{
CM_TRAFFIC_DLG d;
// Validate arguments
if (t == NULL)
{
return;
}
Zero(&d, sizeof(d));
d.Setting = t;
d.ResultShowEvent = NewEvent();
MsSetThreadPriorityHigh();
Dialog(hWnd, D_CM_TRAFFIC_RUN, CmTrafficRunDlg, &d);
MsRestoreThreadPriority();
ReleaseEvent(d.ResultShowEvent);
}
// Write the settings to the registry
void CmTrafficSaveToReg(CM_TRAFFIC *t)
{
// Validate arguments
if (t == NULL)
{
return;
}
MsRegWriteInt(REG_CURRENT_USER, CM_TRAFFIC_REG_KEY, "ServerMode", t->ServerMode ? 1 : 0);
MsRegWriteInt(REG_CURRENT_USER, CM_TRAFFIC_REG_KEY, "Double", t->Double ? 1 : 0);
MsRegWriteInt(REG_CURRENT_USER, CM_TRAFFIC_REG_KEY, "Raw", t->Raw ? 1 : 0);
MsRegWriteInt(REG_CURRENT_USER, CM_TRAFFIC_REG_KEY, "Port", t->Port);
MsRegWriteInt(REG_CURRENT_USER, CM_TRAFFIC_REG_KEY, "NumTcp", t->NumTcp);
MsRegWriteInt(REG_CURRENT_USER, CM_TRAFFIC_REG_KEY, "Type", t->Type);
MsRegWriteInt(REG_CURRENT_USER, CM_TRAFFIC_REG_KEY, "Span", t->Span);
MsRegWriteStr(REG_CURRENT_USER, CM_TRAFFIC_REG_KEY, "Host", t->Host);
}
// Read the settings from the registry
bool CmTrafficLoadFromReg(CM_TRAFFIC *t)
{
char *s;
// Validate arguments
if (t == NULL)
{
return false;
}
Zero(t, sizeof(CM_TRAFFIC));
if (MsRegIsKey(REG_CURRENT_USER, CM_TRAFFIC_REG_KEY) == false)
{
return false;
}
t->Double = MsRegReadInt(REG_CURRENT_USER, CM_TRAFFIC_REG_KEY, "Double") == 0 ? false : true;
t->Raw = MsRegReadInt(REG_CURRENT_USER, CM_TRAFFIC_REG_KEY, "Raw") == 0 ? false : true;
t->Port = MsRegReadInt(REG_CURRENT_USER, CM_TRAFFIC_REG_KEY, "Port");
if (t->Port == 0)
{
t->Port = TRAFFIC_DEFAULT_PORT;
}
s = MsRegReadStr(REG_CURRENT_USER, CM_TRAFFIC_REG_KEY, "Host");
if (IsEmptyStr(s) == false)
{
Trim(s);
StrCpy(t->Host, sizeof(t->Host), s);
}
Free(s);
t->NumTcp = MsRegReadInt(REG_CURRENT_USER, CM_TRAFFIC_REG_KEY, "NumTcp");
t->NumTcp = MAKESURE(t->NumTcp, 1, TRAFFIC_NUMTCP_MAX);
t->Type = MsRegReadInt(REG_CURRENT_USER, CM_TRAFFIC_REG_KEY, "Type");
if (t->Type != TRAFFIC_TYPE_DOWNLOAD && t->Type != TRAFFIC_TYPE_UPLOAD &&
t->Type != TRAFFIC_TYPE_FULL)
{
t->Type = TRAFFIC_TYPE_FULL;
}
t->Span = MsRegReadInt(REG_CURRENT_USER, CM_TRAFFIC_REG_KEY, "Span");
if (t->Span == 0)
{
t->Span = TRAFFIC_SPAN_DEFAULT;
}
t->ServerMode = MsRegReadInt(REG_CURRENT_USER, CM_TRAFFIC_REG_KEY, "ServerMode") == 0 ? false : true;
return true;
}
// Get the default settings
void CmTrafficGetDefaultSetting(CM_TRAFFIC *t)
{
// Validate arguments
if (t == NULL)
{
return;
}
Zero(t, sizeof(CM_TRAFFIC));
t->Double = false;
t->Raw = false;
t->Port = TRAFFIC_DEFAULT_PORT;
t->NumTcp = TRAFFIC_NUMTCP_DEFAULT;
t->Type = TRAFFIC_TYPE_FULL;
t->Span = TRAFFIC_SPAN_DEFAULT;
t->ServerMode = false;
}
// Communication throughput measurement tool dialog initialization
void CmTrafficDlgInit(HWND hWnd)
{
CM_TRAFFIC t;
LIST *c1, *c2;
UINT i;
// Validate arguments
if (hWnd == NULL)
{
return;
}
DlgFont(hWnd, S_8, 9, true);
DlgFont(hWnd, S_3, 9, true);
Zero(&t, sizeof(t));
if (CmTrafficLoadFromReg(&t) == false)
{
CmTrafficGetDefaultSetting(&t);
}
// Write the settings to the dialog
Check(hWnd, R_SERVER, t.ServerMode);
Check(hWnd, R_CLIENT, t.ServerMode == false);
c1 = ReadCandidateFromReg(REG_CURRENT_USER, CM_TRAFFIC_REG_KEY, "HostCandidate");
if (c1 != NULL)
{
UINT i;
CbReset(hWnd, C_HOST);
for (i = 0;i < LIST_NUM(c1);i++)
{
CANDIDATE *c = LIST_DATA(c1, i);
CbAddStr(hWnd, C_HOST, c->Str, 0);
}
FreeCandidateList(c1);
}
if (CbNum(hWnd, C_HOST) == 0)
{
CbAddStr(hWnd, C_HOST, L"speed.softether.com", 0);
}
if (IsEmptyStr(t.Host) == false)
{
SetTextA(hWnd, C_HOST, t.Host);
}
c2 = ReadCandidateFromReg(REG_CURRENT_USER, CM_TRAFFIC_REG_KEY, "PortCandidate");
if (c2 != NULL)
{
UINT i;
if (t.Port != 0)
{
wchar_t tmp[32];
UniToStru(tmp, t.Port);
AddCandidate(c2, tmp, 0);
}
CbReset(hWnd, C_PORT);
for (i = 0;i < LIST_NUM(c2);i++)
{
CANDIDATE *c = LIST_DATA(c2, i);
CbAddStr(hWnd, C_PORT, c->Str, 0);
}
FreeCandidateList(c2);
}
CbReset(hWnd, C_NUM);
for (i = 1;i <= TRAFFIC_NUMTCP_MAX;i++)
{
wchar_t tmp[32];
UniToStru(tmp, i);
CbAddStr(hWnd, C_NUM, tmp, i);
}
CbSelect(hWnd, C_NUM, t.NumTcp);
Check(hWnd, R_DOWNLOAD, t.Type == TRAFFIC_TYPE_DOWNLOAD);
Check(hWnd, R_UPLOAD, t.Type == TRAFFIC_TYPE_UPLOAD);
Check(hWnd, R_FULL, t.Type == TRAFFIC_TYPE_FULL);
Check(hWnd, R_ETHERNET, t.Raw ? false : true);
Check(hWnd, R_DOUBLE, t.Double);
SetIntEx(hWnd, E_SPAN, t.Span);
CmTrafficDlgUpdate(hWnd);
}
// Put the contents of the dialog to structure
void CmTrafficDlgToStruct(HWND hWnd, CM_TRAFFIC *t)
{
// Validate arguments
if (hWnd == NULL || t == NULL)
{
return;
}
Zero(t, sizeof(CM_TRAFFIC));
t->ServerMode = IsChecked(hWnd, R_SERVER);
GetTxtA(hWnd, C_HOST, t->Host, sizeof(t->Host));
Trim(t->Host);
t->Port = GetInt(hWnd, C_PORT);
t->NumTcp = CbGetSelect(hWnd, C_NUM);
t->Span = GetInt(hWnd, E_SPAN);
t->Raw = IsChecked(hWnd, R_ETHERNET) ? false : true;
t->Double = IsChecked(hWnd, R_DOUBLE);
if (IsChecked(hWnd, R_DOWNLOAD))
{
t->Type = TRAFFIC_TYPE_DOWNLOAD;
}
else if (IsChecked(hWnd, R_UPLOAD))
{
t->Type = TRAFFIC_TYPE_UPLOAD;
}
else
{
t->Type = TRAFFIC_TYPE_FULL;
}
}
// Communication throughput measurement tool dialog update
bool CmTrafficDlgUpdate(HWND hWnd)
{
CM_TRAFFIC t;
bool ok = true;
bool client_only;
// Validate arguments
if (hWnd == NULL)
{
return false;
}
CmTrafficDlgToStruct(hWnd, &t);
client_only = t.ServerMode ? false : true;
SetEnable(hWnd, C_HOST, client_only);
SetEnable(hWnd, S_5, client_only);
SetEnable(hWnd, S_8, client_only);
SetEnable(hWnd, S_9, client_only);
SetEnable(hWnd, R_DOWNLOAD, client_only);
SetEnable(hWnd, R_UPLOAD, client_only);
SetEnable(hWnd, R_FULL, client_only);
SetEnable(hWnd, S_10, client_only);
SetEnable(hWnd, S_11, client_only);
SetEnable(hWnd, C_NUM, client_only);
SetEnable(hWnd, S_14, client_only);
SetEnable(hWnd, S_12, client_only);
SetEnable(hWnd, E_SPAN, client_only);
SetEnable(hWnd, S_13, client_only);
SetEnable(hWnd, R_ETHERNET, client_only);
SetEnable(hWnd, R_DOUBLE, client_only);
if (t.Port == 0 || t.Port >= 65536)
{
ok = false;
}
if (t.ServerMode == false)
{
if (IsEmptyStr(t.Host))
{
ok = false;
}
if (t.NumTcp == 0 || t.NumTcp >= 33)
{
ok = false;
}
if (t.Span == 0)
{
ok = false;
}
if (t.Type == TRAFFIC_TYPE_FULL && ((t.NumTcp % 2) != 0))
{
ok = false;
}
}
SetEnable(hWnd, IDOK, ok);
return ok;
}
// Communication throughput measurement tool dialog OK button
void CmTrafficDlgOnOk(HWND hWnd)
{
CM_TRAFFIC t;
LIST *c;
// Validate arguments
if (hWnd == NULL)
{
return;
}
// Get the basic data
CmTrafficDlgToStruct(hWnd, &t);
// Save to registry
CmTrafficSaveToReg(&t);
// Retrieve and save the server name candidate
if (IsEmptyStr(t.Host) == false)
{
c = ReadCandidateFromReg(REG_CURRENT_USER, CM_TRAFFIC_REG_KEY, "HostCandidate");
if (c != NULL)
{
wchar_t tmp[MAX_SIZE];
StrToUni(tmp, sizeof(tmp), t.Host);
AddCandidate(c, tmp, 0);
WriteCandidateToReg(REG_CURRENT_USER, CM_TRAFFIC_REG_KEY, c, "HostCandidate");
FreeCandidateList(c);
}
}
if (t.Port != 0 && t.Port <= 65536)
{
// Retrieve and store the port number candidate
c = ReadCandidateFromReg(REG_CURRENT_USER, CM_TRAFFIC_REG_KEY, "PortCandidate");
if (c != NULL)
{
wchar_t tmp[MAX_SIZE];
UniToStru(tmp, t.Port);
AddCandidate(c, tmp, 0);
WriteCandidateToReg(REG_CURRENT_USER, CM_TRAFFIC_REG_KEY, c, "PortCandidate");
FreeCandidateList(c);
}
}
// Execute
CmExecTraffic(hWnd, &t);
// Update the dialog
CmTrafficDlgInit(hWnd);
}
// Communication throughput measurement tool dialog procedure
UINT CmTrafficDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
{
// Validate arguments
if (hWnd == NULL)
{
return 0;
}
switch (msg)
{
case WM_INITDIALOG:
SetIcon(hWnd, 0, ICO_SWITCH);
CmTrafficDlgInit(hWnd);
break;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case R_SERVER:
case R_CLIENT:
case C_HOST:
case C_PORT:
case R_DOWNLOAD:
case R_UPLOAD:
case R_FULL:
case C_NUM:
case E_SPAN:
case R_ETHERNET:
case R_DOUBLE:
CmTrafficDlgUpdate(hWnd);
break;
}
switch (wParam)
{
case IDOK:
CmTrafficDlgOnOk(hWnd);
break;
case IDCANCEL:
Close(hWnd);
break;
}
break;
case WM_CLOSE:
EndDialog(hWnd, 0);
break;
}
return 0;
}
// Communication throughput measurement tool
void CmTraffic(HWND hWnd)
{
Dialog(hWnd, D_CM_TRAFFIC, CmTrafficDlgProc, NULL);
}
// Delete old startup file
void CmDeleteOldStartupTrayFile()
{
char tmp[MAX_SIZE];
char *tag = _SS("CM_JAPANESE_ONLY_OLD_STARTUP");
if (IsEmptyStr(tag))
{
return;
}
Format(tmp, sizeof(tmp), tag, MsGetCommonStartupDir());
FileDelete(tmp);
}
// PKCS license confirmation dialog
UINT CmPkcsEulaDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
{
UINT id;
SECURE_DEVICE *dev;
char *name;
// Validate arguments
if (hWnd == NULL)
{
return 0;
}
switch (msg)
{
case WM_INITDIALOG:
id = (UINT)param;
dev = GetSecureDevice(id);
if (dev == NULL)
{
EndDialog(hWnd, 0);
return 0;
}
name = dev->ModuleName;
FormatText(hWnd, S_INFO_1, name);
FormatText(hWnd, S_INFO_2, name, name);
FormatText(hWnd, S_INFO_3, name);
break;
case WM_COMMAND:
switch (wParam)
{
case IDOK:
EndDialog(hWnd, 1);
break;
case IDCANCEL:
Close(hWnd);
break;
}
break;
case WM_CLOSE:
EndDialog(hWnd, 0);
break;
}
return 0;
}
// Confirmation screen of whether the user accepts the EULA of the PKCS DLL
bool CmCheckPkcsEula(HWND hWnd, UINT id)
{
return (Dialog(hWnd, D_CM_PKCSEULA, CmPkcsEulaDlg, (void *)id) == 0) ? false : true;
}
// Update controls
void CmSecurePinDlgUpdate(HWND hWnd)
{
char *tmp1, *tmp2, *tmp3;
bool ok = true;
// Validate arguments
if (hWnd == NULL)
{
return;
}
tmp1 = GetTextA(hWnd, E_PIN1);
tmp2 = GetTextA(hWnd, E_PIN2);
tmp3 = GetTextA(hWnd, E_PIN3);
if (IsEmptyStr(tmp1))
{
ok = false;
}
if (IsEmptyStr(tmp2))
{
ok = false;
}
if (IsEmptyStr(tmp3))
{
ok = false;
}
if (StrCmp(tmp2, tmp3) != 0)
{
ok = false;
}
Free(tmp1);
Free(tmp2);
Free(tmp3);
SetEnable(hWnd, IDOK, ok);
}
// PIN code changing dialog
UINT CmSecurePinDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
{
UINT id = (UINT)param;
char *src, *dst;
SECURE *s;
// Validate arguments
if (hWnd == NULL)
{
return 0;
}
switch (msg)
{
case WM_INITDIALOG:
CmSecurePinDlgUpdate(hWnd);
break;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case E_PIN1:
case E_PIN2:
case E_PIN3:
CmSecurePinDlgUpdate(hWnd);
break;
}
switch (wParam)
{
case IDOK:
src = GetTextA(hWnd, E_PIN1);
dst = GetTextA(hWnd, E_PIN3);
Disable(hWnd, IDOK);
Disable(hWnd, IDCANCEL);
s = OpenSec(id);
if (s == NULL)
{
if (GetSecureDevice(id) != NULL)
{
MsgBoxEx(hWnd, MB_ICONEXCLAMATION, _UU("SEC_PIN_DEVICE_OPEN_ERR"),
GetSecureDevice(id)->DeviceName);
}
else
{
MsgBoxEx(hWnd, MB_ICONEXCLAMATION, _UU("SEC_PIN_DEVICE_OPEN_ERR"),
"Unknown");
}
}
else
{
if (OpenSecSession(s, 0) == false)
{
if (GetSecureDevice(id) != NULL)
{
MsgBoxEx(hWnd, MB_ICONEXCLAMATION, _UU("SEC_PIN_DEVICE_OPEN_ERR"),
GetSecureDevice(id)->DeviceName);
}
else
{
MsgBoxEx(hWnd, MB_ICONEXCLAMATION, _UU("SEC_PIN_DEVICE_OPEN_ERR"),
"Unknown");
}
}
else
{
if (LoginSec(s, src) == false)
{
MsgBox(hWnd, MB_ICONEXCLAMATION, _UU("SEC_PIN_CURRENT_BAD"));
FocusEx(hWnd, E_PIN1);
}
else
{
if (ChangePin(s, src, dst) == false)
{
MsgBox(hWnd, MB_ICONEXCLAMATION, _UU("SEC_PIN_CHANGE_FAILED"));
FocusEx(hWnd, E_PIN1);
}
else
{
// Clear the cache for PIN code
cached_pin_code_expires = 0;
cached_pin_code[0] = 0;
MsgBox(hWnd, MB_ICONINFORMATION, _UU("SEC_PIN_OK"));
EndDialog(hWnd, true);
}
LogoutSec(s);
}
CloseSecSession(s);
}
CloseSec(s);
}
Enable(hWnd, IDOK);
Enable(hWnd, IDCANCEL);
Free(src);
Free(dst);
break;
case IDCANCEL:
Close(hWnd);
break;
}
break;
case WM_CLOSE:
EndDialog(hWnd, false);
break;
}
return 0;
}
// Change the PIN code
void CmSecurePin(HWND hWnd, UINT id)
{
// Validate arguments
if (hWnd == NULL || id == 0 || CheckSecureDeviceId(id) == false)
{
return;
}
Dialog(hWnd, D_CM_SECURE_PIN, CmSecurePinDlg, (void *)id);
}
// Object type selection dialog
UINT CmSecureTypeDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
{
UINT type;
// Validate arguments
if (hWnd == NULL)
{
return 0;
}
switch (msg)
{
case WM_INITDIALOG:
type = MsRegReadInt(REG_CURRENT_USER, SECURE_MANAGER_KEY, "DefaultImportType");
Check(hWnd, R_DATA, type == SEC_DATA);
Check(hWnd, R_CERT, type == SEC_X);
Check(hWnd, R_KEY, type == SEC_K);
goto UPDATE_CONTROL;
case WM_COMMAND:
switch (wParam)
{
case IDOK:
type = SEC_DATA;
if (IsChecked(hWnd, R_CERT))
{
type = SEC_X;
}
else if (IsChecked(hWnd, R_KEY))
{
type = SEC_K;
}
MsRegWriteInt(REG_CURRENT_USER, SECURE_MANAGER_KEY, "DefaultImportType", type);
EndDialog(hWnd, type);
break;
case IDCANCEL:
Close(hWnd);
break;
case R_CERT:
case R_KEY:
case R_DATA:
UPDATE_CONTROL:
SetEnable(hWnd, IDOK, IsChecked(hWnd, R_CERT) ||
IsChecked(hWnd, R_KEY) ||
IsChecked(hWnd, R_DATA));
break;
}
break;
case WM_CLOSE:
EndDialog(hWnd, INFINITE);
break;
}
return 0;
}
// Object type selection
UINT CmSecureType(HWND hWnd)
{
return Dialog(hWnd, D_CM_SECURE_TYPE, CmSecureTypeDlg, NULL);
}
// Initialize the dialog
void CmSecureManagerDlgInit(HWND hWnd, UINT id)
{
SECURE_DEVICE *dev;
// Validate arguments
if (hWnd == NULL || id == 0)
{
return;
}
SetIcon(hWnd, 0, ICO_SECURE);
dev = GetSecureDevice(id);
if (dev != NULL)
{
FormatText(hWnd, S_INFO, dev->DeviceName);
}
SetFont(hWnd, B_BOLD, Font(0, true));
LvInit(hWnd, L_LIST);
LvInsertColumn(hWnd, L_LIST, 0, _UU("SEC_MGR_COLUMN1"), 200);
LvInsertColumn(hWnd, L_LIST, 1, _UU("SEC_MGR_COLUMN2"), 110);
CmSecureManagerDlgUpdate(hWnd, id);
}
// Update controls
void CmSecureManagerDlgUpdate(HWND hWnd, UINT id)
{
bool b = true;
bool read_only = IsJPKI(id);
// Validate arguments
if (hWnd == NULL)
{
return;
}
if (LvIsSingleSelected(hWnd, L_LIST) == false)
{
b = false;
}
SetEnable(hWnd, B_EXPORT, b && ((UINT)LvGetParam(hWnd, L_LIST, LvGetSelected(hWnd, L_LIST)) != SEC_K));
SetEnable(hWnd, B_DELETE, b && (read_only == false));
SetEnable(hWnd, B_PIN, (read_only == false));
SetEnable(hWnd, B_IMPORT, (read_only == false));
SetEnable(hWnd, B_NEW_CERT, (read_only == false));
}
// Content update
void CmSecureManagerDlgRefresh(HWND hWnd, UINT id)
{
bool ret;
LIST *o;
WINUI_SECURE_BATCH batch[] =
{
{WINUI_SECURE_ENUM_OBJECTS, NULL, false, NULL, NULL, NULL, NULL, NULL, NULL},
};
// Validate arguments
if (hWnd == NULL || id == 0)
{
return;
}
ret = SecureDeviceWindow(hWnd, batch, sizeof(batch) / sizeof(batch[0]), id, 0);
if (ret == false)
{
return;
}
o = batch[0].EnumList;
if (o != NULL)
{
CmSecureManagerDlgPrintList(hWnd, o);
FreeEnumSecObject(o);
}
// update controls
CmSecureManagerDlgUpdate(hWnd, id);
}
// Show the list of secure objects
void CmSecureManagerDlgPrintList(HWND hWnd, LIST *o)
{
CmSecureManagerDlgPrintListEx(hWnd, L_LIST, o, INFINITE);
}
void CmSecureManagerDlgPrintListEx(HWND hWnd, UINT id, LIST *o, UINT type)
{
UINT i;
LVB *v;
// Validate arguments
if (hWnd == NULL || o == NULL)
{
return;
}
LvReset(hWnd, id);
v = LvInsertStart();
for (i = 0;i < LIST_NUM(o);i++)
{
UINT icon = ICO_LOG2;
wchar_t tmp1[MAX_SIZE], *tmp2, *tmp3;
SEC_OBJ *obj = LIST_DATA(o, i);
if (type == INFINITE || obj->Type == type)
{
StrToUni(tmp1, sizeof(tmp1), obj->Name);
tmp2 = CmSecureObjTypeToStr(obj->Type);
tmp3 = obj->Private ? _UU("SEC_YES") : _UU("SEC_NO");
if (obj->Type == SEC_X)
{
icon = ICO_CERT;
}
else if (obj->Type == SEC_K || obj->Type == SEC_P)
{
icon = ICO_KEY;
}
LvInsertAdd(v, icon, (void *)obj->Type, 2, tmp1, tmp2);
}
}
LvInsertEnd(v, hWnd, id);
}
// Convert the type of secure object to a string
wchar_t *CmSecureObjTypeToStr(UINT type)
{
wchar_t *ret = _UU("SEC_TYPE_DATA");
if (type == SEC_X)
{
ret = _UU("SEC_TYPE_CERT");
}
else if (type == SEC_K)
{
ret = _UU("SEC_TYPE_KEY");
}
else if (type == SEC_P)
{
ret = _UU("SEC_TYPE_PUB");
}
return ret;
}
// Write by creating a new certificate
void CmSecureManagerDlgNewCert(HWND hWnd, UINT id)
{
X *x;
K *k;
char default_name[MAX_SIZE];
char *object_name;
bool ok = false;
WINUI_SECURE_BATCH batch[] =
{
{WINUI_SECURE_WRITE_CERT, NULL, true, NULL, NULL, NULL, NULL, NULL, NULL},
{WINUI_SECURE_WRITE_KEY, NULL, true, NULL, NULL, NULL, NULL, NULL, NULL},
{WINUI_SECURE_ENUM_OBJECTS, NULL, false, NULL, NULL, NULL, NULL, NULL, NULL},
};
// Validate arguments
if (hWnd == NULL || id == 0)
{
return;
}
// Dialog for creating certificate
if (SmCreateCert(hWnd, &x, &k, true, NULL, false) == false)
{
return;
}
// Generate the default name
GetPrintNameFromXA(default_name, sizeof(default_name), x);
ConvertSafeFileName(default_name, sizeof(default_name), default_name);
object_name = StringDlgA(hWnd, _UU("SEC_OBJECT_NAME_TITLE"),
_UU("SEC_OBJECT_NAME_INFO"), default_name, ICO_CERT, false, false);
if (object_name != NULL)
{
// Enumerate and write
batch[0].InputX = x;
batch[0].Name = object_name;
batch[1].InputK = k;
batch[1].Name = object_name;
if (SecureDeviceWindow(hWnd, batch, sizeof(batch) / sizeof(batch[0]), id, 0) == false)
{
// Failure
}
else
{
ok = true;
}
Free(object_name);
}
if (ok)
{
LIST *o = batch[2].EnumList;
CmSecureManagerDlgPrintList(hWnd, o);
FreeEnumSecObject(o);
MsgBox(hWnd, MB_ICONINFORMATION, _UU("SEC_NEW_CERT_IMPORT_OK"));
}
FreeX(x);
FreeK(k);
}
// Import
void CmSecureManagerDlgImport(HWND hWnd, UINT id)
{
UINT type;
char name[MAX_SIZE];
wchar_t tmp2[MAX_SIZE];
wchar_t *tmp;
wchar_t *filename;
BUF *b;
K *k;
bool ok = false;
X *x;
WINUI_SECURE_BATCH batch[] =
{
{WINUI_SECURE_WRITE_DATA, name, true, NULL, NULL, NULL, NULL, NULL, NULL},
{WINUI_SECURE_ENUM_OBJECTS, NULL, false, NULL, NULL, NULL, NULL, NULL, NULL},
};
// Validate arguments
if (hWnd == NULL || id == 0)
{
return;
}
// Select the type of secure object
type = CmSecureType(hWnd);
switch (type)
{
case SEC_DATA:
// Data
tmp = OpenDlg(hWnd, _UU("DLG_ALL_FILES"), _UU("SEC_IMPORT_DATA"));
if (tmp == NULL)
{
return;
}
filename = CopyUniStr(tmp);
Free(tmp);
// Read the file
b = ReadDumpW(filename);
if (b == NULL)
{
// Read failure
MsgBox(hWnd, MB_ICONSTOP, _UU("SEC_READ_FAILED"));
}
else
{
if (b->Size > MAX_SEC_DATA_SIZE)
{
// File size is too large
MsgBoxEx(hWnd, MB_ICONEXCLAMATION, _UU("SEC_DATA_TOO_BIG"), MAX_SEC_DATA_SIZE);
}
else
{
// Generate the default name
char default_name[MAX_SIZE];
wchar_t default_name_w[MAX_SIZE];
char *object_name;
GetFileNameFromFilePathW(default_name_w, sizeof(default_name_w), filename);
UniToStr(default_name, sizeof(default_name), default_name_w);
ConvertSafeFileName(default_name, sizeof(default_name), default_name);
object_name = StringDlgA(hWnd, _UU("SEC_OBJECT_NAME_TITLE"),
_UU("SEC_OBJECT_NAME_INFO"), default_name, ICO_LOG2, false, false);
if (object_name != NULL)
{
// Enumerate and write
batch[0].InputData = b;
batch[0].Name = object_name;
if (SecureDeviceWindow(hWnd, batch, sizeof(batch) / sizeof(batch[0]), id, 0) == false)
{
// Failure
}
else
{
ok = true;
}
Free(object_name);
}
}
FreeBuf(b);
}
Free(filename);
break;
case SEC_X:
// Read a certificate
if (CmLoadXExW(hWnd, &x, tmp2, sizeof(tmp2)))
{
// Generate the default name
char default_name[MAX_SIZE];
wchar_t default_name_w[MAX_PATH];
char *object_name;
GetFileNameFromFilePathW(default_name_w, sizeof(default_name_w), tmp2);
UniToStr(default_name, sizeof(default_name), default_name_w);
ConvertSafeFileName(default_name, sizeof(default_name), default_name);
object_name = StringDlgA(hWnd, _UU("SEC_OBJECT_NAME_TITLE"),
_UU("SEC_OBJECT_NAME_INFO"), default_name, ICO_CERT, false, false);
if (object_name != NULL)
{
// Enumerate and write
batch[0].Type = WINUI_SECURE_WRITE_CERT;
batch[0].InputX = x;
batch[0].Name = object_name;
if (SecureDeviceWindow(hWnd, batch, sizeof(batch) / sizeof(batch[0]), id, 0) == false)
{
// Failure
}
else
{
ok = true;
}
Free(object_name);
}
FreeX(x);
}
break;
case SEC_K:
// Secret key
if (CmLoadKExW(hWnd, &k, tmp2, sizeof(tmp2)))
{
// Generate the default name
char default_name[MAX_SIZE];
wchar_t default_name_w[MAX_PATH];
char *object_name;
GetFileNameFromFilePathW(default_name_w, sizeof(default_name_w), tmp2);
UniToStr(default_name, sizeof(default_name), default_name_w);
ConvertSafeFileName(default_name, sizeof(default_name), default_name);
object_name = StringDlgA(hWnd, _UU("SEC_OBJECT_NAME_TITLE"),
_UU("SEC_OBJECT_NAME_INFO"), default_name, ICO_KEY, false, false);
if (object_name != NULL)
{
// Enumerate and write
batch[0].Type = WINUI_SECURE_WRITE_KEY;
batch[0].InputK = k;
batch[0].Name = object_name;
if (SecureDeviceWindow(hWnd, batch, sizeof(batch) / sizeof(batch[0]), id, 0) == false)
{
// Failure
}
else
{
ok = true;
}
Free(object_name);
}
FreeK(k);
}
break;
default:
// Invalid
return;
}
if (ok)
{
LIST *o = batch[1].EnumList;
CmSecureManagerDlgPrintList(hWnd, o);
FreeEnumSecObject(o);
MsgBox(hWnd, MB_ICONINFORMATION, _UU("SEC_OBJECT_IMPORT_OK"));
}
}
// Export the object
void CmSecureManagerDlgExport(HWND hWnd, UINT id)
{
char name[MAX_SIZE];
UINT method = WINUI_SECURE_READ_DATA;
char *tmp;
UINT type;
wchar_t filename[MAX_PATH];
wchar_t *uni_tmp;
X *x;
BUF *b;
wchar_t default_name[128];
WINUI_SECURE_BATCH batch[] =
{
{WINUI_SECURE_READ_DATA, name, true, NULL, NULL, NULL, NULL, NULL, NULL},
};
UINT i;
// Validate arguments
if (hWnd == NULL || id == 0)
{
return;
}
i = LvGetSelected(hWnd, L_LIST);
if (i == INFINITE)
{
return;
}
tmp = LvGetStrA(hWnd, L_LIST, i, 0);
StrCpy(name, sizeof(name), tmp);
Free(tmp);
type = (UINT)LvGetParam(hWnd, L_LIST, i);
switch (type)
{
case SEC_X:
method = WINUI_SECURE_READ_CERT;
break;
default:
method = WINUI_SECURE_READ_DATA;
break;
}
batch[0].Type = method;
// Operate the smart card
if (SecureDeviceWindow(hWnd, batch, sizeof(batch) / sizeof(batch[0]), id, 0) == false)
{
return;
}
switch (type)
{
case SEC_X:
// Certificate
x = batch[0].OutputX;
CertDlg(hWnd, x, NULL, true);
FreeX(x);
break;
default:
// File
b = batch[0].OutputData;
StrToUni(default_name, sizeof(default_name), name);
uni_tmp = SaveDlg(hWnd, _UU("DLG_ALL_FILES"), _UU("DLG_SAVE_FILE"), default_name, NULL);
if (uni_tmp != NULL)
{
UniStrCpy(filename, sizeof(filename), uni_tmp);
DumpBufW(b, filename);
Free(uni_tmp);
MsgBox(hWnd, MB_ICONINFORMATION, _UU("SEC_OBJECT_EXPORT_OK"));
}
FreeBuf(b);
break;
}
}
// Delete the object
void CmSecureManagerDlgDelete(HWND hWnd, UINT id)
{
char name[MAX_SIZE];
UINT method = WINUI_SECURE_DELETE_DATA;
char *tmp;
UINT type;
LIST *o;
WINUI_SECURE_BATCH batch[] =
{
{WINUI_SECURE_DELETE_OBJECT, name, false, NULL, NULL, NULL, NULL, NULL, NULL},
{WINUI_SECURE_ENUM_OBJECTS, NULL, false, NULL, NULL, NULL, NULL, NULL, NULL},
};
UINT i;
// Validate arguments
if (hWnd == NULL || id == 0)
{
return;
}
i = LvGetSelected(hWnd, L_LIST);
if (i == INFINITE)
{
return;
}
tmp = LvGetStrA(hWnd, L_LIST, i, 0);
StrCpy(name, sizeof(name), tmp);
Free(tmp);
type = (UINT)LvGetParam(hWnd, L_LIST, i);
switch (type)
{
case SEC_X:
method = WINUI_SECURE_DELETE_CERT;
break;
case SEC_K:
method = WINUI_SECURE_DELETE_KEY;
break;
default:
method = WINUI_SECURE_DELETE_DATA;
break;
}
batch[0].Type = method;
if (SecureDeviceWindow(hWnd, batch, sizeof(batch) / sizeof(batch[0]), id, 0) == false)
{
return;
}
o = batch[1].EnumList;
CmSecureManagerDlgPrintList(hWnd, o);
FreeEnumSecObject(o);
}
static bool cm_secure_manager_no_new_cert = false;
// Smart Card Manager dialog
UINT CmSecureManagerDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
{
NMHDR *n;
UINT id = (UINT)param;
// Validate arguments
if (hWnd == NULL)
{
return 0;
}
switch (msg)
{
case WM_INITDIALOG:
CmSecureManagerDlgInit(hWnd, id);
if (cm_secure_manager_no_new_cert)
{
Hide(hWnd, B_NEW_CERT);
}
SetTimer(hWnd, 1, 1, NULL);
break;
case WM_COMMAND:
switch (wParam)
{
case B_REFRESH:
CmSecureManagerDlgRefresh(hWnd, id);
break;
case B_IMPORT:
CmSecureManagerDlgImport(hWnd, id);
break;
case B_EXPORT:
CmSecureManagerDlgExport(hWnd, id);
break;
case B_DELETE:
if (MsgBox(hWnd, MB_YESNO | MB_ICONEXCLAMATION | MB_DEFBUTTON2,
_UU("SEC_DELETE_MSG")) == IDYES)
{
CmSecureManagerDlgDelete(hWnd, id);
}
break;
case B_NEW_CERT:
CmSecureManagerDlgNewCert(hWnd, id);
break;
case B_PIN:
CmSecurePin(hWnd, id);
break;
case IDCANCEL:
Close(hWnd);
break;
}
break;
case WM_TIMER:
switch (wParam)
{
case 1:
KillTimer(hWnd, 1);
CmSecureManagerDlgRefresh(hWnd, id);
break;
}
break;
case WM_CLOSE:
EndDialog(hWnd, 0);
break;
case WM_NOTIFY:
n = (NMHDR *)lParam;
switch (n->idFrom)
{
case L_LIST:
switch (n->code)
{
case LVN_ITEMCHANGED:
CmSecureManagerDlgUpdate(hWnd, id);
break;
}
break;
}
break;
}
return 0;
}
// Smart Card Manager
void CmSecureManager(HWND hWnd, UINT id)
{
CmSecureManagerEx(hWnd, id, false);
}
void CmSecureManagerEx(HWND hWnd, UINT id, bool no_new_cert)
{
// Validate arguments
if (hWnd == NULL || id == 0)
{
return;
}
// ID check
if (CheckSecureDeviceId(id) == false)
{
MsgBox(hWnd, MB_ICONEXCLAMATION, _UU("SEC_INVALID_ID"));
return;
}
if (no_new_cert)
{
cm_secure_manager_no_new_cert = true;
}
else
{
cm_secure_manager_no_new_cert = false;
}
Dialog(hWnd, D_CM_SECURE_MANAGER, CmSecureManagerDlg, (void *)id);
}
// Smart Card Manager for Client
void CmClientSecureManager(HWND hWnd)
{
RPC_USE_SECURE t;
UINT id;
Zero(&t, sizeof(t));
CcGetUseSecure(cm->Client, &t);
id = t.DeviceId;
if (id == 0 || CheckSecureDeviceId(id) == false)
{
id = CmClientSelectSecure(hWnd);
}
if (id == 0)
{
return;
}
CmSecureManager(hWnd, id);
}
// Initialize the dialog
void CmSelectSecureDlgInit(HWND hWnd, UINT default_id)
{
UINT i;
LIST *o;
LVB *v;
SetIcon(hWnd, 0, ICO_SECURE);
o = GetSecureDeviceList();
LvInit(hWnd, L_LIST);
LvInsertColumn(hWnd, L_LIST, 0, _UU("SEC_COLUMN1"), 150);
LvInsertColumn(hWnd, L_LIST, 1, _UU("SEC_COLUMN2"), 100);
LvInsertColumn(hWnd, L_LIST, 2, _UU("SEC_COLUMN3"), 130);
LvInsertColumn(hWnd, L_LIST, 3, _UU("SEC_COLUMN4"), 100);
v = LvInsertStart();
for (i = 0;i < LIST_NUM(o);i++)
{
wchar_t tmp1[MAX_SIZE];
wchar_t *tmp2;
wchar_t tmp3[MAX_SIZE];
wchar_t tmp4[MAX_SIZE];
SECURE_DEVICE *dev = LIST_DATA(o, i);
StrToUni(tmp1, sizeof(tmp1), dev->DeviceName);
tmp2 = (dev->Type == SECURE_IC_CARD) ? _UU("SEC_SMART_CARD") : _UU("SEC_USB_TOKEN");
StrToUni(tmp3, sizeof(tmp3), dev->Manufacturer);
StrToUni(tmp4, sizeof(tmp4), dev->ModuleName);
LvInsertAdd(v, ICO_SECURE, (void *)dev->Id, 4, tmp1, tmp2, tmp3, tmp4);
}
LvInsertEnd(v, hWnd, L_LIST);
if (default_id != 0)
{
LvSelect(hWnd, L_LIST, LvSearchParam(hWnd, L_LIST, (void *)default_id));
}
ReleaseList(o);
// Control update
CmSelectSecureDlgUpdate(hWnd);
}
// Update controls of the dialog
void CmSelectSecureDlgUpdate(HWND hWnd)
{
SetEnable(hWnd, IDOK, LvIsSingleSelected(hWnd, L_LIST));
}
// Smart card selection dialog
UINT CmSelectSecureDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
{
UINT default_id = (UINT)param;
NMHDR *n = NULL;
static UINT old_id;
// Validate arguments
if (hWnd == NULL)
{
return 0;
}
switch (msg)
{
case WM_INITDIALOG:
old_id = default_id;
CmSelectSecureDlgInit(hWnd, default_id);
if (LvNum(hWnd, L_LIST) == 0)
{
// There is no smart card
SetTimer(hWnd, 1, 100, NULL);
}
break;
case WM_TIMER:
switch (wParam)
{
case 1:
KillTimer(hWnd, 1);
Disable(hWnd, L_LIST);
MsgBox(hWnd, MB_ICONINFORMATION, _UU("SEC_NO_SECURE_DEVICE"));
break;
}
break;
case WM_COMMAND:
switch (wParam)
{
case IDOK:
if (IsEnable(hWnd, IDOK))
{
UINT i = LvGetSelected(hWnd, L_LIST);
if (i != INFINITE)
{
UINT id = (UINT)LvGetParam(hWnd, L_LIST, i);
if (old_id != id)
{
if (CmCheckPkcsEula(hWnd, id) == false)
{
break;
}
}
EndDialog(hWnd, id);
}
}
break;
case IDCANCEL:
Close(hWnd);
break;
}
break;
case WM_CLOSE:
EndDialog(hWnd, 0);
break;
case WM_NOTIFY:
n = (NMHDR *)lParam;
switch (n->idFrom)
{
case L_LIST:
switch (n->code)
{
case LVN_ITEMCHANGED:
CmSelectSecureDlgUpdate(hWnd);
break;
case NM_DBLCLK:
Command(hWnd, IDOK);
break;
}
break;
}
break;
}
return 0;
}
// Select the smart card device to be used
UINT CmSelectSecure(HWND hWnd, UINT current_id)
{
return Dialog(hWnd, D_CM_SELECT_SECURE, CmSelectSecureDlg, (void *)current_id);
}
// Select the smart card device to be used (client)
UINT CmClientSelectSecure(HWND hWnd)
{
UINT id;
RPC_USE_SECURE t;
if (cm->server_name != NULL)
{
MsgBox(hWnd, MB_ICONEXCLAMATION, _UU("CM_SECURE_MUST_LOCAL"));
return 0;
}
Zero(&t, sizeof(t));
CcGetUseSecure(cm->Client, &t);
id = t.DeviceId;
id = CmSelectSecure(hWnd, id);
if (id != 0)
{
Zero(&t, sizeof(t));
t.DeviceId = id;
CALL(hWnd, CcUseSecure(cm->Client, &t));
SmWriteSelectSecureIdReg(id);
}
return id;
}
// Shortcut connection
void CmConnectShortcut(UCHAR *key)
{
UINT ret;
// Validate arguments
if (key == NULL)
{
return;
}
// Attempt to connect
ret = CcShortcut(key);
if (ret != ERR_NO_ERROR)
{
if (ret == ERR_ACCOUNT_ACTIVE)
{
// Because it is currently connected, to query whether or not to disconnect
if (MsgBox(NULL, MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2, _UU("CM_SHORTCUT_DISCONNECT")) == IDYES)
{
// Try to disconnect
ret = CcShortcutDisconnect(key);
if (ret != ERR_NO_ERROR)
{
// Error
MsgBox(NULL, MB_ICONEXCLAMATION, GetUniErrorStr(ret));
}
}
}
else
{
// Other errors
MsgBox(NULL, MB_ICONEXCLAMATION, GetUniErrorStr(ret));
}
}
}
// Play the audio guide
void CmVoice(char *name)
{
UINT i;
// Validate arguments
if (name == NULL)
{
return;
}
// Voice guidance features disappeared!!
return;
if (cm->DisableVoice)
{
return;
}
for (i = 0;i < sizeof(cm_voice) / sizeof(CM_VOICE);i++)
{
if (cm_voice[i].voice_id == cm->VoiceId)
{
char tmp[MAX_SIZE];
Format(tmp, sizeof(tmp), "%s_%s.wav", cm_voice[i].perfix, name);
MsPlaySound(tmp);
return;
}
}
}
// Update the password changing dialog
void CmChangePasswordUpdate(HWND hWnd, CM_CHANGE_PASSWORD *p)
{
bool ok = true;
char *s1, *s2;
// Validate arguments
if (hWnd == NULL || p == NULL)
{
return;
}
if (IsEmpty(hWnd, E_USERNAME))
{
ok = false;
}
s1 = GetTextA(hWnd, E_NEW_PASSWORD1);
s2 = GetTextA(hWnd, E_NEW_PASSWORD2);
if (StrCmp(s1, s2) != 0)
{
ok = false;
}
Free(s1);
Free(s2);
SetEnable(hWnd, IDOK, ok);
}
// Password changing dialog procedure
UINT CmChangePasswordProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
{
CM_CHANGE_PASSWORD *p = (CM_CHANGE_PASSWORD *)param;
char username[MAX_USERNAME_LEN + 1];
char old_pass[MAX_PASSWORD_LEN + 1];
char new_pass[MAX_PASSWORD_LEN + 1];
UINT ret;
// Validate arguments
if (hWnd == NULL)
{
return 0;
}
switch (msg)
{
case WM_INITDIALOG:
SetTextA(hWnd, E_HUBNAME, p->HubName);
SetTextA(hWnd, E_USERNAME, p->Username);
FormatText(hWnd, S_TITLE, p->ClientOption->Hostname);
if (IsEmpty(hWnd, E_USERNAME))
{
FocusEx(hWnd, E_USERNAME);
}
else
{
FocusEx(hWnd, E_OLD_PASSWORD);
}
CmChangePasswordUpdate(hWnd, p);
break;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case E_USERNAME:
case E_OLD_PASSWORD:
case E_NEW_PASSWORD1:
case E_NEW_PASSWORD2:
CmChangePasswordUpdate(hWnd, p);
break;
}
switch (wParam)
{
case IDOK:
GetTxtA(hWnd, E_USERNAME, username, sizeof(username));
GetTxtA(hWnd, E_OLD_PASSWORD, old_pass, sizeof(old_pass));
GetTxtA(hWnd, E_NEW_PASSWORD1, new_pass, sizeof(new_pass));
Disable(hWnd, E_USERNAME);
Disable(hWnd, E_OLD_PASSWORD);
Disable(hWnd, E_NEW_PASSWORD1);
Disable(hWnd, E_NEW_PASSWORD2);
Disable(hWnd, IDOK);
Disable(hWnd, IDCANCEL);
ret = ChangePassword(cm->Cedar, p->ClientOption, p->HubName, username, old_pass, new_pass);
if (ret == ERR_NO_ERROR)
{
MsgBox(hWnd, MB_ICONINFORMATION, _UU("CM_PASSWORD_CHANGED"));
EndDialog(hWnd, true);
}
else
{
MsgBox(hWnd, MB_ICONSTOP, _E(ret));
Enable(hWnd, E_USERNAME);
Enable(hWnd, E_OLD_PASSWORD);
Enable(hWnd, E_NEW_PASSWORD1);
Enable(hWnd, E_NEW_PASSWORD2);
Enable(hWnd, IDOK);
Enable(hWnd, IDCANCEL);
SetTextA(hWnd, E_OLD_PASSWORD, "");
SetTextA(hWnd, E_NEW_PASSWORD1, "");
SetTextA(hWnd, E_NEW_PASSWORD2, "");
Focus(hWnd, E_OLD_PASSWORD);
}
break;
case IDCANCEL:
Close(hWnd);
break;
}
break;
case WM_CLOSE:
EndDialog(hWnd, false);
break;
}
return 0;
}
// Show the password changing dialog
void CmChangePassword(HWND hWnd, CLIENT_OPTION *o, char *hubname, char *username)
{
CM_CHANGE_PASSWORD p;
// Validate arguments
if (hWnd == NULL || o == NULL || hubname == NULL || username == NULL)
{
return;
}
Zero(&p, sizeof(p));
StrCpy(p.Username, sizeof(p.Username), username);
StrCpy(p.HubName, sizeof(p.HubName), hubname);
p.ClientOption = o;
CmVoice("password");
Dialog(hWnd, D_CM_CHANGE_PASSWORD, CmChangePasswordProc, &p);
}
// Prohibit the installation of the virtual LAN card
bool CmStopInstallVLan(HWND hWnd)
{
if (cm->Client->Unix)
{
// There is no need to be prohibited if the client is an UNIX
return true;
}
if (cm->Client->Win9x)
{
// There is no need to prohibit if the client is a Win9x
return true;
}
return true;
if (MsIsTerminalServiceInstalled() || MsIsUserSwitchingInstalled())
{
if (MsGetCurrentTerminalSessionId() == 0)
{
// There is no need to prohibit
return true;
}
else
{
// Prohibit to install the device drivers since
// the user logged in other than the console session
wchar_t *user = MsGetSessionUserName(0);
if (user == NULL)
{
MsgBoxEx(hWnd, MB_ICONEXCLAMATION, _UU("CM_STOP_INST_VLAN_2"),
MsIsTerminalServiceInstalled() ? _UU("CM_DESKTOP_MSG_LOCAL_TS") : _UU("CM_DESKTOP_MSG_LOCAL_SW"),
MsGetCurrentTerminalSessionId());
}
else
{
MsgBoxEx(hWnd, MB_ICONEXCLAMATION, _UU("CM_STOP_INST_VLAN_1"),
MsIsTerminalServiceInstalled() ? _UU("CM_DESKTOP_MSG_LOCAL_TS") : _UU("CM_DESKTOP_MSG_LOCAL_SW"),
MsGetCurrentTerminalSessionId(), 0, user);
}
if (user != NULL)
{
Free(user);
}
return false;
}
}
else
{
// There is no need to prohibit
return true;
}
}
// Desktop difference warning message dialog initialization
void CmDesktopDlgInit(HWND hWnd, wchar_t *account_name)
{
wchar_t tmp[2048];
bool remote = false;
bool user_switching = false;
bool console_active = false;
wchar_t *console_user = NULL;
// Validate arguments
if (hWnd == NULL)
{
return;
}
FormatText(hWnd, 0, account_name);
FormatText(hWnd, S_TITLE, account_name);
DlgFont(hWnd, S_TITLE, 11, true);
DlgFont(hWnd, S_INFO, 11, true);
if (cm->server_name == NULL)
{
UniStrCpy(tmp, sizeof(tmp), _UU("CM_DESKTOP_LOCAL_PC"));
}
else
{
UniFormat(tmp, sizeof(tmp), _UU("CM_DESKTOP_REMOTE_PC"), cm->server_name);
}
FormatText(hWnd, S_WARNING, tmp);
if (cm->server_name != NULL)
{
remote = true;
}
else
{
if (MsIsTerminalServiceInstalled())
{
user_switching = false;
}
else
{
user_switching = true;
}
console_user = MsGetSessionUserName(0);
if (console_user == NULL)
{
console_active = false;
}
else
{
console_active = true;
}
}
// MSG1
if (remote == false)
{
UniFormat(tmp, sizeof(tmp), _UU("CM_DESKTOP_MSG_LOCAL_1"),
user_switching ? _UU("CM_DESKTOP_MSG_LOCAL_SW") : _UU("CM_DESKTOP_MSG_LOCAL_TS"));
}
else
{
UniFormat(tmp, sizeof(tmp), _UU("CM_DESKTOP_MSG_REMOTE_1"),
cm->server_name);
}
SetText(hWnd, S_MSG_1, tmp);
// MSG2
if (remote == false)
{
if (console_active)
{
UniFormat(tmp, sizeof(tmp), _UU("CM_DESKTOP_MSG_LOCAL_21"),
console_user, MsGetCurrentTerminalSessionId());
}
else
{
UniFormat(tmp, sizeof(tmp), _UU("CM_DESKTOP_MSG_LOCAL_22"),
MsGetCurrentTerminalSessionId());
}
}
else
{
UniFormat(tmp, sizeof(tmp), _UU("CM_DESKTOP_MSG_REMOTE_2"), cm->server_name);
}
SetText(hWnd, S_MSG_2, tmp);
// MSG3
if (remote == false)
{
if (console_active)
{
UniFormat(tmp, sizeof(tmp), _UU("CM_DESKTOP_MSG_LOCAL_31"),
console_user, account_name);
}
else
{
UniFormat(tmp, sizeof(tmp), _UU("CM_DESKTOP_MSG_LOCAL_32"),
account_name);
}
}
else
{
UniFormat(tmp, sizeof(tmp), _UU("CM_DESKTOP_MSG_REMOTE_3"), cm->server_name,
account_name);
}
SetText(hWnd, S_MSG_3, tmp);
if (console_user != NULL)
{
Free(console_user);
}
}
// Desktop difference warning message dialog
UINT CmDesktopDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
{
wchar_t *account_name = (wchar_t *)param;
// Validate arguments
if (hWnd == NULL)
{
return 0;
}
switch (msg)
{
case WM_INITDIALOG:
CmDesktopDlgInit(hWnd, account_name);
break;
case WM_COMMAND:
switch (wParam)
{
case IDOK:
EndDialog(hWnd, true);
break;
case IDCANCEL:
Close(hWnd);
break;
}
break;
case WM_CLOSE:
EndDialog(hWnd, false);
break;
}
return 0;
}
// Show a warning message that the desktop is different, if necessary
bool CmWarningDesktop(HWND hWnd, wchar_t *account_name)
{
// Validate arguments
if (hWnd == NULL || account_name == NULL)
{
return false;
}
if (cm->Client->Unix)
{
//There is no need for warning if the client is an UNIX
return true;
}
if (/*MsIsTerminalServiceInstalled() || MsIsUserSwitchingInstalled() ||*/ (cm->server_name != NULL))
{
if (cm->server_name == NULL)
{
//if (MsGetCurrentTerminalSessionId() == 0)
{
// No need for warning
return true;
}
}
// There is a need for warning
return Dialog(hWnd, D_CM_DESKTOP, CmDesktopDlgProc, account_name);
}
else
{
// No need for warning
return true;
}
}
// Update the password setting dialog
void CmPasswordRefresh(HWND hWnd)
{
bool ok = true;
// Validate arguments
if (hWnd == NULL)
{
return;
}
SetEnable(hWnd, E_PASSWORD, IsChecked(hWnd, R_USE_PASSWORD));
SetEnable(hWnd, E_PASSWORD2, IsChecked(hWnd, R_USE_PASSWORD));
SetEnable(hWnd, IDC_STATIC1, IsChecked(hWnd, R_USE_PASSWORD));
SetEnable(hWnd, IDC_STATIC2, IsChecked(hWnd, R_USE_PASSWORD));
SetEnable(hWnd, R_REMOTE_ONLY, IsChecked(hWnd, R_USE_PASSWORD));
if (IsChecked(hWnd, R_USE_PASSWORD))
{
char tmp1[MAX_SIZE];
char tmp2[MAX_SIZE];
if (IsEmpty(hWnd, E_PASSWORD))
{
ok = false;
}
GetTxtA(hWnd, E_PASSWORD, tmp1, sizeof(tmp1));
GetTxtA(hWnd, E_PASSWORD2, tmp2, sizeof(tmp2));
if (StrCmp(tmp1, tmp2) != 0)
{
ok = false;
}
if (StrCmp(tmp1, HIDDEN_PASSWORD) == 0)
{
ok = false;
}
}
SetEnable(hWnd, IDOK, ok);
}
// Password setting procedure
UINT CmPasswordProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
{
RPC_CLIENT_PASSWORD_SETTING c;
RPC_CLIENT_PASSWORD p;
char tmp[MAX_SIZE];
// Validate arguments
if (hWnd == NULL)
{
return 0;
}
switch (msg)
{
case WM_INITDIALOG:
// Get the password setting
if (CALL(hWnd, CcGetPasswordSetting(cm->Client, &c)))
{
Check(hWnd, R_USE_PASSWORD, c.IsPasswordPresented);
if (c.IsPasswordPresented)
{
SetTextA(hWnd, E_PASSWORD, HIDDEN_PASSWORD);
SetTextA(hWnd, E_PASSWORD2, HIDDEN_PASSWORD);
FocusEx(hWnd, E_PASSWORD);
Check(hWnd, R_REMOTE_ONLY, c.PasswordRemoteOnly);
}
else
{
Focus(hWnd, R_USE_PASSWORD);
}
}
CmPasswordRefresh(hWnd);
break;
case WM_COMMAND:
switch (wParam)
{
case R_USE_PASSWORD:
if (IsChecked(hWnd, R_USE_PASSWORD))
{
FocusEx(hWnd, E_PASSWORD);
}
break;
case IDOK:
GetTxtA(hWnd, E_PASSWORD, tmp, sizeof(tmp));
Zero(&p, sizeof(p));
if (IsChecked(hWnd, R_USE_PASSWORD))
{
StrCpy(p.Password, sizeof(p.Password), tmp);
p.PasswordRemoteOnly = IsChecked(hWnd, R_REMOTE_ONLY);
}
if (CALL(hWnd, CcSetPassword(cm->Client, &p)))
{
if (StrLen(p.Password) > 0)
{
MsgBox(hWnd, MB_ICONINFORMATION, _UU("CM_PASSWORD_SET"));
}
else
{
MsgBox(hWnd, MB_ICONINFORMATION, _UU("CM_PASSWORD_REMOVE"));
}
EndDialog(hWnd, true);
}
break;
case IDCANCEL:
Close(hWnd);
break;
}
switch (LOWORD(wParam))
{
case R_USE_PASSWORD:
case R_REMOTE_ONLY:
case E_PASSWORD:
case E_PASSWORD2:
CmPasswordRefresh(hWnd);
break;
}
switch (wParam)
{
case R_REMOTE_ONLY:
case R_USE_PASSWORD:
if (IsChecked(hWnd, R_USE_PASSWORD))
{
FocusEx(hWnd, E_PASSWORD);
}
break;
}
break;
case WM_CLOSE:
EndDialog(hWnd, false);
break;
}
return 0;
}
// Set the password
void CmPassword(HWND hWnd)
{
// Validate arguments
if (hWnd == NULL)
{
return;
}
Dialog(hWnd, D_CM_PASSWORD, CmPasswordProc, NULL);
}
// CA dialog update
void CmTrustDlgUpdate(HWND hWnd)
{
// Validate arguments
if (hWnd == NULL)
{
return;
}
SetEnable(hWnd, B_EXPORT, LvIsSelected(hWnd, L_CERT));
SetEnable(hWnd, B_DELETE, LvIsSelected(hWnd, L_CERT) && cm->CmSetting.LockMode == false);
SetEnable(hWnd, IDOK, LvIsSelected(hWnd, L_CERT));
SetEnable(hWnd, B_IMPORT, cm->CmSetting.LockMode == false);
}
// Update the list of certificates
void CmTrustDlgRefresh(HWND hWnd)
{
RPC_CLIENT_ENUM_CA c;
// Validate arguments
if (hWnd == NULL)
{
return;
}
if (CALL(hWnd, CcEnumCa(cm->Client, &c)))
{
UINT i;
LVB *b = LvInsertStart();
for (i = 0;i < c.NumItem;i++)
{
RPC_CLIENT_ENUM_CA_ITEM *cert = c.Items[i];
wchar_t tmp[MAX_SIZE];
GetDateStrEx64(tmp, sizeof(tmp), SystemToLocal64(cert->Expires), NULL);
LvInsertAdd(b, ICO_CERT, (void *)cert->Key, 3,
cert->SubjectName, cert->IssuerName, tmp);
}
LvInsertEnd(b, hWnd, L_CERT);
CiFreeClientEnumCa(&c);
}
CmTrustDlgUpdate(hWnd);
}
// Import
void CmTrustImport(HWND hWnd)
{
X *x;
RPC_CERT c;
if (CmLoadXFromFileOrSecureCard(hWnd, &x) == false)
{
return;
}
Zero(&c, sizeof(c));
c.x = x;
CALL(hWnd, CcAddCa(cm->Client, &c));
CmVoice("new_cert");
FreeX(c.x);
CmTrustDlgRefresh(hWnd);
}
// Export
void CmTrustExport(HWND hWnd)
{
UINT key;
// Validate arguments
if (hWnd == NULL)
{
return;
}
key = (UINT)LvGetParam(hWnd, L_CERT, LvGetSelected(hWnd, L_CERT));
if (key != INFINITE)
{
RPC_GET_CA a;
Zero(&a, sizeof(a));
a.Key = key;
if (CALL(hWnd, CcGetCa(cm->Client, &a)))
{
wchar_t *name;
X *x = CloneX(a.x);
CiFreeGetCa(&a);
// Save
name = SaveDlg(hWnd, _UU("DLG_CERT_FILES"), _UU("DLG_SAVE_CERT"), NULL, L".cer");
if (name != NULL)
{
wchar_t str[MAX_SIZE];
UniStrCpy(str, sizeof(str), name);
if (XToFileW(x, str, true))
{
MsgBox(hWnd, MB_ICONINFORMATION, _UU("DLG_CERT_SAVE_OK"));
}
else
{
MsgBox(hWnd, MB_ICONSTOP, _UU("DLG_CERT_SAVE_ERROR"));
}
Free(name);
}
FreeX(x);
}
}
}
// Display
void CmTrustView(HWND hWnd)
{
UINT key;
// Validate arguments
if (hWnd == NULL)
{
return;
}
key = (UINT)LvGetParam(hWnd, L_CERT, LvGetSelected(hWnd, L_CERT));
if (key != INFINITE)
{
RPC_GET_CA a;
Zero(&a, sizeof(a));
a.Key = key;
if (CALL(hWnd, CcGetCa(cm->Client, &a)))
{
X *x = CloneX(a.x);
X *x_issuer;
CiFreeGetCa(&a);
x_issuer = CmGetIssuer(x);
CertDlg(hWnd, x, x_issuer, true);
FreeX(x);
FreeX(x_issuer);
}
}
}
// CA dialog procedure
UINT CmTrustDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
{
NMHDR *n;
UINT index;
// Validate arguments
if (hWnd == NULL)
{
return 0;
}
switch (msg)
{
case WM_INITDIALOG:
LvInit(hWnd, L_CERT);
LvInsertColumn(hWnd, L_CERT, 0, _UU("CM_CERT_COLUMN_1"), 190);
LvInsertColumn(hWnd, L_CERT, 1, _UU("CM_CERT_COLUMN_2"), 190);
LvInsertColumn(hWnd, L_CERT, 2, _UU("CM_CERT_COLUMN_3"), 160);
CmTrustDlgRefresh(hWnd);
break;
case WM_COMMAND:
switch (wParam)
{
case B_IMPORT:
CmTrustImport(hWnd);
break;
case B_EXPORT:
CmTrustExport(hWnd);
break;
case B_DELETE:
index = LvGetSelected(hWnd, L_CERT);
if (index != INFINITE)
{
UINT key = (UINT)LvGetParam(hWnd, L_CERT, index);
if (key != INFINITE)
{
if (MsgBox(hWnd, MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2, _UU("CM_CERT_DELETE_MSG")) == IDYES)
{
RPC_CLIENT_DELETE_CA c;
Zero(&c, sizeof(c));
c.Key = key;
if (CALL(hWnd, CcDeleteCa(cm->Client, &c)))
{
CmTrustDlgRefresh(hWnd);
}
}
}
}
break;
case IDOK:
if (IsEnable(hWnd, IDOK))
{
CmTrustView(hWnd);
}
break;
case IDCANCEL:
Close(hWnd);
break;
}
break;
case WM_CLOSE:
EndDialog(hWnd, 0);
break;
case WM_NOTIFY:
n = (NMHDR *)lParam;
switch (n->idFrom)
{
case L_CERT:
switch (n->code)
{
case LVN_ITEMCHANGED:
CmTrustDlgUpdate(hWnd);
break;
case NM_DBLCLK:
Command(hWnd, IDOK);
break;
}
break;
}
break;
}
LvSortHander(hWnd, msg, wParam, lParam, L_CERT);
return 0;
}
// Show the CA dialog
void CmTrustDlg(HWND hWnd)
{
Dialog(hWnd, D_CM_TRUST, CmTrustDlgProc, NULL);
}
// Main window procedure
UINT CmMainWindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
{
NMHDR *n;
static UINT taskbar_msg = 0;
COPYDATASTRUCT *cpy;
// Validate arguments
if (hWnd == NULL)
{
return 0;
}
if (taskbar_msg != 0 && msg == taskbar_msg)
{
// The task-bar is regenerated
if (cm->TrayInited)
{
MsRestoreIconOnTray();
}
}
// CmSetForegroundProcessToCnService();
switch (msg)
{
case WM_CM_SETTING_CHANGED_MESSAGE:
// CM_SETTING has changed
CmApplyCmSetting();
break;
case WM_INITDIALOG:
CmMainWindowOnInit(hWnd);
taskbar_msg = RegisterWindowMessage("TaskbarCreated");
CmEndStartupMutex();
break;
case WM_CM_SHOW:
// Received a display request from another process
if (cm->CmSetting.EasyMode == false)
{
ShowWindow(hWnd, SW_SHOWNORMAL);
}
else
{
if (cm->hEasyWnd == NULL)
{
CmShowEasy();
}
else
{
SetForegroundWindow(cm->hEasyWnd);
SetActiveWindow(cm->hEasyWnd);
}
}
break;
case WM_COMMAND:
CmMainWindowOnCommand(hWnd, wParam, lParam);
break;
case WM_SIZE:
CmMainWindowOnSize(hWnd);
break;
case WM_CLOSE:
if (cm->CmSetting.EasyMode == false)
{
CmShowOrHideWindow(hWnd);
}
else
{
if (cm->hEasyWnd == NULL)
{
CmShowEasy();
}
else
{
SetForegroundWindow(cm->hEasyWnd);
SetActiveWindow(cm->hEasyWnd);
}
}
return 1;
case WM_INITMENUPOPUP:
if (HIWORD(lParam) == false)
{
CmMainWindowOnPopupMenu(hWnd, (HMENU)wParam, LOWORD(lParam));
}
break;
case WM_NOTIFY:
n = (NMHDR *)lParam;
if (n->idFrom == L_ACCOUNT && (n->code == LVN_BEGINLABELEDITW || n->code == LVN_BEGINLABELEDITA))
{
wchar_t *tmp = LvGetSelectedStr(hWnd, L_ACCOUNT, 0);
if (tmp != NULL)
{
if (UniStrCmpi(tmp, _UU("CM_NEW_ICON")) == 0 || UniStrCmpi(tmp, _UU("CM_VGC_ICON")) == 0 || UniStrCmpi(tmp, _UU("CM_VGC_LINK")) == 0
)
{
SendMsg(hWnd, L_ACCOUNT, LVM_CANCELEDITLABEL, 0, 0);
Free(tmp);
return true;
}
Free(tmp);
}
}
CmMainWindowOnNotify(hWnd, (NMHDR *)lParam);
break;
case WM_CM_NOTIFY:
CmRefreshVLanList(hWnd);
CmRefreshAccountList(hWnd);
CmRefreshStatusBar(hWnd);
break;
case WM_TIMER:
switch (wParam)
{
case 1:
CmSetForegroundProcessToCnService();
break;
case 2:
CmPollingTray(hWnd);
break;
case 3:
KillTimer(hWnd, 3);
Hide(hWnd, 0);
break;
case 4:
KillTimer(hWnd, 4);
CmMainWindowOnShowEasy(hWnd);
break;
case 6:
if (cm->Update == NULL)
{
if (cm->server_name == NULL)
{
if (CmGetNumConnected(hWnd) == 0)
{
cm->Update = InitUpdateUi(_UU("PRODUCT_NAME_VPN_CMGR"), NAME_OF_VPN_CLIENT_MANAGER, NULL,
GetCurrentBuildDate(), CEDAR_BUILD, CEDAR_VER, ((cm->Client == NULL) ? NULL : cm->Client->ClientId),
true);
}
}
}
break;
}
break;
case WM_CM_TRAY_MESSAGE:
// Message from the icon in the task tray
CmMainWindowOnTrayClicked(hWnd, wParam, lParam);
break;
case WM_COPYDATA:
cpy = (COPYDATASTRUCT *)lParam;
if (cpy != NULL)
{
if (cpy->dwData == CM_IMPORT_FILENAME_MSG || cpy->dwData == CM_IMPORT_FILENAME_MSG_OVERWRITE)
{
char *filename = (char *)cpy->lpData;
if (cm->CmSetting.LockMode == false || cpy->dwData == CM_IMPORT_FILENAME_MSG_OVERWRITE)
{
wchar_t fullpath[MAX_PATH];
if (StrLen(filename) >= 2 && IsFileExists(filename))
{
StrToUni(fullpath, sizeof(fullpath), filename);
}
else
{
UniStrCpy(fullpath, sizeof(fullpath), (wchar_t *)filename);
}
CmImportAccountMainEx(cm->hEasyWnd ? cm->hEasyWnd : hWnd, fullpath, cpy->dwData == CM_IMPORT_FILENAME_MSG_OVERWRITE);
}
else
{
MsgBox(cm->hEasyWnd ? cm->hEasyWnd : hWnd, MB_ICONEXCLAMATION | MB_SETFOREGROUND | MB_TOPMOST, _UU("CM_VPN_FILE_IMPORT_NG"));
}
}
}
break;
case WM_QUERYENDSESSION:
// Windows is about to terminate
cm->WindowsShutdowning = true;
CmSaveMainWindowPos(hWnd);
SleepThread(256);
break;
case WM_ENDSESSION:
// Windows has terminated
_exit(0);
break;
}
LvSortHander(hWnd, msg, wParam, lParam, L_ACCOUNT);
LvSortHander(hWnd, msg, wParam, lParam, L_VLAN);
return 0;
}
// Specify the notification service to the foreground process
void CmSetForegroundProcessToCnService()
{
if (cm->MenuPopuping)
{
return;
}
if (cm->server_name == NULL)
{
if (CnCheckAlreadyExists(false))
{
AllowFGWindow(MsRegReadInt(REG_CURRENT_USER,
CM_REG_KEY, "NotifyServerProcessId"));
}
}
}
// Show the [recent destination] sub-menu
HMENU CmCreateRecentSubMenu(HWND hWnd, UINT start_id)
{
HMENU h = NULL;
UINT i;
RPC_CLIENT_ENUM_ACCOUNT a;
LIST *o;
bool easy;
easy = cm->CmSetting.EasyMode;
Zero(&a, sizeof(a));
if (CcEnumAccount(cm->Client, &a) == ERR_NO_ERROR)
{
o = NewListFast(CiCompareClientAccountEnumItemByLastConnectDateTime);
for (i = 0;i < a.NumItem;i++)
{
RPC_CLIENT_ENUM_ACCOUNT_ITEM *item = a.Items[i];
item->tmp1 = i;
if (item->LastConnectDateTime != 0)
{
Add(o, item);
}
}
Sort(o);
for (i = 0;i < MIN(LIST_NUM(o), CM_NUM_RECENT);i++)
{
RPC_CLIENT_ENUM_ACCOUNT_ITEM *item = (RPC_CLIENT_ENUM_ACCOUNT_ITEM *)LIST_DATA(o, i);
wchar_t tmp[MAX_PATH];
wchar_t *account_name;
char *server_name;
char *hub_name;
UINT pos;
if (h == NULL)
{
h = CreatePopupMenu();
}
account_name = item->AccountName;
server_name = item->ServerName;
hub_name = item->HubName;
UniStrCpy(tmp, sizeof(tmp), account_name);
pos = LvSearchStr(hWnd, L_ACCOUNT, 0, account_name);
if (pos != INFINITE)
{
MsAppendMenu(h, MF_STRING, start_id + pos, tmp);
}
}
ReleaseList(o);
CiFreeClientEnumAccount(&a);
}
return h;
}
// Show the sub-menu of the right-click menu in the task tray
HMENU CmCreateTraySubMenu(HWND hWnd, bool flag, UINT start_id)
{
HMENU h = NULL;
UINT i, num;
bool easy;
// Validate arguments
if (hWnd == NULL)
{
return NULL;
}
easy = cm->CmSetting.EasyMode;
num = LvNum(hWnd, L_ACCOUNT);
for (i = 0;i < num;i++)
{
wchar_t *status_str = LvGetStr(hWnd, L_ACCOUNT, i, 1);
if (status_str != NULL)
{
bool b = false;
bool is_account = false;
if (UniStrCmpi(status_str, _UU("CM_ACCOUNT_OFFLINE")) == 0)
{
if (flag == false)
{
b = true;
}
is_account = true;
}
if (UniStrCmpi(status_str, _UU("CM_ACCOUNT_ONLINE")) == 0 ||
UniStrCmpi(status_str, _UU("CM_ACCOUNT_CONNECTING")) == 0)
{
if (flag == true)
{
b = true;
}
is_account = true;
}
if (b)
{
wchar_t tmp[MAX_PATH];
wchar_t *account_name, *server_name;
wchar_t *hub_name;
if (h == NULL)
{
h = CreatePopupMenu();
}
account_name = LvGetStr(hWnd, L_ACCOUNT, i, 0);
server_name = LvGetStr(hWnd, L_ACCOUNT, i, 2);
hub_name = LvGetStr(hWnd, L_ACCOUNT, i, 3);
if (easy == false)
{
UniFormat(tmp, sizeof(tmp), L"%s\t- %s [%s]", account_name, server_name, hub_name);
}
else
{
UniStrCpy(tmp, sizeof(tmp), account_name);
}
MsAppendMenu(h, MF_STRING, start_id + i, tmp);
Free(account_name);
Free(server_name);
Free(hub_name);
}
Free(status_str);
}
}
return h;
}
// Display the right-click menu of the task tray
void CmShowTrayMenu(HWND hWnd)
{
HMENU h;
POINT p;
HMENU sub1, sub2, sub3, sub4;
bool locked;
bool easy;
// Validate arguments
if (hWnd == NULL)
{
return;
}
cm->MenuPopuping = true;
locked = cm->CmSetting.LockMode;
easy = cm->CmSetting.EasyMode;
// Create a menu
h = CreatePopupMenu();
// Cancel
MsAppendMenu(h, MF_ENABLED | MF_STRING, 100007, _UU("CM_TRAY_MENU_CANCEL"));
// Separator
MsAppendMenu(h, MF_SEPARATOR, 10006, NULL);
if (locked == false && easy == false)
{
// Creating a new connection settings
MsAppendMenu(h, MF_ENABLED | MF_STRING, CMD_NEW, _UU("CM_TRAY_MENU_NEW"));
// Separator
MsAppendMenu(h, MF_SEPARATOR, 10005, NULL);
}
// Connection menu
sub1 = CmCreateTraySubMenu(hWnd, false, CM_TRAY_MENU_CONNECT_ID_START);
if (sub1 != NULL)
{
MsAppendMenu(h, MF_BYPOSITION | MF_ENABLED | MF_POPUP | MF_STRING,
(UINT_PTR)sub1, _UU("CM_TRAY_MENU_CONNECT"));
}
// Disconnection menu
sub2 = CmCreateTraySubMenu(hWnd, true, CM_TRAY_MENU_DISCONNECT_ID_START);
if (sub2 != NULL)
{
MsAppendMenu(h, MF_BYPOSITION | MF_ENABLED | MF_POPUP | MF_STRING,
(UINT_PTR)sub2, _UU("CM_TRAY_MENU_DISCONNECT"));
}
// Status Display menu
sub3 = CmCreateTraySubMenu(hWnd, true, CM_TRAY_MENU_STATUS_ID_START);
if (sub3 != NULL)
{
MsAppendMenu(h, MF_BYPOSITION | MF_ENABLED | MF_POPUP | MF_STRING,
(UINT_PTR)sub3, _UU("CM_TRAY_MENU_STATUS"));
}
if (sub3 != NULL)
{
// Disconnect all connections
MsAppendMenu(h, MF_ENABLED | MF_STRING, CMD_DISCONNECT_ALL, _UU("CM_TRAY_MENU_DISCONNECT_ALL"));
}
if (sub1 != NULL || sub2 != NULL || sub3 != NULL)
{
// Separator
MsAppendMenu(h, MF_SEPARATOR, 10003, NULL);
}
// Connect to the recently connected VPN server
sub4 = CmCreateRecentSubMenu(hWnd, CM_TRAY_MENU_RECENT_ID_START);
if (sub4 != NULL)
{
MsAppendMenu(h, MF_BYPOSITION | MF_ENABLED | MF_POPUP | MF_STRING,
(UINT_PTR)sub4, _UU("CM_TRAY_MENU_RECENT"));
MsAppendMenu(h, MF_SEPARATOR, 10008, NULL);
}
if (locked == false && easy == false)
{
// Communication throughput measurement
MsAppendMenu(h, MF_ENABLED | MF_STRING, CMD_TRAFFIC, _UU("CM_TRAY_MENU_TRAFFIC"));
}
if (easy == false)
{
// Network device status
MsAppendMenu(h, MF_ENABLED | MF_STRING, CMD_NETIF, _UU("CM_TRAY_MENU_NETIF"));
}
// Version information
MsAppendMenu(h, MF_ENABLED | MF_STRING, CMD_ABOUT, _UU("CM_TRAY_MENU_ABOUT"));
// Separator
MsAppendMenu(h, MF_SEPARATOR, 10001, NULL);
// Change the operating mode
MsAppendMenu(h, MF_ENABLED | MF_STRING, CMD_CM_SETTING, _UU("CM_TRAY_MENU_SETTING"));
// Separator
MsAppendMenu(h, MF_SEPARATOR, 10001, NULL);
// Hide the icon
MsAppendMenu(h, MF_ENABLED | MF_STRING, CMD_TRAYICON, _UU("CM_MENU@CMD_TRAYICON"));
// Separator
MsAppendMenu(h, MF_SEPARATOR, 10001, NULL);
// Show or hide
MsAppendMenu(h, MF_ENABLED | MF_STRING, CMD_EXIT,
IsHide(hWnd, 0) ? _UU("CM_TRAY_MENU_1_SHOW") : _UU("CM_TRAY_MENU_1_HIDE"));
// Quit
MsAppendMenu(h, MF_ENABLED | MF_STRING, CMD_QUIT, _UU("CM_TRAY_MENU_2_QUIT"));
// Show the menu
GetCursorPos(&p);
SetForegroundWindow(hWnd);
TrackPopupMenu(h, TPM_LEFTALIGN, p.x, p.y, 0, hWnd, NULL);
PostMessage(hWnd, WM_NULL, 0, 0);
if (sub1 != NULL)
{
DestroyMenu(sub1);
}
if (sub2 != NULL)
{
DestroyMenu(sub2);
}
if (sub3 != NULL)
{
DestroyMenu(sub3);
}
DestroyMenu(h);
cm->MenuPopuping = false;
}
// Hide or show the main window
void CmShowOrHideWindow(HWND hWnd)
{
// Validate arguments
if (hWnd == NULL)
{
return;
}
if (IsHide(hWnd, 0))
{
Show(hWnd, 0);
if (IsIconic(hWnd))
{
ShowWindow(hWnd, SW_SHOWNORMAL);
}
SetForegroundWindow(hWnd);
SetActiveWindow(hWnd);
}
else
{
CmSaveMainWindowPos(hWnd);
Hide(hWnd, 0);
if (cm->TrayInited == false)
{
Command(hWnd, CMD_QUIT);
return;
}
}
}
// Right-clicked on the account list
void CmAccountListRightClick(HWND hWnd)
{
HMENU h;
HMENU parent;
UINT i;
// Validate arguments
if (hWnd == NULL)
{
return;
}
// Load the menu
h = LoadSubMenu(M_MAIN, 0, &parent);
if (h == NULL)
{
return;
}
InitMenuInternational(h, "CM_MENU");
// Remove the shortcut key
RemoveShortcutKeyStrFromMenu(h);
// Delete the exit menu
i = GetMenuItemPos(h, CMD_QUIT);
if (i != INFINITE)
{
DeleteMenuItem(h, i);
DeleteMenuItem(h, i - 1);
DeleteMenuItem(h, i - 2);
DeleteMenuItem(h, i - 3);
}
// Set enable / disable
CmMainWindowOnPopupMenu(hWnd, h, INFINITE);
if (h != NULL)
{
// Determine whether the selected account is under connecting
UINT i = LvGetSelected(hWnd, L_ACCOUNT);
wchar_t *str;
bool is_connected = false;
if (i != INFINITE)
{
str = LvGetStr(hWnd, L_ACCOUNT, i, 1);
if (str != NULL)
{
if (UniStrCmpi(str, _UU("CM_ACCOUNT_ONLINE")) == 0 || UniStrCmpi(str, _UU("CM_ACCOUNT_CONNECTING")) == 0)
{
// Connecting
is_connected = true;
}
Free(str);
}
}
if (i == INFINITE)
{
// Bold the New menu
SetMenuItemBold(h, GetMenuItemPos(h, CMD_NEW), true);
}
else
{
if (is_connected == false)
{
// Bold the connection menu
SetMenuItemBold(h, GetMenuItemPos(h, CMD_CONNECT), true);
}
else
{
// Bold the status menu
SetMenuItemBold(h, GetMenuItemPos(h, CMD_STATUS), true);
}
}
}
// Show the menu
PrintMenu(hWnd, h);
DestroyMenu(parent);
}
// Right-clicked on the virtual LAN card list
void CmVLanListRightClick(HWND hWnd)
{
HMENU h;
HMENU parent;
// Validate arguments
if (hWnd == NULL)
{
return;
}
// Load the menu
h = LoadSubMenu(M_MAIN, 3, &parent);
if (h == NULL)
{
return;
}
InitMenuInternational(h, "CM_MENU");
// Remove the shortcut key
RemoveShortcutKeyStrFromMenu(h);
// Set enable / disable
CmMainWindowOnPopupMenu(hWnd, h, INFINITE);
if (h != NULL)
{
// Examine whether the selected device is enabled
UINT i = LvGetSelected(hWnd, L_VLAN);
wchar_t *str;
bool is_active = false;
if (i != INFINITE)
{
str = LvGetStr(hWnd, L_VLAN, i, 1);
if (str != NULL)
{
if (UniStrCmpi(str, _UU("CM_VLAN_ENABLED")) == 0)
{
// Enabled
is_active = true;
}
Free(str);
}
}
if (i == INFINITE)
{
// Bold the New menu
SetMenuItemBold(h, GetMenuItemPos(h, CMD_NEW_VLAN), true);
}
else
{
if (is_active == false)
{
// Bold the enable menu
SetMenuItemBold(h, GetMenuItemPos(h, CMD_ENABLE_VLAN), true);
}
else
{
// Bold the Windows Network Setup menu
SetMenuItemBold(h, GetMenuItemPos(h, CMD_WINNET), true);
}
}
}
// Show the menu
PrintMenu(hWnd, h);
DestroyMenu(parent);
}
// Notify to the main window
void CmMainWindowOnNotify(HWND hWnd, NMHDR *n)
{
bool item_vlan;
NMLVDISPINFOW *disp_info;
NMLVKEYDOWN *key;
// Validate arguments
if (hWnd == NULL || n == NULL)
{
return;
}
switch (n->idFrom)
{
case L_ACCOUNT:
case L_VLAN:
if (n->idFrom == L_ACCOUNT)
{
item_vlan = false;
}
else
{
item_vlan = true;
}
switch (n->code)
{
case NM_DBLCLK:
// Double click
CmOnKey(hWnd, false, false, VK_RETURN);
break;
case NM_RCLICK:
// Right click
if (item_vlan == false)
{
CmAccountListRightClick(hWnd);
}
else
{
CmVLanListRightClick(hWnd);
}
break;
case LVN_ENDLABELEDITW:
// Change the name
disp_info = (NMLVDISPINFOW *)n;
if (disp_info->item.pszText != NULL)
{
wchar_t *new_name = disp_info->item.pszText;
wchar_t *old_name = LvGetStr(hWnd, L_ACCOUNT, disp_info->item.iItem, 0);
if (old_name != NULL)
{
if (UniStrCmp(new_name, old_name) != 0 && UniIsEmptyStr(new_name) == false)
{
RPC_RENAME_ACCOUNT a;
Zero(&a, sizeof(a));
UniStrCpy(a.OldName, sizeof(a.OldName), old_name);
UniStrCpy(a.NewName, sizeof(a.NewName), new_name);
if (CALL(hWnd, CcRenameAccount(cm->Client, &a)))
{
LvSetItem(hWnd, L_ACCOUNT, disp_info->item.iItem, 0, new_name);
}
}
Free(old_name);
}
}
break;
case LVN_KEYDOWN:
// Key pressed
key = (NMLVKEYDOWN *)n;
if (key != NULL)
{
bool ctrl, alt;
UINT code = key->wVKey;
ctrl = (GetKeyState(VK_CONTROL) & 0x8000) == 0 ? false : true;
alt = (GetKeyState(VK_MENU) & 0x8000) == 0 ? false : true;
CmOnKey(hWnd, ctrl, alt, code);
}
break;
}
break;
}
}
// Keyboard pressed
void CmOnKey(HWND hWnd, bool ctrl, bool alt, UINT key)
{
// Validate arguments
if (hWnd == NULL)
{
return;
}
// Single key
switch (key)
{
case VK_RETURN:
Command(hWnd, IDOK);
break;
case VK_DELETE:
// Delete
if (IsFocus(hWnd, L_ACCOUNT))
{
// Operation on the account list
Command(hWnd, CMD_DELETE);
}
else
{
// Operation on the virtual LAN card list
Command(hWnd, CMD_DELETE_VLAN);
}
break;
case VK_F2:
// Change the name
Command(hWnd, CMD_RENAME);
break;
case VK_F5:
// Update the status
Command(hWnd, CMD_REFRESH);
break;
}
if (alt)
{
switch (key)
{
case 'Q':
// Close
Command(hWnd, CMD_QUIT);
break;
}
}
if (ctrl)
{
switch (key)
{
case 'G':
// Smart Card Manager
Command(hWnd, CMD_SECURE_MANAGER);
break;
case 'S':
// Show the state
Command(hWnd, CMD_STATUS);
break;
case 'I':
// Disconnect all connections
Command(hWnd, CMD_DISCONNECT_ALL);
break;
case 'D':
// Disconnect
Command(hWnd, CMD_DISCONNECT);
break;
case 'N':
// Create a new connection settings
Command(hWnd, CMD_NEW);
break;
case 'C':
// Creating a copy
Command(hWnd, CMD_CLONE);
break;
case 'T':
// Set to start-up connection
Command(hWnd, CMD_STARTUP);
break;
case 'A':
// Select all
Command(hWnd, CMD_SELECT_ALL);
break;
case 'L':
// Create a new virtual LAN card
Command(hWnd, CMD_NEW_VLAN);
break;
case 'E':
// Enable the virtual LAN card
Command(hWnd, CMD_ENABLE_VLAN);
break;
case 'B':
// Disable the virtual LAN card
Command(hWnd, CMD_DISABLE_VLAN);
break;
case 'U':
// Reinstall the driver
Command(hWnd, CMD_REINSTALL);
break;
case 'W':
// Configure Windows network connection
Command(hWnd, CMD_WINNET);
break;
case 'P':
// Set the password
Command(hWnd, CMD_PASSWORD);
break;
case 'O':
// Option settings
Command(hWnd, CMD_TRAFFIC);
break;
case 'R':
// Certificate management
Command(hWnd, CMD_TRUST);
break;
case 'Q':
// Throughput
Command(hWnd, CMD_TRAFFIC);
break;
}
}
}
// Command of the main window
void CmMainWindowOnCommand(HWND hWnd, WPARAM wParam, LPARAM lParam)
{
CmMainWindowOnCommandEx(hWnd, wParam, lParam, false);
}
void CmMainWindowOnCommandEx(HWND hWnd, WPARAM wParam, LPARAM lParam, bool easy)
{
wchar_t *tmp;
char *name;
UINT index;
UINT id;
bool ctrl, alt;
UINT flag = 0;
// Validate arguments
wchar_t *selected_name = NULL;
UINT starter_id = 0;
if (hWnd == NULL)
{
return;
}
ctrl = (GetKeyState(VK_CONTROL) & 0x8000) == 0 ? false : true;
alt = (GetKeyState(VK_MENU) & 0x8000) == 0 ? false : true;
if (wParam == IDOK)
{
tmp = LvGetSelectedStr(hWnd, L_ACCOUNT, 0);
if (tmp != NULL)
{
if (UniStrCmpi(tmp, _UU("CM_NEW_ICON")) == 0)
{
Free(tmp);
Command(hWnd, CMD_NEW);
return;
}
if (UniStrCmpi(tmp, _UU("CM_VGC_ICON")) == 0 || UniStrCmpi(tmp, _UU("CM_VGC_LINK")) == 0)
{
Free(tmp);
Command(hWnd, CMD_VGC_CONNECT);
return;
}
Free(tmp);
}
}
if (CmIsEnabled(hWnd, (UINT)wParam) == false)
{
return;
}
if (CM_TRAY_IS_CONNECT_ID(wParam))
{
// Connection request
starter_id = CM_TRAY_MENU_CONNECT_ID_START;
flag = 1;
}
if (CM_TRAY_IS_STATUS_ID(wParam))
{
// Information display request
starter_id = CM_TRAY_MENU_STATUS_ID_START;
flag = 2;
}
if (CM_TRAY_IS_DISCONNECT_ID(wParam))
{
// Disconnect request
starter_id = CM_TRAY_MENU_DISCONNECT_ID_START;
flag = 3;
}
if (CM_TRAY_IS_RECENT_ID(wParam))
{
// Recent destinations
starter_id = CM_TRAY_MENU_RECENT_ID_START;
flag = 1;
}
if (starter_id != 0)
{
UINT num;
id = (UINT)wParam - starter_id;
num = LvNum(hWnd, L_ACCOUNT);
if (id < num)
{
selected_name = LvGetStr(hWnd, L_ACCOUNT, id, 0);
if (selected_name != NULL)
{
if (UniStrCmpi(selected_name, _UU("CM_NEW_ICON")) != 0 &&
UniStrCmpi(selected_name, _UU("CM_VGC_ICON")) != 0 &&
UniStrCmpi(selected_name, _UU("CM_VGC_LINK")) != 0)
{
switch (flag)
{
case 1:
CmConnect(hWnd, selected_name);
break;
case 2:
CmStatus(hWnd, selected_name);
break;
case 3:
CmDisconnect(hWnd, selected_name);
break;
}
}
}
Free(selected_name);
}
}
switch (wParam)
{
case IDOK:
case CMD_EASY_DBLCLICK:
// Property or connection
if (IsFocus(hWnd, L_ACCOUNT) || (hWnd == cm->hEasyWnd))
{
// Operation about the account list
if (alt == false)
{
UINT index = LvGetSelected(hWnd, L_ACCOUNT);
bool b = false;
if (index != INFINITE)
{
wchar_t *s = LvGetStr(hWnd, L_ACCOUNT, index, 1);
if (s != NULL)
{
if (UniStrCmpi(s, _UU("CM_ACCOUNT_ONLINE")) == 0 || UniStrCmpi(s, _UU("CM_ACCOUNT_CONNECTING")) == 0)
{
b = true;
}
Free(s);
}
}
if (b == false)
{
// Connection
Command(hWnd, CMD_CONNECT);
}
else
{
if (hWnd != cm->hEasyWnd || wParam == CMD_EASY_DBLCLICK)
{
// Display status
Command(hWnd, CMD_STATUS);
}
else
{
// Disconnect
Command(hWnd, CMD_DISCONNECT);
}
}
}
else
{
// Property
Command(hWnd, CMD_PROPERTY);
}
}
else
{
// Configure Windows network connection
Command(hWnd, CMD_WINNET);
}
break;
case CMD_CONNECT:
// Connection
tmp = LvGetStr(hWnd, L_ACCOUNT, LvGetSelected(hWnd, L_ACCOUNT), 0);
if (tmp != NULL)
{
CmConnect(hWnd, tmp);
Free(tmp);
}
break;
case CMD_STATUS:
// Show the status
tmp = LvGetStr(hWnd, L_ACCOUNT, LvGetSelected(hWnd, L_ACCOUNT), 0);
if (tmp != NULL)
{
CmStatus(hWnd, tmp);
Free(tmp);
}
break;
case CMD_DISCONNECT_ALL:
// Disconnect all connections
CmDisconnectAll(hWnd);
break;
case CMD_DISCONNECT:
// Disconnect
tmp = LvGetStr(hWnd, L_ACCOUNT, LvGetSelected(hWnd, L_ACCOUNT), 0);
if (tmp != NULL)
{
CmDisconnect(hWnd, tmp);
Free(tmp);
}
break;
case CMD_NEW:
// Create new
CmNewAccount(hWnd);
break;
case CMD_CLONE:
// Copy
tmp = LvGetStr(hWnd, L_ACCOUNT, LvGetSelected(hWnd, L_ACCOUNT), 0);
if (tmp != NULL)
{
CmCopyAccount(hWnd, tmp);
Free(tmp);
}
break;
case CMD_SHORTCUT:
// Create a shortcut
tmp = LvGetStr(hWnd, L_ACCOUNT, LvGetSelected(hWnd, L_ACCOUNT), 0);
if (tmp != NULL)
{
CmSortcut(hWnd, tmp);
Free(tmp);
}
break;
case CMD_EXPORT_ACCOUNT:
// Export settings
tmp = LvGetStr(hWnd, L_ACCOUNT, LvGetSelected(hWnd, L_ACCOUNT), 0);
if (tmp != NULL)
{
CmExportAccount(hWnd, tmp);
Free(tmp);
}
break;
case CMD_IMPORT_ACCOUNT:
// Import settings
CmImportAccount(hWnd);
break;
case CMD_STARTUP:
// Set to start-up connection
tmp = LvGetStr(hWnd, L_ACCOUNT, LvGetSelected(hWnd, L_ACCOUNT), 0);
if (tmp != NULL)
{
RPC_CLIENT_DELETE_ACCOUNT c;
Zero(&c, sizeof(c));
UniStrCpy(c.AccountName, sizeof(c.AccountName), tmp);
CALL(hWnd, CcSetStartupAccount(cm->Client, &c));
CmVoice("set_startup");
MsgBoxEx(hWnd, MB_ICONINFORMATION, _UU("CM_SET_STARTUP"), tmp);
Free(tmp);
}
break;
case CMD_NOSTARTUP:
// Unset the start-up connection
tmp = LvGetStr(hWnd, L_ACCOUNT, LvGetSelected(hWnd, L_ACCOUNT), 0);
if (tmp != NULL)
{
if (MsgBoxEx(hWnd, MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2,
_UU("CM_REMOVE_STARTUP"), tmp) == IDYES)
{
RPC_CLIENT_DELETE_ACCOUNT c;
Zero(&c, sizeof(c));
UniStrCpy(c.AccountName, sizeof(c.AccountName), tmp);
CALL(hWnd, CcRemoveStartupAccount(cm->Client, &c));
CmVoice("remove_startup");
}
Free(tmp);
}
break;
case CMD_DELETE:
// Delete
tmp = LvGetStr(hWnd, L_ACCOUNT, LvGetSelected(hWnd, L_ACCOUNT), 0);
if (tmp != NULL)
{
CmDeleteAccount(hWnd, tmp);
Free(tmp);
}
break;
case CMD_RENAME:
// Change the name
Focus(hWnd, L_ACCOUNT);
LvRename(hWnd, L_ACCOUNT, LvGetSelected(hWnd, L_ACCOUNT));
break;
case CMD_PROPERTY:
// Property
tmp = LvGetStr(hWnd, L_ACCOUNT, LvGetSelected(hWnd, L_ACCOUNT), 0);
if (tmp != NULL)
{
CmEditAccount(hWnd, tmp);
Free(tmp);
}
break;
case IDCANCEL:
case CMD_EXIT:
// Close
Close(hWnd);
break;
case CMD_QUIT:
// Exit
CmMainWindowOnQuit(hWnd);
break;
case CMD_SELECT_ALL:
// Select all
LvSelectAll(hWnd, L_ACCOUNT);
LvSelectAll(hWnd, L_VLAN);
break;
case CMD_SWITCH_SELECT:
// Invert selection
LvSwitchSelect(hWnd, L_ACCOUNT);
LvSwitchSelect(hWnd, L_VLAN);
break;
case CMD_GRID:
// Show grid
cm->ShowGrid = !cm->ShowGrid;
CmRefreshVLanListEx(hWnd, true);
CmRefreshAccountListEx2(hWnd, false, true);
break;
case CMD_STATUSBAR:
// Show the status bar
if (cm->HideStatusBar == false)
{
cm->HideStatusBar = true;
Hide(hWnd, S_STATUSBAR);
CmMainWindowOnSize(hWnd);
}
else
{
cm->HideStatusBar = false;
Show(hWnd, S_STATUSBAR);
CmMainWindowOnSize(hWnd);
}
CmSaveMainWindowPos(hWnd);
break;
case CMD_VISTASTYLE:
cm->VistaStyle = !cm->VistaStyle;
CmRefreshEx(hWnd, true);
CmSaveMainWindowPos(hWnd);
break;
case CMD_TRAYICON:
// Tray icon display
if (cm->HideTrayIcon == false)
{
cm->HideTrayIcon = true;
CmFreeTray(hWnd);
if (IsHide(hWnd, 0))
{
MsgBox(hWnd, MB_ICONINFORMATION, _UU("CM_TRAY_ICON_RESTORE"));
}
}
else
{
cm->HideTrayIcon = false;
if (cm->server_name == NULL)
{
CmInitTray(hWnd);
}
}
break;
case CMD_SHOWPORT:
// Show the port number
cm->ShowPort = !cm->ShowPort;
CmRefresh(hWnd);
break;
case CMD_ICON:
// Show the icon
if (cm->IconView == false)
{
cm->IconView = true;
CmRefresh(hWnd);
}
break;
case CMD_DETAIL:
// Show details
if (cm->IconView)
{
cm->IconView = false;
CmRefresh(hWnd);
}
break;
case CMD_REFRESH:
if (easy == false)
{
// Display update
LvReset(hWnd, L_ACCOUNT);
LvReset(hWnd, L_VLAN);
CmRefresh(hWnd);
}
break;
case CMD_NEW_VLAN:
// Create a Virtual LAN card
if (CmStopInstallVLan(hWnd) == false)
{
// Installation is prohibited
break;
}
name = CmNewVLanDlg(hWnd);
if (name != NULL)
{
wchar_t tmp[MAX_SIZE];
void *helper = NULL;
RPC_CLIENT_CREATE_VLAN c;
Zero(&c, sizeof(c));
StrCpy(c.DeviceName, sizeof(c.DeviceName), name);
if (MsIsNt() == false)
{
// Change the title of the window
GetTxt(hWnd, 0, tmp, sizeof(tmp));
SetText(hWnd, 0, _UU("CM_VLAN_INSTALLING"));
}
// Minimize
if (MsIsVista() == false)
{
ShowWindow(hWnd, SW_SHOWMINIMIZED);
}
if (MsIsVista())
{
helper = CmStartUacHelper();
}
if (CALL(hWnd, CcCreateVLan(cm->Client, &c)))
{
CmVoice("new_vlan");
}
CmStopUacHelper(helper);
if (MsIsNt() == false)
{
// Restore the title of the window
SetText(hWnd, 0, tmp);
}
// Restore
if (MsIsVista() == false)
{
ShowWindow(hWnd, SW_SHOWNORMAL);
}
Free(name);
}
break;
case CMD_DELETE_VLAN:
// Delete the Virtual LAN card
index = LvGetSelected(hWnd, L_VLAN);
if (index != INFINITE)
{
if (cm->Client->Win9x == false)
{
// Windows 2000 or later
wchar_t *s = LvGetStr(hWnd, L_VLAN, index, 0);
if (s != NULL)
{
RPC_CLIENT_CREATE_VLAN c;
char str[MAX_SIZE];
CmVoice("delete_vlan_1");
if (MsgBoxEx(hWnd, MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2, _UU("CM_DELETE_VLAN"), s) == IDYES)
{
Zero(&c, sizeof(c));
UniToStr(str, sizeof(str), s);
if (CmPrintNameToVLanName(c.DeviceName, sizeof(c.DeviceName), str))
{
if (CALL(hWnd, CcDeleteVLan(cm->Client, &c)))
{
CmVoice("delete_vlan_2");
}
}
}
Free(s);
}
}
else
{
// Windows 9x
if (MsgBox(hWnd, MB_ICONQUESTION | MB_YESNO, _UU("CM_9X_VLAN_UNINSTALL")) == IDYES)
{
Run("rundll32.exe", "shell32.dll,Control_RunDLL NETCPL.CPL",
false, false);
}
}
}
break;
case CMD_ENABLE_VLAN:
// Enable the virtual LAN card
index = LvGetSelected(hWnd, L_VLAN);
if (index != INFINITE)
{
wchar_t *s = LvGetStr(hWnd, L_VLAN, index, 0);
if (s != NULL)
{
RPC_CLIENT_CREATE_VLAN c;
char str[MAX_SIZE];
Zero(&c, sizeof(c));
UniToStr(str, sizeof(str), s);
if (CmPrintNameToVLanName(c.DeviceName, sizeof(c.DeviceName), str))
{
CALL(hWnd, CcEnableVLan(cm->Client, &c));
}
Free(s);
}
}
break;
case CMD_DISABLE_VLAN:
// Disable the virtual LAN card
index = LvGetSelected(hWnd, L_VLAN);
if (index != INFINITE)
{
wchar_t *s = LvGetStr(hWnd, L_VLAN, index, 0);
if (s != NULL)
{
RPC_CLIENT_CREATE_VLAN c;
char str[MAX_SIZE];
Zero(&c, sizeof(c));
UniToStr(str, sizeof(str), s);
if (CmPrintNameToVLanName(c.DeviceName, sizeof(c.DeviceName), str))
{
CALL(hWnd, CcDisableVLan(cm->Client, &c));
}
Free(s);
}
}
break;
case CMD_REINSTALL:
// Reinstall the virtual LAN card
if (CmStopInstallVLan(hWnd) == false)
{
// Installation is prohibited
break;
}
index = LvGetSelected(hWnd, L_VLAN);
if (index != INFINITE)
{
wchar_t *s = LvGetStr(hWnd, L_VLAN, index, 0);
if (s != NULL)
{
RPC_CLIENT_CREATE_VLAN c;
char str[MAX_SIZE];
Zero(&c, sizeof(c));
UniToStr(str, sizeof(str), s);
if (CmPrintNameToVLanName(c.DeviceName, sizeof(c.DeviceName), str))
{
void *helper = NULL;
if (MsIsVista() == false)
{
ShowWindow(hWnd, SW_SHOWMINIMIZED);
}
if (MsIsVista())
{
helper = CmStartUacHelper();
}
CALL(hWnd, CcUpgradeVLan(cm->Client, &c));
CmStopUacHelper(helper);
if (MsIsVista() == false)
{
ShowWindow(hWnd, SW_SHOWNORMAL);
}
}
Free(s);
}
}
break;
case CMD_PASSWORD:
// Password setting
CmPassword(hWnd);
break;
case CMD_OPTION:
// Option
CmConfigDlg(hWnd);
break;
case CMD_LANGUAGE:
// Language settings
if (true)
{
wchar_t path[MAX_SIZE];
CombinePathW(path, sizeof(path), MsGetExeDirNameW(), L"vpnsetup.exe");
if (MsExecuteW(path, L"/language:yes") == false)
{
MsgBox(hWnd, MB_ICONEXCLAMATION, _UU("SW_CHILD_PROCESS_ERROR"));
}
}
break;
case CMD_TRUST:
// Certificate management
CmTrustDlg(hWnd);
break;
case CMD_ABOUT:
// Version information
if (IsEnable(hWnd, 0))
{
AboutEx(hWnd, cm->Cedar, _UU("PRODUCT_NAME_VPN_CMGR"), cm->Update);
}
break;
case CMD_VOIDE_NONE:
cm->DisableVoice = true;
break;
case CMD_VOICE_NORMAL:
cm->DisableVoice = false;
cm->VoiceId = VOICE_SSK;
break;
case CMD_VOICE_ODD:
if (MsgBox(hWnd, MB_ICONQUESTION | MB_YESNO, _UU("CM_EXT_VOICE_MSG")) == IDYES)
{
cm->DisableVoice = false;
cm->VoiceId = VOICE_AHO;
}
break;
case CMD_SECURE_MANAGER:
// Smart Card Manager
CmClientSecureManager(hWnd);
break;
case CMD_SECURE_SELECT:
// Select a smart card
CmClientSelectSecure(hWnd);
break;
case CMD_NETIF:
// State of the network device
if (IsEnable(hWnd, 0))
{
UtSpeedMeterEx(hWnd);
}
break;
case CMD_MMCSS:
// Optimization utility for Windows Vista
if (MsIsVista() == false)
{
MsgBox(hWnd, MB_ICONINFORMATION, _UU("VISTA_MMCSS_MSG_4"));
}
else
{
if (MsIsAdmin() == false)
{
MsgBox(hWnd, MB_ICONEXCLAMATION, _UU("VISTA_MMCSS_MSG_4"));
}
else
{
if (MsIsMMCSSNetworkThrottlingEnabled())
{
if (MsgBox(hWnd, MB_ICONQUESTION | MB_YESNO, _UU("VISTA_MMCSS_MSG")) == IDYES)
{
MsSetMMCSSNetworkThrottlingEnable(false);
MsgBox(hWnd, MB_ICONINFORMATION, _UU("VISTA_MMCSS_MSG_5"));
}
}
else
{
if (MsgBox(hWnd, MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2, _UU("VISTA_MMCSS_MSG_2")) == IDYES)
{
MsSetMMCSSNetworkThrottlingEnable(true);
MsgBox(hWnd, MB_ICONINFORMATION, _UU("VISTA_MMCSS_MSG_6"));
}
}
}
}
break;
case CMD_TRAFFIC:
// Communication traffic measurement
if (IsEnable(hWnd, 0))
{
CmTraffic(hWnd);
}
break;
case CMD_CM_SETTING:
// Operation mode setting
if (IsEnable(hWnd, 0))
{
if (CmSetting(hWnd))
{
CmApplyCmSetting();
}
}
break;
case CMD_WINNET:
// Windows network settings
ShowWindowsNetworkConnectionDialog();
break;
}
}
// Option dialog
void CmConfigDlg(HWND hWnd)
{
// Validate arguments
if (hWnd == NULL)
{
return;
}
Dialog(hWnd, D_CM_CONFIG, CmConfigDlgProc, NULL);
}
// Initialize the option dialog
void CmConfigDlgInit(HWND hWnd)
{
bool use_alpha;
UINT alpha_value;
UINT os;
CLIENT_CONFIG c;
// Validate arguments
if (hWnd == NULL)
{
return;
}
DlgFont(hWnd, S_WARNING, 10, true);
DlgFont(hWnd, S_INFO, 10, false);
Zero(&c, sizeof(c));
if (CALL(hWnd, CcGetClientConfig(cm->Client, &c)) == false)
{
EndDialog(hWnd, 0);
return;
}
Check(hWnd, R_ALLOW_REMOTE_CONFIG, c.AllowRemoteConfig);
Check(hWnd, R_USE_KEEP_CONNECT, c.UseKeepConnect);
SetTextA(hWnd, E_HOSTNAME, c.KeepConnectHost);
SetIntEx(hWnd, E_PORT, c.KeepConnectPort);
SetIntEx(hWnd, E_INTERVAL, c.KeepConnectInterval);
Check(hWnd, R_TCP, c.KeepConnectProtocol == CONNECTION_TCP);
Check(hWnd, R_UDP, c.KeepConnectProtocol == CONNECTION_UDP);
use_alpha = MsRegReadInt(REG_CURRENT_USER, CM_REG_KEY, "UseAlpha") == 0 ? false : true;
alpha_value = MsRegReadInt(REG_CURRENT_USER, CM_REG_KEY, "AlphaValue");
alpha_value = MAKESURE(alpha_value, 0, 100);
SetInt(hWnd, E_ALPHA_VALUE, alpha_value == 0 ? 50 : alpha_value);
Check(hWnd, R_ALPHA, use_alpha);
os = GetOsInfo()->OsType;
if (OS_IS_WINDOWS_NT(os) && GET_KETA(os, 100) >= 2)
{
Enable(hWnd, R_ALPHA);
}
else
{
Disable(hWnd, R_ALPHA);
}
CmConfigDlgRefresh(hWnd);
}
// Update the option dialog
void CmConfigDlgRefresh(HWND hWnd)
{
bool ok = true;
bool use_keep_connect;
// Validate arguments
if (hWnd == NULL)
{
return;
}
use_keep_connect = IsChecked(hWnd, R_USE_KEEP_CONNECT);
SetEnable(hWnd, S_HOSTNAME, use_keep_connect);
SetEnable(hWnd, S_PORT, use_keep_connect);
SetEnable(hWnd, S_INTERVAL, use_keep_connect);
SetEnable(hWnd, S_INTERVAL2, use_keep_connect);
SetEnable(hWnd, S_PROTOCOL, use_keep_connect);
SetEnable(hWnd, S_INFO, use_keep_connect);
SetEnable(hWnd, S_INFO2, use_keep_connect);
SetEnable(hWnd, E_HOSTNAME, use_keep_connect);
SetEnable(hWnd, E_PORT, use_keep_connect);
SetEnable(hWnd, E_INTERVAL, use_keep_connect);
SetEnable(hWnd, R_TCP, use_keep_connect);
SetEnable(hWnd, R_UDP, use_keep_connect);
SetEnable(hWnd, S_WARNING, IsChecked(hWnd, R_ALLOW_REMOTE_CONFIG));
if (IsChecked(hWnd, R_USE_KEEP_CONNECT))
{
if (IsEmpty(hWnd, E_HOSTNAME))
{
ok = false;
}
if (IsChecked(hWnd, R_TCP) == false && IsChecked(hWnd, R_UDP) == false)
{
ok = false;
}
if (GetInt(hWnd, E_PORT) == 0 || GetInt(hWnd, E_PORT) >= 65536)
{
ok = false;
}
if (GetInt(hWnd, E_INTERVAL) == 0)
{
ok = false;
}
}
if (IsChecked(hWnd, R_ALPHA))
{
UINT i = GetInt(hWnd, E_ALPHA_VALUE);
if (i < 20 || i >= 100)
{
ok = false;
}
Enable(hWnd, E_ALPHA_VALUE);
}
else
{
Disable(hWnd, E_ALPHA_VALUE);
}
SetEnable(hWnd, IDOK, ok);
}
// Save the setting of the option dialog
void CmConfigDlgOnOk(HWND hWnd)
{
CLIENT_CONFIG c;
// Validate arguments
if (hWnd == NULL)
{
return;
}
Zero(&c, sizeof(c));
c.AllowRemoteConfig = IsChecked(hWnd, R_ALLOW_REMOTE_CONFIG);
c.UseKeepConnect = IsChecked(hWnd, R_USE_KEEP_CONNECT);
GetTxtA(hWnd, E_HOSTNAME, c.KeepConnectHost, sizeof(c.KeepConnectHost));
c.KeepConnectPort = GetInt(hWnd, E_PORT);
c.KeepConnectInterval = GetInt(hWnd, E_INTERVAL);
if (IsChecked(hWnd, R_TCP))
{
c.KeepConnectProtocol = CONNECTION_TCP;
}
else if (IsChecked(hWnd, R_UDP))
{
c.KeepConnectProtocol = CONNECTION_UDP;
}
else
{
return;
}
if (c.UseKeepConnect)
{
if (c.KeepConnectInterval < KEEP_INTERVAL_MIN || c.KeepConnectInterval > KEEP_INTERVAL_MAX)
{
MsgBoxEx(hWnd, MB_ICONINFORMATION, _UU("CM_KEEP_INTERVAL_MSG"),
KEEP_INTERVAL_MIN, KEEP_INTERVAL_MAX);
FocusEx(hWnd, E_INTERVAL);
return;
}
}
if (CALL(hWnd, CcSetClientConfig(cm->Client, &c)) == false)
{
return;
}
MsRegWriteInt(REG_CURRENT_USER, CM_REG_KEY, "AlphaValue", GetInt(hWnd, E_ALPHA_VALUE));
MsRegWriteInt(REG_CURRENT_USER, CM_REG_KEY, "UseAlpha", IsChecked(hWnd, R_ALPHA));
EndDialog(hWnd, true);
}
// Option setting dialog procedure
UINT CmConfigDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
{
// Validate arguments
if (hWnd == NULL)
{
return 0;
}
switch (msg)
{
case WM_INITDIALOG:
CmConfigDlgInit(hWnd);
break;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case R_ALLOW_REMOTE_CONFIG:
case R_USE_KEEP_CONNECT:
case E_HOSTNAME:
case E_PORT:
case E_INTERVAL:
case R_ALPHA:
case E_ALPHA_VALUE:
CmConfigDlgRefresh(hWnd);
break;
}
switch (wParam)
{
case IDOK:
CmConfigDlgRefresh(hWnd);
CmConfigDlgOnOk(hWnd);
break;
case IDCANCEL:
Close(hWnd);
break;
case R_ALLOW_REMOTE_CONFIG:
if (IsChecked(hWnd, R_ALLOW_REMOTE_CONFIG) == false)
{
if (cm->server_name != NULL)
{
// If the current user is remotely connected, show a warning
// when the user choose to disable the remote management
if (MsgBoxEx(hWnd, MB_ICONEXCLAMATION | MB_DEFBUTTON2 | MB_YESNO, _UU("CM_REMOTE_WARNING"),
cm->server_name, cm->server_name) == IDNO)
{
Check(hWnd, R_ALLOW_REMOTE_CONFIG, true);
}
}
}
break;
case R_USE_KEEP_CONNECT:
if (IsChecked(hWnd, R_USE_KEEP_CONNECT))
{
FocusEx(hWnd, E_HOSTNAME);
}
break;
case R_ALPHA:
if (IsChecked(hWnd, R_ALPHA))
{
FocusEx(hWnd, E_ALPHA_VALUE);
}
break;
}
break;
case WM_CLOSE:
EndDialog(hWnd, false);
break;
}
return 0;
}
// Create a shortcut
void CmSortcut(HWND hWnd, wchar_t *account_name)
{
wchar_t tmp[MAX_SIZE];
CM_ACCOUNT *a;
wchar_t *filename;
UCHAR key[SHA1_SIZE];
// Validate arguments
if (hWnd == NULL || account_name == NULL)
{
return;
}
// Get the account information
a = CmGetExistAccountObject(hWnd, account_name);
if (a == NULL)
{
return;
}
Copy(key, a->ShortcutKey, SHA1_SIZE);
if (IsZero(key, SHA1_SIZE))
{
MsgBox(hWnd, MB_ICONINFORMATION, _UU("CM_SHORTCUT_UNSUPPORTED"));
}
else
{
// Determine the file name
UniFormat(tmp, sizeof(tmp), L"%s.lnk", account_name);
UniSafeFileName(tmp);
filename = SaveDlg(hWnd, _UU("CM_SHORTCUT_FILE"),
_UU("CM_SHORTCUT_SAVE_TITLE"), tmp, L".vpn");
if (filename != NULL)
{
char key_str[64];
wchar_t target[MAX_PATH];
wchar_t workdir[MAX_PATH];
wchar_t args[MAX_PATH];
wchar_t comment[MAX_SIZE];
wchar_t icon[MAX_PATH];
BinToStr(key_str, sizeof(key_str), key, SHA1_SIZE);
// Create a shortcut
UniStrCpy(target, sizeof(target), MsGetExeFileNameW());
UniStrCpy(workdir, sizeof(workdir), MsGetExeDirNameW());
StrToUni(args, sizeof(args), key_str);
UniFormat(comment, sizeof(comment), _UU("CM_SHORTCUT_COMMENT"), account_name);
UniStrCpy(icon, sizeof(icon), MsGetExeFileNameW());
if (CreateLink(filename, target, workdir, args, comment, icon, 1) == false)
{
MsgBox(hWnd, MB_ICONSTOP, _UU("CM_SHORTCUT_ERROR"));
}
Free(filename);
}
}
CmFreeAccountObject(hWnd, a);
}
// Export the account
void CmExportAccount(HWND hWnd, wchar_t *account_name)
{
wchar_t tmp[MAX_SIZE];
CM_ACCOUNT *a;
wchar_t *filename;
// Validate arguments
if (hWnd == NULL || account_name == NULL)
{
return;
}
// Get the account information
a = CmGetExistAccountObject(hWnd, account_name);
if (a == NULL)
{
return;
}
// Determine the file name
UniFormat(tmp, sizeof(tmp), L"%s.vpn", account_name);
UniSafeFileName(tmp);
filename = SaveDlg(hWnd, _UU("CM_ACCOUNT_SETTING_FILE"),
_UU("CM_ACCOUNT_SAVE_TITLE"), tmp, L".vpn");
if (filename != NULL)
{
RPC_CLIENT_CREATE_ACCOUNT t;
BUF *b;
BUF *b2;
wchar_t tmp[MAX_SIZE];
UCHAR *buf;
UINT buf_size;
UCHAR bom[] = {0xef, 0xbb, 0xbf, };
Zero(&t, sizeof(t));
t.ClientOption = a->ClientOption;
t.ClientAuth = a->ClientAuth;
t.StartupAccount = a->Startup;
t.CheckServerCert = a->CheckServerCert;
t.ServerCert = a->ServerCert;
t.ClientOption->FromAdminPack = false;
b = CiAccountToCfg(&t);
SeekBuf(b, 0, 0);
// Check whether the password is contained
if (CiHasAccountSensitiveInformation(b))
{
SeekBuf(b, 0, 0);
// Confirm that the user want to clear the password
if (MsgBox(hWnd, MB_YESNO | MB_ICONQUESTION, _UU("CM_ACCOUNT_MSG_SENSITIVE")) == IDYES)
{
// Erase
CiEraseSensitiveInAccount(b);
}
}
UniStrCpy(tmp, sizeof(tmp), filename);
b2 = NewBuf();
WriteBuf(b2, bom, sizeof(bom));
// Add a header part
buf_size = CalcUniToUtf8(_UU("CM_ACCOUNT_FILE_BANNER"));
buf = ZeroMalloc(buf_size + 32);
UniToUtf8(buf, buf_size, _UU("CM_ACCOUNT_FILE_BANNER"));
WriteBuf(b2, buf, StrLen((char *)buf));
WriteBuf(b2, b->Buf, b->Size);
SeekBuf(b2, 0, 0);
FreeBuf(b);
if (DumpBufW(b2, tmp) == false)
{
MsgBox(hWnd, MB_ICONSTOP, _UU("CM_FAILED_TO_SAVE_FILE"));
}
Free(filename);
FreeBuf(b2);
Free(buf);
}
CmFreeAccountObject(hWnd, a);
}
// Main process of importing account
void CmImportAccountMain(HWND hWnd, wchar_t *filename)
{
CmImportAccountMainEx(hWnd, filename, false);
}
void CmImportAccountMainEx(HWND hWnd, wchar_t *filename, bool overwrite)
{
wchar_t name[MAX_SIZE];
wchar_t tmp[MAX_SIZE];
BUF *b;
RPC_CLIENT_CREATE_ACCOUNT *t;
// Validate arguments
if (hWnd == NULL || filename == NULL)
{
return;
}
UniStrCpy(tmp, sizeof(tmp), filename);
b = ReadDumpW(tmp);
if (b == NULL)
{
MsgBox(hWnd, MB_ICONSTOP, _UU("CM_FAILED_TO_OPEN_FILE"));
return;
}
t = CiCfgToAccount(b);
if (t == NULL)
{
FreeBuf(b);
MsgBox(hWnd, MB_ICONEXCLAMATION, _UU("CM_ACCOUNT_PARSE_FAILED"));
return;
}
if (overwrite)
{
// If the same name already exists, remove it
if (LvSearchStr(hWnd, L_ACCOUNT, 0, t->ClientOption->AccountName) != INFINITE)
{
RPC_CLIENT_DELETE_ACCOUNT d;
RPC_CLIENT_GET_ACCOUNT get;
HWND h = cm->hEasyWnd == NULL ? hWnd : cm->hEasyWnd;
Zero(&d, sizeof(d));
UniStrCpy(d.AccountName, sizeof(d.AccountName), t->ClientOption->AccountName);
Zero(&get, sizeof(get));
UniStrCpy(get.AccountName, sizeof(get.AccountName), t->ClientOption->AccountName);
if (CcGetAccount(cm->Client, &get) == ERR_NO_ERROR)
{
// Inherit the information of some of the client option by getting
// the account information of the same name that already exists
if (get.ClientOption != NULL && get.ClientAuth != NULL)
{
CLIENT_OPTION *old_option = get.ClientOption;
CLIENT_AUTH *old_auth = get.ClientAuth;
// Inherit the connection parameters
t->ClientOption->ProxyType = old_option->ProxyType;
StrCpy(t->ClientOption->ProxyName, sizeof(t->ClientOption->ProxyName),
old_option->ProxyName);
t->ClientOption->ProxyPort = old_option->ProxyPort;
StrCpy(t->ClientOption->ProxyUsername, sizeof(t->ClientOption->ProxyUsername),
old_option->ProxyUsername);
StrCpy(t->ClientOption->ProxyPassword, sizeof(t->ClientOption->ProxyPassword),
old_option->ProxyPassword);
t->ClientOption->NumRetry = old_option->NumRetry;
t->ClientOption->RetryInterval = old_option->RetryInterval;
t->ClientOption->MaxConnection = old_option->MaxConnection;
t->ClientOption->UseEncrypt = old_option->UseEncrypt;
t->ClientOption->UseCompress = old_option->UseCompress;
t->ClientOption->HalfConnection = old_option->HalfConnection;
t->ClientOption->NoRoutingTracking = old_option->NoRoutingTracking;
StrCpy(t->ClientOption->DeviceName, sizeof(t->ClientOption->DeviceName),
old_option->DeviceName);
t->ClientOption->AdditionalConnectionInterval = old_option->AdditionalConnectionInterval;
t->ClientOption->ConnectionDisconnectSpan = old_option->ConnectionDisconnectSpan;
t->ClientOption->HideStatusWindow = old_option->HideStatusWindow;
t->ClientOption->RequireMonitorMode = old_option->RequireMonitorMode;
t->ClientOption->RequireBridgeRoutingMode = old_option->RequireBridgeRoutingMode;
t->ClientOption->DisableQoS = old_option->DisableQoS;
t->ClientOption->NoTls1 = old_option->NoTls1;
// Inherit the authentication data
CiFreeClientAuth(t->ClientAuth);
t->ClientAuth = CopyClientAuth(old_auth);
// Other Settings
t->StartupAccount = get.StartupAccount;
t->CheckServerCert = get.CheckServerCert;
if (t->ServerCert != NULL)
{
FreeX(t->ServerCert);
}
t->ServerCert = NULL;
if (get.ServerCert != NULL)
{
t->ServerCert = CloneX(get.ServerCert);
}
Copy(t->ShortcutKey, get.ShortcutKey, sizeof(t->ShortcutKey));
}
CiFreeClientGetAccount(&get);
}
if (CALL(h, CcDeleteAccount(cm->Client, &d)) == false)
{
CiFreeClientCreateAccount(t);
Free(t);
return;
}
CmRefreshAccountList(hWnd);
}
}
CmGenerateImportName(hWnd, name, sizeof(name), t->ClientOption->AccountName);
UniStrCpy(t->ClientOption->AccountName, sizeof(t->ClientOption->AccountName), name);
if (overwrite)
{
t->ClientOption->FromAdminPack = true;
}
CALL(hWnd, CcCreateAccount(cm->Client, t));
CiFreeClientCreateAccount(t);
Free(t);
FreeBuf(b);
if (overwrite)
{
// Start to connect the VPN
CmConnect(hWnd, name);
}
//MsgBoxEx(hWnd, MB_ICONINFORMATION, _UU("CM_IMPORT_MESSAGE"), filename, name);
}
// Import an account
void CmImportAccount(HWND hWnd)
{
wchar_t *filename;
wchar_t tmp[MAX_SIZE];
// Validate arguments
if (hWnd == NULL)
{
return;
}
// Open the file
filename = OpenDlg(hWnd, _UU("CM_ACCOUNT_SETTING_FILE"), _UU("CM_ACCOUNT_OPEN_TITLE"));
if (filename == NULL)
{
return;
}
UniStrCpy(tmp, sizeof(tmp), filename);
Free(filename);
CmImportAccountMain(hWnd, tmp);
}
// Create a copy of the account
void CmCopyAccount(HWND hWnd, wchar_t *account_name)
{
wchar_t tmp[MAX_SIZE];
CM_ACCOUNT *a;
RPC_CLIENT_CREATE_ACCOUNT c;
// Validate arguments
if (hWnd == NULL || account_name == NULL)
{
return;
}
CmGenerateCopyName(hWnd, tmp, sizeof(tmp), account_name);
// Get an account information
a = CmGetExistAccountObject(hWnd, account_name);
if (a == NULL)
{
return;
}
// Change the account name
UniStrCpy(a->ClientOption->AccountName, sizeof(a->ClientOption->AccountName), tmp);
// Write
Zero(&c, sizeof(c));
c.ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
Copy(c.ClientOption, a->ClientOption, sizeof(CLIENT_OPTION));
c.ClientAuth = CopyClientAuth(a->ClientAuth);
if (a->ServerCert)
{
c.ServerCert = CloneX(a->ServerCert);
}
c.CheckServerCert = a->CheckServerCert;
c.StartupAccount = false; // Don't copy the startup attribute
CALL(hWnd, CcCreateAccount(cm->Client, &c));
CiFreeClientCreateAccount(&c);
CmFreeAccountObject(hWnd, a);
}
// Update the Virtual LAN Card Name dialog
void CmNewVLanDlgUpdate(HWND hWnd)
{
bool ok = true;
char tmp[MAX_SIZE];
// Validate arguments
if (hWnd == NULL)
{
return;
}
GetTxtA(hWnd, E_NAME, tmp, sizeof(tmp));
if (IsSafeStr(tmp) == false)
{
ok = false;
}
if (SearchStrEx(tmp, " ", 0, false) != INFINITE)
{
ok = false;
}
Trim(tmp);
if (StrLen(tmp) == 0)
{
ok = false;
}
SetEnable(hWnd, IDOK, ok);
}
// Virtual LAN card name decision dialog procedure
UINT CmNewVLanDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
{
char *tmp = (char *)param;
char default_name[MAX_SIZE];
RPC_CLIENT_VERSION ver;
// Validate arguments
if (hWnd == NULL)
{
return 0;
}
switch (msg)
{
case WM_INITDIALOG:
LimitText(hWnd, E_NAME, cm->Client->Win9x ? MAX_DEVICE_NAME_LEN_9X : MAX_DEVICE_NAME_LEN);
FormatText(hWnd, S_INFO, cm->Client->Win9x ? MAX_DEVICE_NAME_LEN_9X : MAX_DEVICE_NAME_LEN);
Zero(&ver, sizeof(ver));
if (CcGetClientVersion(cm->Client, &ver) == ERR_NO_ERROR)
{
if (ver.IsVLanNameRegulated)
{
Show(hWnd, S_WIN8);
}
}
if (CiGetNextRecommendedVLanName(cm->Client, default_name, sizeof(default_name)))
{
// Show a default virtual LAN card name candidate
SetTextA(hWnd, E_NAME, default_name);
}
CmNewVLanDlgUpdate(hWnd);
break;
case WM_COMMAND:
switch (wParam)
{
case IDOK:
if (cm->Client->Win9x)
{
// For Windows 9x, show a confirmation message
if (MsgBox(hWnd, MB_ICONQUESTION | MB_OKCANCEL, _UU("CM_9X_VLAN_INSTALL")) == IDCANCEL)
{
break;
}
}
GetTxtA(hWnd, E_NAME, tmp, (cm->Client->Win9x ? MAX_DEVICE_NAME_LEN_9X : MAX_DEVICE_NAME_LEN) + 1);
Trim(tmp);
if (CcGetClientVersion(cm->Client, &ver) == ERR_NO_ERROR)
{
if (ver.IsVLanNameRegulated)
{
if (CiIsValidVLanRegulatedName(tmp) == false)
{
// Virtual LAN card name isn't meeting the format
MsgBox(hWnd, MB_ICONEXCLAMATION, _UU("D_CM_NEW_VLAN@S_WIN8"));
FocusEx(hWnd, E_NAME);
break;
}
}
}
EndDialog(hWnd, true);
break;
case IDCANCEL:
Close(hWnd);
break;
}
switch (LOWORD(wParam))
{
case E_NAME:
CmNewVLanDlgUpdate(hWnd);
break;
case R_USE_DISCONNECT:
if (IsChecked(hWnd, R_USE_DISCONNECT))
{
FocusEx(hWnd, E_DISCONNECT_SPAN);
}
break;
}
break;
case WM_CLOSE:
EndDialog(hWnd, false);
break;
}
return 0;
}
// Dialog to determine the new virtual LAN card name
char *CmNewVLanDlg(HWND hWnd)
{
char tmp[MAX_DEVICE_NAME_LEN + 1];
if (Dialog(hWnd, D_CM_NEW_VLAN, CmNewVLanDlgProc, tmp) == false)
{
return NULL;
}
return CopyStr(tmp);
}
// Update the advanced settings dialog
void CmDetailDlgUpdate(HWND hWnd, CM_ACCOUNT *a)
{
bool ok = true;
bool locked;
// Validate arguments
if (hWnd == NULL || a == NULL)
{
return;
}
locked = a->LockMode;
if (a->LinkMode || a->NatMode)
{
Disable(hWnd, R_NO_ROUTING);
}
else
{
if (cm->Client->Unix)
{
Disable(hWnd, R_NO_ROUTING);
}
}
SetEnable(hWnd, E_DISCONNECT_SPAN, IsChecked(hWnd, R_USE_DISCONNECT));
SetEnable(hWnd, IDOK, ok);
if (locked)
{
Disable(hWnd, C_NUM_TCP);
Disable(hWnd, S_STATIC5);
Disable(hWnd, S_STATIC8);
Disable(hWnd, E_INTERVAL);
Disable(hWnd, S_STATIC9);
Disable(hWnd, E_DISCONNECT_SPAN);
Disable(hWnd, S_STATIC10);
Disable(hWnd, S_STATIC11);
Disable(hWnd, R_USE_DISCONNECT);
Disable(hWnd, R_USE_HALF_CONNECTION);
Disable(hWnd, R_DISABLE_QOS);
Disable(hWnd, R_USE_ENCRYPT);
Disable(hWnd, R_USE_COMPRESS);
Disable(hWnd, R_BRIDGE);
Disable(hWnd, R_MONITOR);
Disable(hWnd, R_NO_ROUTING);
}
}
// Advanced Settings dialog procedure
UINT CmDetailDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
{
CM_ACCOUNT *a = (CM_ACCOUNT *)param;
UINT i;
UINT num;
wchar_t tmp[MAX_SIZE];
// Validate arguments
if (hWnd == NULL)
{
return 0;
}
switch (msg)
{
case WM_INITDIALOG:
// Number of TCP connections
for (i = 1;i <= MAX_TCP_CONNECTION;i++)
{
UniFormat(tmp, sizeof(tmp), L"%u", i);
CbAddStr(hWnd, C_NUM_TCP, tmp, i);
}
CbSelect(hWnd, C_NUM_TCP, a->ClientOption->MaxConnection);
// Connection establishment interval
SetInt(hWnd, E_INTERVAL, a->ClientOption->AdditionalConnectionInterval);
// Lifetime
SetIntEx(hWnd, E_DISCONNECT_SPAN, a->ClientOption->ConnectionDisconnectSpan);
Check(hWnd, R_USE_DISCONNECT, a->ClientOption->ConnectionDisconnectSpan != 0);
Check(hWnd, R_USE_HALF_CONNECTION, a->ClientOption->HalfConnection);
Check(hWnd, R_USE_ENCRYPT, a->ClientOption->UseEncrypt);
Check(hWnd, R_USE_COMPRESS, a->ClientOption->UseCompress);
Check(hWnd, R_NO_ROUTING, a->ClientOption->NoRoutingTracking);
Check(hWnd, R_DISABLE_QOS, a->ClientOption->DisableQoS);
Check(hWnd, R_DISABLE_UDP, a->ClientOption->NoUdpAcceleration);
// Select the Connection Mode
if (a->LinkMode == false)
{
Check(hWnd, R_BRIDGE, a->ClientOption->RequireBridgeRoutingMode);
Check(hWnd, R_MONITOR, a->ClientOption->RequireMonitorMode);
}
else
{
Check(hWnd, R_BRIDGE, true);
Check(hWnd, R_MONITOR, false);
SetText(hWnd, S_MODE, _UU("CM_DETAIL_MODE_LINK_STR"));
Disable(hWnd, R_BRIDGE);
Disable(hWnd, R_MONITOR);
}
CmDetailDlgUpdate(hWnd, a);
Focus(hWnd, IDOK);
break;
case WM_COMMAND:
switch (wParam)
{
case IDOK:
if (IsChecked(hWnd, R_USE_DISCONNECT) && GetInt(hWnd, E_DISCONNECT_SPAN) == 0)
{
MsgBox(hWnd, MB_ICONINFORMATION, _UU("CM_NO_DISCONNECT_SPAN"));
FocusEx(hWnd, E_DISCONNECT_SPAN);
break;
}
num = GetInt(hWnd, C_NUM_TCP);
if (num == 0)
{
break;
}
if (num == 1 && IsChecked(hWnd, R_USE_HALF_CONNECTION))
{
MsgBox(hWnd, MB_ICONINFORMATION, _UU("CM_HALF_MSG"));
Focus(hWnd, C_NUM_TCP);
break;
}
if (GetInt(hWnd, E_INTERVAL) < 1)
{
MsgBox(hWnd, MB_ICONINFORMATION, _UU("CM_TOO_SMALL_INTERVAL"));
Focus(hWnd, E_INTERVAL);
break;
}
a->ClientOption->MaxConnection = num;
a->ClientOption->AdditionalConnectionInterval = GetInt(hWnd, E_INTERVAL);
if (IsChecked(hWnd, R_USE_DISCONNECT) == false)
{
a->ClientOption->ConnectionDisconnectSpan = 0;
}
else
{
a->ClientOption->ConnectionDisconnectSpan = GetInt(hWnd, E_DISCONNECT_SPAN);
}
a->ClientOption->HalfConnection = IsChecked(hWnd, R_USE_HALF_CONNECTION);
a->ClientOption->UseEncrypt = IsChecked(hWnd, R_USE_ENCRYPT);
a->ClientOption->UseCompress = IsChecked(hWnd, R_USE_COMPRESS);
a->ClientOption->NoRoutingTracking = IsChecked(hWnd, R_NO_ROUTING);
a->ClientOption->DisableQoS = IsChecked(hWnd, R_DISABLE_QOS);
a->ClientOption->NoUdpAcceleration = IsChecked(hWnd, R_DISABLE_UDP);
if (a->LinkMode)
{
a->ClientOption->RequireBridgeRoutingMode = true;
a->ClientOption->RequireMonitorMode = false;
}
else
{
a->ClientOption->RequireBridgeRoutingMode = IsChecked(hWnd, R_BRIDGE);
a->ClientOption->RequireMonitorMode = IsChecked(hWnd, R_MONITOR);
}
EndDialog(hWnd, true);
break;
case IDCANCEL:
Close(hWnd);
break;
}
switch (LOWORD(wParam))
{
case C_NUM_TCP:
case E_INTERVAL:
case E_DISCONNECT_SPAN:
case R_USE_DISCONNECT:
case R_USE_HALF_CONNECTION:
CmDetailDlgUpdate(hWnd, a);
break;
}
switch (wParam)
{
case R_USE_DISCONNECT:
if (IsChecked(hWnd, R_USE_DISCONNECT))
{
FocusEx(hWnd, E_DISCONNECT_SPAN);
}
break;
}
break;
case WM_CLOSE:
EndDialog(hWnd, false);
break;
}
return 0;
}
// Advanced Settings dialog
bool CmDetailDlg(HWND hWnd, CM_ACCOUNT *a)
{
// Validate arguments
if (hWnd == NULL || a == NULL)
{
return false;
}
return Dialog(hWnd, D_CM_DETAIL, CmDetailDlgProc, a);
}
// Update the account editing dialog procedure
void CmEditAccountDlgUpdate(HWND hWnd, CM_ACCOUNT *a)
{
bool ok = true;
char str[MAX_SIZE];
bool locked;
// Validate arguments
if (hWnd == NULL || a == NULL)
{
return;
}
locked = a->LockMode;
if (a->Inited == false)
{
return;
}
if (a->EditMode)
{
Disable(hWnd, E_ACCOUNT_NAME);
}
// The name of connection settings
GetTxt(hWnd, E_ACCOUNT_NAME, a->ClientOption->AccountName, sizeof(a->ClientOption->AccountName));
UniTrim(a->ClientOption->AccountName);
// Host name
GetTxtA(hWnd, E_HOSTNAME, a->ClientOption->Hostname, sizeof(a->ClientOption->Hostname));
Trim(a->ClientOption->Hostname);
if (InStr(a->ClientOption->Hostname, "/tcp"))
{
Check(hWnd, R_DISABLE_NATT, true);
}
else
{
Check(hWnd, R_DISABLE_NATT, false);
}
SetEnable(hWnd, R_DISABLE_NATT, !IsEmptyStr(a->ClientOption->Hostname));
// Port number
a->ClientOption->Port = GetInt(hWnd, C_PORT);
// HUB name
GetTxtA(hWnd,C_HUBNAME, a->ClientOption->HubName, sizeof(a->ClientOption->HubName));
// Type of proxy
a->ClientOption->ProxyType = PROXY_DIRECT;
if (IsChecked(hWnd, R_HTTPS))
{
a->ClientOption->ProxyType = PROXY_HTTP;
}
if (IsChecked(hWnd, R_SOCKS))
{
a->ClientOption->ProxyType = PROXY_SOCKS;
}
// To validate the server certificate
a->CheckServerCert = IsChecked(hWnd, R_CHECK_CERT);
if (a->NatMode)
{
Disable(hWnd, R_CHECK_CERT);
Disable(hWnd, B_TRUST);
}
if (a->HideTrustCert)
{
Disable(hWnd, B_TRUST);
}
// Device name
StrCpy(a->ClientOption->DeviceName, sizeof(a->ClientOption->DeviceName), "");
if (LvIsSelected(hWnd, L_VLAN))
{
wchar_t *s = LvGetStr(hWnd, L_VLAN, LvGetSelected(hWnd, L_VLAN), 0);
if (s != NULL)
{
char str[MAX_SIZE];
UniToStr(str, sizeof(str), s);
CmPrintNameToVLanName(a->ClientOption->DeviceName, sizeof(a->ClientOption->DeviceName), str);
Free(s);
}
}
// User authentication
a->ClientAuth->AuthType = CbGetSelect(hWnd, C_TYPE);
GetTxtA(hWnd, E_USERNAME, a->ClientAuth->Username, sizeof(a->ClientAuth->Username));
Trim(a->ClientAuth->Username);
switch (a->ClientAuth->AuthType)
{
case CLIENT_AUTHTYPE_PASSWORD:
// Password authentication
GetTxtA(hWnd, E_PASSWORD, str, sizeof(str));
if (StrCmp(str, HIDDEN_PASSWORD) != 0)
{
HashPassword(a->ClientAuth->HashedPassword, a->ClientAuth->Username, str);
}
break;
case CLIENT_AUTHTYPE_PLAIN_PASSWORD:
// Plaintext password authentication
GetTxtA(hWnd, E_PASSWORD, str, sizeof(str));
if (StrCmp(str, HIDDEN_PASSWORD) != 0)
{
StrCpy(a->ClientAuth->PlainPassword, sizeof(a->ClientAuth->PlainPassword), str);
}
break;
}
// Reconnection option
if ((a->LinkMode || a->NatMode) || a->ClientAuth->AuthType == CLIENT_AUTHTYPE_SECURE)
{
Disable(hWnd, R_RETRY);
}
else
{
Enable(hWnd, R_RETRY);
}
if (IsChecked(hWnd, R_RETRY) == false)
{
a->ClientOption->NumRetry = 0;
}
else
{
if (IsChecked(hWnd, R_INFINITE))
{
a->ClientOption->NumRetry = INFINITE;
}
else
{
a->ClientOption->NumRetry = GetInt(hWnd, E_RETRY_NUM);
}
}
a->ClientOption->RetryInterval = GetInt(hWnd, E_RETRY_SPAN);
a->ClientOption->NoTls1 = IsChecked(hWnd, R_NOTLS1);
// Information determining
if (UniStrLen(a->ClientOption->AccountName) == 0 && a->NatMode == false)
{
ok = false;
}
if (StrLen(a->ClientOption->Hostname) == 0)
{
ok = false;
}
if (a->ClientOption->Port == 0 || a->ClientOption->Port >= 65536)
{
ok = false;
}
if (StrLen(a->ClientOption->HubName) == 0)
{
ok = false;
}
if (StrLen(a->ClientAuth->Username) == 0)
{
ok = false;
}
if (a->ClientAuth->AuthType == CLIENT_AUTHTYPE_CERT)
{
if (a->ClientAuth->ClientK == NULL || a->ClientAuth->ClientX == NULL)
{
ok = false;
}
}
if (a->ClientAuth->AuthType == CLIENT_AUTHTYPE_SECURE)
{
if (IsEmptyStr(a->ClientAuth->SecurePrivateKeyName) || IsEmptyStr(a->ClientAuth->SecurePublicCertName))
{
ok = false;
}
}
// Display update
if (IsChecked(hWnd, R_RETRY) && IsEnable(hWnd, R_RETRY))
{
if (a->LinkMode == false && a->NatMode == false)
{
Enable(hWnd, R_INFINITE);
Enable(hWnd, E_RETRY_SPAN);
Enable(hWnd, S_RETRY_SPAN_1);
Enable(hWnd, S_RETRY_SPAN_2);
}
else
{
Disable(hWnd, R_INFINITE);
Disable(hWnd, E_RETRY_SPAN);
Disable(hWnd, S_RETRY_SPAN_1);
Disable(hWnd, S_RETRY_SPAN_2);
}
if (IsChecked(hWnd, R_INFINITE) == false)
{
Enable(hWnd, E_RETRY_NUM);
Enable(hWnd, S_RETRY_NUM_1);
Enable(hWnd, S_RETRY_NUM_2);
if (GetInt(hWnd, E_RETRY_NUM) == 0)
{
ok = false;
}
}
else
{
Disable(hWnd, E_RETRY_NUM);
Disable(hWnd, S_RETRY_NUM_1);
Disable(hWnd, S_RETRY_NUM_2);
}
}
else
{
Disable(hWnd, E_RETRY_NUM);
Disable(hWnd, E_RETRY_SPAN);
Disable(hWnd, R_INFINITE);
Disable(hWnd, S_RETRY_NUM_1);
Disable(hWnd, S_RETRY_NUM_2);
Disable(hWnd, S_RETRY_SPAN_1);
Disable(hWnd, S_RETRY_SPAN_2);
}
if (a->NatMode == false)
{
if (a->ServerCert == NULL)
{
SetText(hWnd, B_SERVER_CERT, _UU("CM_SERVER_CERT_1"));
Disable(hWnd, B_VIEW_SERVER_CERT);
}
else
{
SetText(hWnd, B_SERVER_CERT, _UU("CM_SERVER_CERT_2"));
Enable(hWnd, B_VIEW_SERVER_CERT);
}
}
else
{
Disable(hWnd, B_VIEW_SERVER_CERT);
Disable(hWnd, B_SERVER_CERT);
}
if (a->ClientAuth->AuthType == CLIENT_AUTHTYPE_CERT || a->ClientAuth->AuthType == CLIENT_AUTHTYPE_SECURE)
{
wchar_t tmp[MAX_SIZE * 2];
wchar_t issuer[MAX_SIZE];
wchar_t subject[MAX_SIZE];
wchar_t expires[MAX_SIZE];
SetIcon(hWnd, S_CERT, (a->ClientAuth->AuthType == CLIENT_AUTHTYPE_CERT) ? ICO_CERT : ICO_SECURE);
Hide(hWnd, S_PASSWORD);
Hide(hWnd, E_PASSWORD);
if (a->ClientAuth->AuthType == CLIENT_AUTHTYPE_CERT)
{
if (a->ClientAuth->ClientX != NULL)
{
Enable(hWnd, B_VIEW_CLIENT_CERT);
SetText(hWnd, B_REGIST_CLIENT_CERT, _UU("CM_CLIENT_CERT_2"));
GetPrintNameFromName(issuer, sizeof(issuer), a->ClientAuth->ClientX->issuer_name);
GetPrintNameFromName(subject, sizeof(subject), a->ClientAuth->ClientX->subject_name);
GetDateStrEx64(expires, sizeof(expires), SystemToLocal64(a->ClientAuth->ClientX->notAfter), NULL);
UniFormat(tmp, sizeof(tmp), _UU("CM_CERT_INFO"), subject, issuer, expires);
}
else
{
Disable(hWnd, B_VIEW_CLIENT_CERT);
SetText(hWnd, B_REGIST_CLIENT_CERT, _UU("CM_CLIENT_CERT_1"));
UniStrCpy(tmp, sizeof(tmp), _UU("CM_NO_CERT"));
}
SetText(hWnd, B_VIEW_CLIENT_CERT, _UU("CM_VIEW_CLIENT_CERT"));
Enable(hWnd, B_REGIST_CLIENT_CERT);
}
else
{
if (IsEmptyStr(a->ClientAuth->SecurePrivateKeyName) || IsEmptyStr(a->ClientAuth->SecurePublicCertName))
{
UniStrCpy(tmp, sizeof(tmp), _UU("CM_NO_SECURE"));
}
else
{
UniFormat(tmp, sizeof(tmp), _UU("CM_CERT_SECURE_INFO"),
a->ClientAuth->SecurePublicCertName, a->ClientAuth->SecurePrivateKeyName);
}
SetText(hWnd, B_VIEW_CLIENT_CERT, _UU("CM_SELECT_SECURE_DEVICE"));
SetText(hWnd, B_REGIST_CLIENT_CERT, _UU("CM_SELECT_CERT_INCARD"));
Enable(hWnd, B_VIEW_CLIENT_CERT);
if (SmGetCurrentSecureIdFromReg() == 0)
{
Disable(hWnd, B_REGIST_CLIENT_CERT);
}
else
{
Enable(hWnd, B_REGIST_CLIENT_CERT);
}
}
SetText(hWnd, S_CERT_INFO, tmp);
Show(hWnd, S_CERT);
Show(hWnd, S_CERT_INFO);
Show(hWnd, B_VIEW_CLIENT_CERT);
Show(hWnd, B_REGIST_CLIENT_CERT);
}
else
{
if (a->ClientAuth->AuthType == CLIENT_AUTHTYPE_ANONYMOUS)
{
Hide(hWnd, S_PASSWORD);
Hide(hWnd, E_PASSWORD);
}
else
{
Show(hWnd, S_PASSWORD);
Show(hWnd, E_PASSWORD);
}
Hide(hWnd, S_CERT);
Hide(hWnd, S_CERT_INFO);
Hide(hWnd, B_VIEW_CLIENT_CERT);
Hide(hWnd, B_REGIST_CLIENT_CERT);
}
if (a->ClientOption->ProxyType != PROXY_DIRECT)
{
Enable(hWnd, B_PROXY_CONFIG);
if (StrLen(a->ClientOption->ProxyName) == 0)
{
ok = false;
}
if (a->ClientOption->ProxyPort == 0)
{
ok = false;
}
}
else
{
Disable(hWnd, B_PROXY_CONFIG);
}
if (a->ClientAuth->AuthType == CLIENT_AUTHTYPE_PASSWORD)
{
bool b = true;
if (ok == false)
{
b = false;
}
if (a->LinkMode == false && a->NatMode == false)
{
SetEnable(hWnd, B_CHANGE_PASSWORD, b);
SetEnable(hWnd, S_CHANGE_PASSWORD, b);
Show(hWnd, B_CHANGE_PASSWORD);
Show(hWnd, S_CHANGE_PASSWORD);
}
else
{
Hide(hWnd, B_CHANGE_PASSWORD);
Hide(hWnd, S_CHANGE_PASSWORD);
}
}
else
{
Hide(hWnd, B_CHANGE_PASSWORD);
Hide(hWnd, S_CHANGE_PASSWORD);
}
if ((StrLen(a->ClientOption->DeviceName) == 0) && (a->LinkMode == false && a->NatMode == false))
{
ok = false;
}
if (a->LinkMode || a->NatMode)
{
Disable(hWnd, L_VLAN);
}
if (a->EditMode == false)
{
char tmp[MAX_SIZE];
GetTxtA(hWnd, E_HOSTNAME, tmp, sizeof(tmp));
Trim(tmp);
if (StartWith(tmp, "127.") || (StrCmpi(tmp, "localhost") == 0))
{
if (a->Flag1 == false)
{
a->Flag1 = true;
a->ClientOption->UseEncrypt = a->ClientOption->UseCompress = false;
a->ClientOption->MaxConnection = 1;
}
}
}
a->ClientOption->HideStatusWindow = IsChecked(hWnd, R_HIDE);
a->ClientOption->HideNicInfoWindow = IsChecked(hWnd, R_HIDE2);
if (locked)
{
SetEnable(hWnd, E_HOSTNAME, false);
SetEnable(hWnd, C_PORT, false);
SetEnable(hWnd, C_HUBNAME, false);
SetEnable(hWnd, S_STATIC2, false);
SetEnable(hWnd, S_STATIC3, false);
SetEnable(hWnd, S_STATIC4, false);
SetEnable(hWnd, S_STATIC5, false);
SetEnable(hWnd, S_STATIC66, false);
SetEnable(hWnd, S_STATIC7, false);
SetEnable(hWnd, S_STATIC11, false);
SetEnable(hWnd, R_CHECK_CERT, false);
SetEnable(hWnd, B_TRUST, false);
SetEnable(hWnd, B_SERVER_CERT, false);
SetEnable(hWnd, B_VIEW_SERVER_CERT, false);
SetEnable(hWnd, R_RETRY, false);
SetEnable(hWnd, S_RETRY_NUM_1, false);
SetEnable(hWnd, E_RETRY_NUM, false);
SetEnable(hWnd, S_RETRY_NUM_2, false);
SetEnable(hWnd, S_RETRY_SPAN_1, false);
SetEnable(hWnd, E_RETRY_SPAN, false);
SetEnable(hWnd, S_RETRY_SPAN_2, false);
SetEnable(hWnd, R_INFINITE, false);
}
SetEnable(hWnd, IDOK, ok);
}
// Initialize the account editing dialog
void CmEditAccountDlgInit(HWND hWnd, CM_ACCOUNT *a)
{
RPC_CLIENT_ENUM_VLAN v;
UINT i;
// Validate arguments
if (hWnd == NULL || a == NULL)
{
return;
}
if (a->LockMode)
{
SetText(hWnd, S_STATIC1, _UU("CM_EASY_ACCOUNT_WARNING"));
}
// Connection settings name
if (a->EditMode || a->NatMode)
{
Disable(hWnd, E_ACCOUNT_NAME);
}
if (a->NatMode || a->LinkMode)
{
Hide(hWnd, R_HIDE);
Hide(hWnd, R_HIDE2);
}
Check(hWnd, R_HIDE, a->ClientOption->HideStatusWindow);
Check(hWnd, R_HIDE2, a->ClientOption->HideNicInfoWindow);
if (a->NatMode)
{
Hide(hWnd, E_ACCOUNT_NAME);
Hide(hWnd, S_ACCOUNT_NAME);
}
if ((cm != NULL && cm->server_name != NULL) || a->LinkMode)
{
Hide(hWnd, B_IE);
}
SetText(hWnd, E_ACCOUNT_NAME, a->ClientOption->AccountName);
// Host name
SetTextA(hWnd, E_HOSTNAME, a->ClientOption->Hostname);
StrCpy(a->old_server_name, sizeof(a->old_server_name), a->ClientOption->Hostname);
if (InStr(a->ClientOption->Hostname, "/tcp"))
{
Check(hWnd, R_DISABLE_NATT, true);
}
else
{
Check(hWnd, R_DISABLE_NATT, false);
}
// Port number
CbSetHeight(hWnd, C_PORT, 18);
CbAddStr(hWnd, C_PORT, _UU("CM_PORT_1"), 0);
CbAddStr(hWnd, C_PORT, _UU("CM_PORT_2"), 0);
CbAddStr(hWnd, C_PORT, _UU("CM_PORT_3"), 0);
CbAddStr(hWnd, C_PORT, _UU("CM_PORT_4"), 0);
SetInt(hWnd, C_PORT, a->ClientOption->Port);
// Virtual HUB name
CbSetHeight(hWnd, C_HUBNAME, 18);
SetTextA(hWnd, C_HUBNAME, a->ClientOption->HubName);
// Type of proxy
Check(hWnd, R_DIRECT_TCP, a->ClientOption->ProxyType == PROXY_DIRECT);
Check(hWnd, R_HTTPS, a->ClientOption->ProxyType == PROXY_HTTP);
Check(hWnd, R_SOCKS, a->ClientOption->ProxyType == PROXY_SOCKS);
// Verify the server certificate
Check(hWnd, R_CHECK_CERT, a->CheckServerCert);
// LAN card list
if (a->NatMode == false && a->LinkMode == false)
{
Zero(&v, sizeof(v));
CcEnumVLan(cm->Client, &v);
LvInit(hWnd, L_VLAN);
LvInsertColumn(hWnd, L_VLAN, 0, L"DeviceName", 345);
for (i = 0;i < v.NumItem;i++)
{
wchar_t tmp[MAX_SIZE];
char str[MAX_SIZE];
CmVLanNameToPrintName(str, sizeof(str), v.Items[i]->DeviceName);
StrToUni(tmp, sizeof(tmp), str);
LvInsert(hWnd, L_VLAN, ICO_NIC_ONLINE, NULL, 1, tmp);
}
// LvAutoSize(hWnd, L_VLAN);
if (v.NumItem == 1)
{
// If only one virtual LAN card exists, initially select it
LvSelect(hWnd, L_VLAN, 0);
}
CiFreeClientEnumVLan(&v);
}
// Select the LAN card
if (StrLen(a->ClientOption->DeviceName) != 0)
{
char str[MAX_SIZE];
wchar_t tmp[MAX_SIZE];
UINT index;
CmVLanNameToPrintName(str, sizeof(str), a->ClientOption->DeviceName);
StrToUni(tmp, sizeof(tmp), str);
index = LvSearchStr(hWnd, L_VLAN, 0, tmp);
if (index != INFINITE)
{
LvSelect(hWnd, L_VLAN, index);
}
}
// Authentication type
CbSetHeight(hWnd, C_TYPE, 18);
CbAddStr(hWnd, C_TYPE, _UU("PW_TYPE_0"), CLIENT_AUTHTYPE_ANONYMOUS);
CbAddStr(hWnd, C_TYPE, _UU("PW_TYPE_1"), CLIENT_AUTHTYPE_PASSWORD);
CbAddStr(hWnd, C_TYPE, _UU("PW_TYPE_2"), CLIENT_AUTHTYPE_PLAIN_PASSWORD);
if (a->HideClientCertAuth == false)
{
// Certificate authentication is not available when HideClientCertAuth is true
CbAddStr(hWnd, C_TYPE, _UU("PW_TYPE_3"), CLIENT_AUTHTYPE_CERT);
}
if (a->HideSecureAuth == false)
{
// Authentication using a smart card
CbAddStr(hWnd, C_TYPE, _UU("PW_TYPE_4"), CLIENT_AUTHTYPE_SECURE);
}
// Select an authentication
CbSelect(hWnd, C_TYPE, a->ClientAuth->AuthType);
// User name
SetTextA(hWnd, E_USERNAME, a->ClientAuth->Username);
// Password
if (a->EditMode)
{
SetTextA(hWnd, E_PASSWORD, HIDDEN_PASSWORD);
}
// Reconnection times
if (a->ClientOption->NumRetry == 0)
{
Check(hWnd, R_RETRY, false);
}
else
{
Check(hWnd, R_RETRY, true);
if (a->ClientOption->NumRetry == INFINITE)
{
Check(hWnd, R_INFINITE, true);
}
else
{
Check(hWnd, R_INFINITE, false);
SetInt(hWnd, E_RETRY_NUM, a->ClientOption->NumRetry);
}
}
SetIntEx(hWnd, E_RETRY_SPAN, a->ClientOption->RetryInterval);
Check(hWnd, R_NOTLS1, a->ClientOption->NoTls1);
// Title
if (a->NatMode == false)
{
if (a->EditMode == false)
{
SetText(hWnd, 0, _UU("CM_ACCOUNT_TITLE_1"));
FocusEx(hWnd, E_ACCOUNT_NAME);
}
else
{
SetText(hWnd, 0, _UU("CM_ACCOUNT_TITLE_2"));
FormatText(hWnd, 0, a->ClientOption->AccountName);
FocusEx(hWnd, E_HOSTNAME);
}
}
else
{
SetText(hWnd, 0, _UU("NM_ACCOUNT_TITLE"));
FocusEx(hWnd, E_HOSTNAME);
}
if (a->LinkMode || a->NatMode)
{
Hide(hWnd, L_VLAN);
if (a->NatMode == false)
{
SetText(hWnd, S_VLAN_GROUP, _UU("SM_LINK_POLICY_GROUP"));
Show(hWnd, S_POLICY_1);
Show(hWnd, S_POLICY_2);
Show(hWnd, B_POLICY);
}
else
{
Hide(hWnd, S_VLAN_GROUP);
Show(hWnd, S_ROUTER_LOGO);
}
}
// Display update
a->Inited = true;
CmEditAccountDlgUpdate(hWnd, a);
}
// Account editing dialog procedure
UINT CmEditAccountDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
{
CM_ACCOUNT *a = (CM_ACCOUNT *)param;
NMHDR *n;
X *x;
K *k;
char tmp[MAX_PATH];
bool no_update_natt_check = false;
// Validate arguments
if (hWnd == NULL)
{
return 0;
}
switch (msg)
{
case WM_INITDIALOG:
CmEditAccountDlgInit(hWnd, a);
if (a->EditMode == false && a->LinkMode == false && a->NatMode == false)
{
SetTimer(hWnd, 1, 100, NULL);
}
break;
case WM_TIMER:
switch (wParam)
{
case 1:
{
CM_INTERNET_SETTING s;
KillTimer(hWnd, 1);
Zero(&s, sizeof(s));
CmGetSystemInternetSetting(&s);
if (s.ProxyType != PROXY_DIRECT)
{
if (MsgBoxEx(hWnd, MB_ICONQUESTION | MB_YESNO,
_UU("CM_WOULDYOULOAD_IE_PROXY"),
s.ProxyHostName) == IDYES)
{
Command(hWnd, B_IE);
}
}
}
break;
}
break;
case WM_COMMAND:
switch (wParam)
{
case R_DISABLE_NATT:
Zero(tmp, sizeof(tmp));
GetTxtA(hWnd, E_HOSTNAME, tmp, sizeof(tmp));
if (IsChecked(hWnd, R_DISABLE_NATT))
{
if (InStr(tmp, "/tcp") == false)
{
Trim(tmp);
StrCat(tmp, sizeof(tmp), "/tcp");
SetTextA(hWnd, E_HOSTNAME, tmp);
}
}
else
{
if (InStr(tmp, "/tcp"))
{
UINT i = SearchStrEx(tmp, "/tcp", 0, false);
if (i != INFINITE)
{
tmp[i] = 0;
Trim(tmp);
SetTextA(hWnd, E_HOSTNAME, tmp);
}
}
}
CmEditAccountDlgStartEnumHub(hWnd, a);
break;
}
switch (LOWORD(wParam))
{
case E_ACCOUNT_NAME:
case E_HOSTNAME:
case C_PORT:
case C_HUBNAME:
case R_DIRECT_TCP:
case R_HTTPS:
case R_SOCKS:
case R_CHECK_CERT:
case C_TYPE:
case E_USERNAME:
case E_PASSWORD:
case R_RETRY:
case E_RETRY_NUM:
case E_RETRY_SPAN:
case R_INFINITE:
CmEditAccountDlgUpdate(hWnd, a);
break;
}
switch (HIWORD(wParam))
{
case EN_KILLFOCUS:
switch (LOWORD(wParam))
{
case E_HOSTNAME:
CmEditAccountDlgStartEnumHub(hWnd, a);
break;
}
break;
case BN_KILLFOCUS:
switch (LOWORD(wParam))
{
case R_DIRECT_TCP:
case R_HTTPS:
case R_SOCKS:
CmEditAccountDlgStartEnumHub(hWnd, a);
break;
}
break;
case CBN_KILLFOCUS:
switch (LOWORD(wParam))
{
case C_PORT:
CmEditAccountDlgStartEnumHub(hWnd, a);
break;
}
break;
case BN_PUSHED:
switch (LOWORD(wParam))
{
case R_DISABLE_NATT:
break;
}
break;
}
if (HIWORD(wParam) == 0)
{
CmEditAccountDlgUpdate(hWnd, a);
}
switch (wParam)
{
case B_POLICY:
// Policy
if (a->LinkMode || a->NatMode)
{
a->Policy.Access = true;
a->Policy.MonitorPort = false;
SmPolicyDlgEx2(hWnd, &a->Policy, _UU("SM_LINK_POLICY_CAPTION"), true, a->PolicyVer);
a->Policy.Access = true;
a->Policy.MonitorPort = false;
}
break;
case IDOK:
CmEditAccountDlgUpdate(hWnd, a);
CmEditAccountDlgOnOk(hWnd, a);
break;
case IDCANCEL:
Close(hWnd);
break;
case B_PROXY_CONFIG:
// Proxy Settings
if (CmProxyDlg(hWnd, a->ClientOption))
{
UINT n = GetInt(hWnd, C_PORT);
if (a->ClientOption->ProxyType == PROXY_HTTP &&
n != 443)
{
// Show a warning message if the destination port is
// other than 443 and HTTP proxy is used
if (MsgBoxEx(hWnd, MB_ICONQUESTION | MB_YESNO, _UU("CM_HTTP_PROXY_WARNING"), n) == IDYES)
{
// Change the port number to 443
SetText(hWnd, C_PORT, _UU("CM_PORT_2"));
}
}
CmEditAccountDlgStartEnumHub(hWnd, a);
CmEditAccountDlgUpdate(hWnd, a);
}
break;
case B_IE:
// Use the IE settings
if(cm->server_name == NULL)
{
CmProxyDlgUseForIE(hWnd, a->ClientOption);
CmEditAccountDlgUpdate(hWnd, a);
MsgBox(hWnd, MB_ICONINFORMATION, _UU("CM_PROXY_FROM_IE"));
}
break;
case B_TRUST:
// CA
if (a->LinkMode == false)
{
CmTrustDlg(hWnd);
}
else
{
SmCaDlg(hWnd, a->Hub);
}
break;
case B_SERVER_CERT:
// Server certificate registration / delete
if (a->ServerCert == NULL)
{
if (CmLoadXFromFileOrSecureCard(hWnd, &x))
{
a->ServerCert = x;
CmEditAccountDlgUpdate(hWnd, a);
}
}
else
{
if (MsgBox(hWnd, MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2, _UU("CM_DELETE_SERVER_CERT")) == IDYES)
{
FreeX(a->ServerCert);
a->ServerCert = NULL;
CmEditAccountDlgUpdate(hWnd, a);
}
}
break;
case B_VIEW_SERVER_CERT:
// Show the server certificate
if (a->ServerCert != NULL)
{
X *issuer = CmGetIssuer(a->ServerCert);
CertDlg(hWnd, a->ServerCert, issuer, true);
FreeX(issuer);
}
break;
case B_VIEW_CLIENT_CERT:
if (a->ClientAuth->AuthType != CLIENT_AUTHTYPE_SECURE)
{
// Show the client certificate
if (a->ClientAuth->ClientX != NULL)
{
X *issuer = CmGetIssuer(a->ClientAuth->ClientX);
CertDlg(hWnd, a->ClientAuth->ClientX, issuer, true);
FreeX(issuer);
}
}
else
{
UINT id;
// Select the type of smart card
SmSelectSecureId(hWnd);
id = SmGetCurrentSecureIdFromReg();
if (id != 0)
{
if (cm->server_name == NULL)
{
RPC_USE_SECURE t;
Zero(&t, sizeof(t));
t.DeviceId = id;
CcUseSecure(cm->Client, &t);
}
}
CmEditAccountDlgUpdate(hWnd, a);
}
break;
case B_REGIST_CLIENT_CERT:
if (a->ClientAuth->AuthType != CLIENT_AUTHTYPE_SECURE)
{
// Client certificate registration / deletion
if (a->ClientAuth->ClientX == NULL)
{
if (CmLoadXAndK(hWnd, &x, &k))
{
a->ClientAuth->ClientX = x;
a->ClientAuth->ClientK = k;
CmEditAccountDlgUpdate(hWnd, a);
}
}
else
{
if (MsgBox(hWnd, MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2, _UU("CM_DELETE_CLIENT_CERT")) == IDYES)
{
FreeX(a->ClientAuth->ClientX);
FreeK(a->ClientAuth->ClientK);
a->ClientAuth->ClientX = NULL;
a->ClientAuth->ClientK = NULL;
CmEditAccountDlgUpdate(hWnd, a);
}
}
}
else
{
char cert[MAX_SECURE_DEVICE_FILE_LEN + 1], priv[MAX_SECURE_DEVICE_FILE_LEN + 1];
// Select a certificate in the smart card
if (SmSelectKeyPairEx(hWnd, cert, sizeof(cert), priv, sizeof(priv), CmGetSecureBitmapId(a->ClientOption->Hostname)))
{
StrCpy(a->ClientAuth->SecurePublicCertName, sizeof(a->ClientAuth->SecurePublicCertName), cert);
StrCpy(a->ClientAuth->SecurePrivateKeyName, sizeof(a->ClientAuth->SecurePrivateKeyName), priv);
CmEditAccountDlgUpdate(hWnd, a);
}
}
break;
case B_DETAIL:
// Advanced communication settings
if (CmDetailDlg(hWnd, a))
{
CmEditAccountDlgUpdate(hWnd, a);
}
break;
case B_CHANGE_PASSWORD:
// Change the password
CmChangePassword(hWnd, a->ClientOption, a->ClientOption->HubName,
a->ClientAuth->Username);
break;
}
break;
case WM_CLOSE:
EndDialog(hWnd, false);
break;
case WM_NOTIFY:
n = (NMHDR *)lParam;
switch (n->idFrom)
{
case L_VLAN:
switch (n->code)
{
case LVN_ITEMCHANGED:
CmEditAccountDlgUpdate(hWnd, a);
break;
}
break;
}
break;
}
return 0;
}
// Update the proxy server settings
void CmProxyDlgUpdate(HWND hWnd, CLIENT_OPTION *a)
{
bool ok = true;
// Validate arguments
if (hWnd == NULL || a == NULL)
{
return;
}
if (IsEmpty(hWnd, E_HOSTNAME))
{
ok = false;
}
if (GetInt(hWnd, C_PORT) == 0)
{
ok = false;
}
SetEnable(hWnd, IDOK, ok);
}
// Proxy server settings dialog c
UINT CmProxyDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
{
CLIENT_OPTION *a = (CLIENT_OPTION *)param;
// Validate arguments
if (hWnd == NULL)
{
return 0;
}
switch (msg)
{
case WM_INITDIALOG:
SetTextA(hWnd, E_HOSTNAME, a->ProxyName);
CbSetHeight(hWnd, C_PORT, 18);
CbAddStr(hWnd, C_PORT, L"8080", 0);
CbAddStr(hWnd, C_PORT, L"1080", 0);
CbAddStr(hWnd, C_PORT, L"80", 0);
CbAddStr(hWnd, C_PORT, L"3128", 0);
CbAddStr(hWnd, C_PORT, L"443", 0);
CbAddStr(hWnd, C_PORT, L"9821", 0);
CbAddStr(hWnd, C_PORT, L"9801", 0);
SetIntEx(hWnd, C_PORT, a->ProxyPort);
SetTextA(hWnd, E_USERNAME, a->ProxyUsername);
SetTextA(hWnd, E_PASSWORD, a->ProxyPassword);
if (a->ProxyPort == 0)
{
if (a->ProxyType == PROXY_HTTP)
{
SetInt(hWnd, C_PORT, 8080);
}
else
{
SetInt(hWnd, C_PORT, 1080);
}
}
CmProxyDlgUpdate(hWnd, a);
break;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case E_HOSTNAME:
case C_PORT:
case E_USERNAME:
case E_PASSWORD:
CmProxyDlgUpdate(hWnd, a);
break;
}
switch (wParam)
{
case IDOK:
GetTxtA(hWnd, E_HOSTNAME, a->ProxyName, sizeof(a->ProxyName));
GetTxtA(hWnd, E_USERNAME, a->ProxyUsername, sizeof(a->ProxyUsername));
GetTxtA(hWnd, E_PASSWORD, a->ProxyPassword, sizeof(a->ProxyPassword));
a->ProxyPort = GetInt(hWnd, C_PORT);
EndDialog(hWnd, true);
break;
case IDCANCEL:
Close(hWnd);
break;
}
break;
case WM_CLOSE:
EndDialog(hWnd, false);
break;
}
return 0;
}
// Proxy server settings
bool CmProxyDlg(HWND hWnd, CLIENT_OPTION *a)
{
// Validate arguments
if (a == NULL)
{
return false;
}
return Dialog(hWnd, D_CM_PROXY, CmProxyDlgProc, a);
}
// Get issuer of the specified certificate if it is known
X *CmGetIssuer(X *x)
{
RPC_GET_ISSUER a;
X *ret;
// Validate arguments
if (x == NULL)
{
return NULL;
}
Zero(&a, sizeof(a));
a.x = CloneX(x);
if (CALLEX(cm->hMainWnd, CcGetIssuer(cm->Client, &a)) == 0)
{
ret = CloneX(a.issuer_x);
}
else
{
ret = NULL;
}
CiFreeGetIssuer(&a);
return ret;
}
// Initialize the dialog
void CmLoadXFromFileOrSecureCardDlgInit(HWND hWnd, CM_LOADX *p)
{
UINT current;
// Validate arguments
if (hWnd == NULL || p == NULL)
{
return;
}
current = MsRegReadInt(REG_CURRENT_USER, SECURE_MANAGER_KEY, "CertLoadSource");
Check(hWnd, R_FROM_FILE, current == 0);
Check(hWnd, R_FROM_SECURE, current != 0);
SetFont(hWnd, S_INFO, Font(0, true));
CmLoadXFromFileOrSecureCardDlgUpdate(hWnd, p);
}
// Update the dialog control
void CmLoadXFromFileOrSecureCardDlgUpdate(HWND hWnd, CM_LOADX *p)
{
SECURE_DEVICE *dev;
wchar_t tmp[MAX_SIZE];
bool ok = true;
// Validate arguments
if (hWnd == NULL || p == NULL)
{
return;
}
dev = GetSecureDevice(SmGetCurrentSecureIdFromReg());
if (dev == NULL)
{
UniStrCpy(tmp, sizeof(tmp), _UU("SEC_CURRENT_NO_DEVICE"));
}
else
{
UniFormat(tmp, sizeof(tmp), _UU("SEC_CURRENT_DEVICE"), dev->DeviceName);
}
SetText(hWnd, S_INFO, tmp);
if (IsChecked(hWnd, R_FROM_SECURE))
{
if (dev == NULL)
{
ok = false;
}
}
SetEnable(hWnd, IDOK, ok);
SetEnable(hWnd, B_SELECT, IsChecked(hWnd, R_FROM_SECURE));
SetEnable(hWnd, S_CERT, IsChecked(hWnd, R_FROM_SECURE));
SetEnable(hWnd, S_FILE, IsChecked(hWnd, R_FROM_FILE));
}
// Certificate reading selection dialog procedure
UINT CmLoadXFromFileOrSecureCardDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
{
CM_LOADX *p = (CM_LOADX *)param;
X *x;
UINT current;
// Validate arguments
if (hWnd == NULL)
{
return 0;
}
switch (msg)
{
case WM_INITDIALOG:
CmLoadXFromFileOrSecureCardDlgInit(hWnd, p);
break;
case WM_COMMAND:
switch (wParam)
{
case IDOK:
current = (IsChecked(hWnd, R_FROM_FILE)) ? 0 : 1;
MsRegWriteInt(REG_CURRENT_USER, SECURE_MANAGER_KEY, "CertLoadSource", current);
if (current == 0)
{
// From file
if (CmLoadX(hWnd, &x))
{
p->x = x;
EndDialog(hWnd, true);
}
}
else
{
// From the smart card
char name[MAX_SIZE];
// Select the certificate name in the card
if (SmSelectKeyPair(hWnd, name, sizeof(name), NULL, 0))
{
// Read
WINUI_SECURE_BATCH batch[] =
{
{WINUI_SECURE_READ_CERT, name, true, NULL, NULL, NULL, NULL, NULL, NULL},
};
// Do reading
if (SecureDeviceWindow(hWnd, batch, sizeof(batch) / sizeof(batch[0]), SmGetCurrentSecureIdFromReg(), 0))
{
// Success
p->x = batch[0].OutputX;
EndDialog(hWnd, true);
}
}
}
break;
case IDCANCEL:
Close(hWnd);
break;
case R_FROM_FILE:
CmLoadXFromFileOrSecureCardDlgUpdate(hWnd, p);
break;
case R_FROM_SECURE:
CmLoadXFromFileOrSecureCardDlgUpdate(hWnd, p);
break;
case B_SELECT:
SmSelectSecureId(hWnd);
CmLoadXFromFileOrSecureCardDlgUpdate(hWnd, p);
break;
}
break;
case WM_CLOSE:
EndDialog(hWnd, false);
break;
}
return 0;
}
// Read certificate from a file or a smart card
bool CmLoadXFromFileOrSecureCard(HWND hWnd, X **x)
{
CM_LOADX p;
// Validate arguments
if (x == NULL)
{
return false;
}
Zero(&p, sizeof(p));
if (Dialog(hWnd, D_CM_LOAD_X, CmLoadXFromFileOrSecureCardDlgProc, &p) == false)
{
return false;
}
*x = p.x;
return true;
}
// Read the certificate
bool CmLoadX(HWND hWnd, X **x)
{
return CmLoadXEx(hWnd, x, NULL, 0);
}
bool CmLoadXEx(HWND hWnd, X **x, char *filename, UINT size)
{
wchar_t *filename_w = CopyStrToUni(filename);
bool ret;
ret = CmLoadXExW(hWnd, x, filename_w, size);
Free(filename_w);
return ret;
}
bool CmLoadXExW(HWND hWnd, X **x, wchar_t *filename, UINT size)
{
wchar_t *s;
bool is_p12;
wchar_t tmp[MAX_SIZE];
K *k;
// Validate arguments
if (x == NULL)
{
return false;
}
// Read the certificate
s = OpenDlg(hWnd, _UU("DLG_CERT_OR_P12_FILTER"), _UU("DLG_OPEN_CERT"));
if (s == NULL)
{
return false;
}
UniStrCpy(tmp, sizeof(tmp), s);
if (filename != NULL)
{
UniStrCpy(filename, size, tmp);
}
Free(s);
if (UniEndWith(tmp, L".p12") || UniEndWith(tmp, L".pfx"))
{
is_p12 = true;
}
else
{
is_p12 = false;
}
if (is_p12)
{
// Processing of PKCS#12
BUF *b = ReadDumpW(tmp);
P12 *p12;
if (b == NULL)
{
MsgBoxEx(hWnd, MB_ICONSTOP, _UU("DLG_OPEN_FILE_ERROR_W"), tmp);
return false;
}
p12 = BufToP12(b);
if (p12 == NULL)
{
MsgBoxEx(hWnd, MB_ICONSTOP, _UU("DLG_BAD_P12_W"), tmp);
FreeBuf(b);
return false;
}
if (IsEncryptedP12(p12) == false)
{
if (ParseP12(p12, x, &k, NULL) == false)
{
MsgBoxEx(hWnd, MB_ICONSTOP, _UU("DLG_BAD_P12_W"), tmp);
FreeP12(p12);
FreeBuf(b);
return false;
}
}
else
{
char password[MAX_SIZE];
if (PassphraseDlg(hWnd, password, sizeof(password), b, true) == false)
{
FreeP12(p12);
FreeBuf(b);
return false;
}
else
{
if (ParseP12(p12, x, &k, password) == false)
{
MsgBoxEx(hWnd, MB_ICONSTOP, _UU("DLG_BAD_P12_W"), tmp);
FreeP12(p12);
FreeBuf(b);
return false;
}
}
}
FreeP12(p12);
FreeBuf(b);
FreeK(k);
return true;
}
else
{
// Processing of X509
BUF *b = ReadDumpW(tmp);
X *x509;
if (b == NULL)
{
MsgBoxEx(hWnd, MB_ICONSTOP, _UU("DLG_OPEN_FILE_ERROR_W"), tmp);
return false;
}
x509 = BufToX(b, IsBase64(b));
FreeBuf(b);
if (x509 == NULL)
{
MsgBoxEx(hWnd, MB_ICONSTOP, _UU("DLG_BAD_X509_W"), tmp);
return false;
}
*x = x509;
return true;
}
}
// Read the secret key
bool CmLoadK(HWND hWnd, K **k)
{
return CmLoadKEx(hWnd, k, NULL, 0);
}
bool CmLoadKEx(HWND hWnd, K **k, char *filename, UINT size)
{
wchar_t *filename_w = CopyStrToUni(filename);
bool ret;
ret = CmLoadKExW(hWnd, k, filename_w, size);
Free(filename_w);
return ret;
}
bool CmLoadKExW(HWND hWnd, K **k, wchar_t *filename, UINT size)
{
wchar_t *s;
bool is_p12;
wchar_t tmp[MAX_SIZE];
// Validate arguments
if (k == NULL)
{
return false;
}
// Read the certificate
s = OpenDlg(hWnd, _UU("DLG_KEY_OR_P12_FILTER"), _UU("DLG_OPEN_KEY"));
if (s == NULL)
{
return false;
}
UniStrCpy(tmp, sizeof(tmp), s);
Free(s);
if (filename != NULL)
{
UniStrCpy(filename, size, tmp);
}
if (UniEndWith(tmp, L".p12") || UniEndWith(tmp, L".pfx"))
{
is_p12 = true;
}
else
{
is_p12 = false;
}
if (is_p12)
{
// Processing of PKCS#12
BUF *b = ReadDumpW(tmp);
P12 *p12;
if (b == NULL)
{
MsgBoxEx(hWnd, MB_ICONSTOP, _UU("DLG_OPEN_FILE_ERROR_W"), tmp);
return false;
}
p12 = BufToP12(b);
if (p12 == NULL)
{
MsgBoxEx(hWnd, MB_ICONSTOP, _UU("DLG_BAD_P12_W"), tmp);
FreeBuf(b);
return false;
}
if (IsEncryptedP12(p12) == false)
{
X *x;
if (ParseP12(p12, &x, k, NULL) == false)
{
MsgBoxEx(hWnd, MB_ICONSTOP, _UU("DLG_BAD_P12_W"), tmp);
FreeP12(p12);
FreeBuf(b);
return false;
}
FreeX(x);
}
else
{
char password[MAX_SIZE];
if (PassphraseDlg(hWnd, password, sizeof(password), b, true) == false)
{
FreeP12(p12);
FreeBuf(b);
return false;
}
else
{
X *x;
if (ParseP12(p12, &x, k, password) == false)
{
MsgBoxEx(hWnd, MB_ICONSTOP, _UU("DLG_BAD_P12_W"), tmp);
FreeP12(p12);
FreeBuf(b);
return false;
}
FreeX(x);
}
}
FreeP12(p12);
FreeBuf(b);
return true;
}
else
{
// Processing of private key
BUF *b = ReadDumpW(tmp);
K *key;
if (b == NULL)
{
MsgBoxEx(hWnd, MB_ICONSTOP, _UU("DLG_OPEN_FILE_ERROR_W"), tmp);
return false;
}
if (IsEncryptedK(b, true) == false)
{
key = BufToK(b, true, IsBase64(b), NULL);
}
else
{
char pass[MAX_SIZE];
if (PassphraseDlg(hWnd, pass, sizeof(pass), b, false) == false)
{
FreeBuf(b);
return false;
}
key = BufToK(b, true, IsBase64(b), pass);
}
if (key == NULL)
{
FreeBuf(b);
MsgBoxEx(hWnd, MB_ICONSTOP, _UU("DLG_BAD_KEY_W"), tmp);
return false;
}
FreeBuf(b);
*k = key;
return true;
}
}
// Read a set of certificate and private key
bool CmLoadXAndK(HWND hWnd, X **x, K **k)
{
wchar_t *s;
bool is_p12;
wchar_t tmp[MAX_SIZE];
// Validate arguments
if (x == NULL || k == NULL)
{
return false;
}
START_FIRST:
// Read the certificate
s = OpenDlg(hWnd, _UU("DLG_CERT_OR_P12_FILTER"), _UU("DLG_OPEN_CERT"));
if (s == NULL)
{
return false;
}
UniStrCpy(tmp, sizeof(tmp), s);
Free(s);
if (UniEndWith(tmp, L".p12") || UniEndWith(tmp, L".pfx"))
{
is_p12 = true;
}
else
{
is_p12 = false;
}
if (is_p12)
{
// Processing of PKCS#12
BUF *b = ReadDumpW(tmp);
P12 *p12;
if (b == NULL)
{
MsgBoxEx(hWnd, MB_ICONSTOP, _UU("DLG_OPEN_FILE_ERROR_W"), tmp);
return false;
}
p12 = BufToP12(b);
if (p12 == NULL)
{
MsgBoxEx(hWnd, MB_ICONSTOP, _UU("DLG_BAD_P12_W"), tmp);
FreeBuf(b);
return false;
}
if (IsEncryptedP12(p12) == false)
{
if (ParseP12(p12, x, k, NULL) == false)
{
MsgBoxEx(hWnd, MB_ICONSTOP, _UU("DLG_BAD_P12_W"), tmp);
FreeP12(p12);
FreeBuf(b);
return false;
}
}
else
{
char password[MAX_SIZE];
if (PassphraseDlg(hWnd, password, sizeof(password), b, true) == false)
{
FreeP12(p12);
FreeBuf(b);
return false;
}
else
{
if (ParseP12(p12, x, k, password) == false)
{
MsgBoxEx(hWnd, MB_ICONSTOP, _UU("DLG_BAD_P12_W"), tmp);
FreeP12(p12);
FreeBuf(b);
return false;
}
}
}
if (CheckXandK(*x, *k) == false)
{
FreeX(*x);
FreeK(*k);
FreeP12(p12);
FreeBuf(b);
if (MsgBox(hWnd, MB_ICONEXCLAMATION | MB_RETRYCANCEL, _UU("DLG_BAD_SIGNATURE")) == IDRETRY)
{
goto START_FIRST;
}
return false;
}
FreeP12(p12);
FreeBuf(b);
return true;
}
else
{
// Processing of X509
BUF *b = ReadDumpW(tmp);
X *x509;
K *key;
if (b == NULL)
{
MsgBoxEx(hWnd, MB_ICONSTOP, _UU("DLG_OPEN_FILE_ERROR_W"), tmp);
return false;
}
x509 = BufToX(b, IsBase64(b));
FreeBuf(b);
if (x509 == NULL)
{
MsgBoxEx(hWnd, MB_ICONSTOP, _UU("DLG_BAD_X509_W"), tmp);
return false;
}
// Read the secret key
s = OpenDlg(hWnd, _UU("DLG_KEY_FILTER"), _UU("DLG_OPEN_KEY_WITH_CERT"));
if (s == NULL)
{
FreeX(x509);
return false;
}
UniStrCpy(tmp, sizeof(tmp), s);
Free(s);
b = ReadDumpW(tmp);
if (b == NULL)
{
MsgBoxEx(hWnd, MB_ICONSTOP, _UU("DLG_OPEN_FILE_ERROR_W"), tmp);
FreeX(x509);
return false;
}
if (IsEncryptedK(b, true) == false)
{
key = BufToK(b, true, IsBase64(b), NULL);
}
else
{
char pass[MAX_SIZE];
if (PassphraseDlg(hWnd, pass, sizeof(pass), b, false) == false)
{
FreeBuf(b);
FreeX(x509);
return false;
}
key = BufToK(b, true, IsBase64(b), pass);
}
if (key == NULL)
{
FreeBuf(b);
FreeX(x509);
MsgBoxEx(hWnd, MB_ICONSTOP, _UU("DLG_BAD_KEY_W"), tmp);
return false;
}
if (CheckXandK(x509, key) == false)
{
FreeBuf(b);
FreeX(x509);
FreeK(key);
if (MsgBox(hWnd, MB_ICONEXCLAMATION | MB_RETRYCANCEL, _UU("DLG_BAD_SIGNATURE")) == IDRETRY)
{
goto START_FIRST;
}
return false;
}
FreeBuf(b);
*x = x509;
*k = key;
return true;
}
}
// Virtual HUB enumeration start
void CmEditAccountDlgStartEnumHub(HWND hWnd, CM_ACCOUNT *a)
{
char server_name[MAX_HOST_NAME_LEN + 1];
UINT old_proxy_type;
// Validate arguments
if (hWnd == NULL || a == NULL)
{
return;
}
if (StrLen(a->ClientOption->Hostname) == 0)
{
return;
}
if (a->ClientOption->Port == 0)
{
return;
}
if (a->ClientOption->ProxyType != PROXY_DIRECT &&
(StrLen(a->ClientOption->ProxyName) == 0 ||
a->ClientOption->ProxyPort == 0))
{
return;
}
GetTxtA(hWnd, E_HOSTNAME, server_name, sizeof(server_name));
if (StrCmpi(server_name, a->old_server_name) == 0)
{
if (CbNum(hWnd, C_HUBNAME) != 0)
{
return;
}
}
else
{
StrCpy(a->old_server_name, sizeof(a->old_server_name), server_name);
CbReset(hWnd, C_HUBNAME);
}
old_proxy_type = a->ClientOption->ProxyType;
if (IsChecked(hWnd, R_DIRECT_TCP))
{
a->ClientOption->ProxyType = PROXY_DIRECT;
}
if (IsChecked(hWnd, R_HTTPS))
{
a->ClientOption->ProxyType = PROXY_HTTP;
}
if (IsChecked(hWnd, R_SOCKS))
{
a->ClientOption->ProxyType = PROXY_SOCKS;
}
CmEnumHubStart(hWnd, a->ClientOption);
a->ClientOption->ProxyType = old_proxy_type;
}
// [OK] button
void CmEditAccountDlgOnOk(HWND hWnd, CM_ACCOUNT *a)
{
RPC_CLIENT_CREATE_ACCOUNT c;
bool b;
// Validate arguments
if (hWnd == NULL || a == NULL)
{
return;
}
if (a->ClientOption->NumRetry != 0 && a->ClientOption->RetryInterval < 5)
{
MsgBox(hWnd, MB_ICONINFORMATION, _UU("CM_RETRY_INTERVAL_ERROR"));
FocusEx(hWnd, E_RETRY_SPAN);
return;
}
CmEditAccountDlgUpdate(hWnd, a);
if (a->LinkMode == false && a->NatMode == false)
{
// Save the account
Zero(&c, sizeof(c));
c.ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
Copy(c.ClientOption, a->ClientOption, sizeof(CLIENT_OPTION));
c.ClientAuth = CopyClientAuth(a->ClientAuth);
c.CheckServerCert = a->CheckServerCert;
if (a->ServerCert != NULL)
{
c.ServerCert = CloneX(a->ServerCert);
}
c.StartupAccount = a->Startup;
if (a->EditMode == false)
{
b = CALL(hWnd, CcCreateAccount(cm->Client, &c));
}
else
{
b = CALL(hWnd, CcSetAccount(cm->Client, &c));
}
CiFreeClientCreateAccount(&c);
// Check whether this account is currently running
if (b)
{
RPC_CLIENT_GET_CONNECTION_STATUS st;
Zero(&st, sizeof(st));
UniStrCpy(st.AccountName, sizeof(st.AccountName), a->ClientOption->AccountName);
if (CALL(hWnd, CcGetAccountStatus(cm->Client, &st)))
{
if (st.Active)
{
MsgBoxEx(hWnd, MB_ICONINFORMATION, _UU("CM_CURRENT_ACTIVE"),
st.AccountName);
}
}
}
if (b)
{
EndDialog(hWnd, true);
}
}
else
{
if (a->LinkMode)
{
// Link mode
RPC_CREATE_LINK t;
Zero(&t, sizeof(t));
StrCpy(t.HubName, sizeof(t.HubName), a->Hub->HubName);
t.Online = a->OnlineFlag;
Copy(&t.Policy, &a->Policy, sizeof(POLICY));
t.ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
Copy(t.ClientOption, a->ClientOption, sizeof(CLIENT_OPTION));
t.ClientAuth = CopyClientAuth(a->ClientAuth);
t.CheckServerCert = a->CheckServerCert;
t.ServerCert = CloneX(a->ServerCert);
// Save the settings for cascade connection
if (a->EditMode)
{
if (CALL(hWnd, ScSetLink(a->Hub->Rpc, &t)))
{
if (a->OnlineFlag)
{
MsgBoxEx(hWnd, MB_ICONINFORMATION, _UU("SM_LINK_SAVE_ONLINE"), a->ClientOption->AccountName);
}
EndDialog(hWnd, true);
}
}
else
{
if (CALL(hWnd, ScCreateLink(a->Hub->Rpc, &t)))
{
if (a->Link_ConnectNow)
{
RPC_LINK tt;
Zero(&tt, sizeof(tt));
UniStrCpy(tt.AccountName, sizeof(tt.AccountName), a->ClientOption->AccountName);
StrCpy(tt.HubName, sizeof(tt.HubName), a->Hub->HubName);
CALL(hWnd, ScSetLinkOnline(a->Hub->Rpc, &tt));
}
EndDialog(hWnd, true);
}
}
FreeRpcCreateLink(&t);
}
else
{
// NAT mode
RPC_CREATE_LINK t;
Zero(&t, sizeof(t));
t.ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
Copy(t.ClientOption, a->ClientOption, sizeof(CLIENT_OPTION));
t.ClientAuth = CopyClientAuth(a->ClientAuth);
if (CALL(hWnd, NcSetClientConfig(a->Rpc, &t)))
{
EndDialog(hWnd, true);
}
FreeRpcCreateLink(&t);
}
}
}
// Show the account editing dialog
bool CmEditAccountDlg(HWND hWnd, CM_ACCOUNT *a)
{
// Validate arguments
if (hWnd == NULL || a == NULL)
{
return false;
}
return Dialog(hWnd, D_CM_ACCOUNT, CmEditAccountDlgProc, a);
}
// Edit the account
void CmEditAccount(HWND hWnd, wchar_t *account_name)
{
CM_ACCOUNT *a;
// Validate arguments
if (hWnd == NULL || account_name == NULL)
{
return;
}
a = CmGetExistAccountObject(hWnd, account_name);
if (a == NULL)
{
return;
}
CmVoice("input_config");
if (CmEditAccountDlg(hWnd, a))
{
CmVoice("set_config");
}
CmFreeAccountObject(hWnd, a);
}
// Create an account
void CmNewAccount(HWND hWnd)
{
CM_ACCOUNT *a;
RPC_CLIENT_ENUM_VLAN t;
UINT num_vlan = 0;
// Validate arguments
if (hWnd == NULL)
{
return;
}
if (IsEnable(hWnd, 0) == false)
{
return;
}
Zero(&t, sizeof(t));
if (CcEnumVLan(cm->Client, &t) == ERR_NO_ERROR)
{
num_vlan = t.NumItem;
CiFreeClientEnumVLan(&t);
}
if (num_vlan == 0)
{
if (MsgBox(hWnd, MB_ICONINFORMATION | MB_YESNO, _UU("CM_NO_VLAN")) == IDNO)
{
return;
}
else
{
if (cm->server_name == NULL || cm->Client->Unix)
{
Command(hWnd, CMD_NEW_VLAN);
return;
}
else
{
MsgBox(hWnd, MB_ICONINFORMATION, _UU("CM_VLAN_REMOTE_ERROR"));
}
return;
}
}
a = CmCreateNewAccountObject(hWnd);
if (a == NULL)
{
return;
}
CmVoice("input_config");
if (CmEditAccountDlg(hWnd, a))
{
CmVoice("new_config");
}
CmFreeAccountObject(hWnd, a);
}
// Release the account object
void CmFreeAccountObject(HWND hWnd, CM_ACCOUNT *a)
{
// Validate arguments
if (hWnd == NULL || a == NULL)
{
return;
}
Free(a->ClientOption);
CiFreeClientAuth(a->ClientAuth);
if (a->ServerCert != NULL)
{
FreeX(a->ServerCert);
}
Free(a);
}
// Get an existing account object
CM_ACCOUNT *CmGetExistAccountObject(HWND hWnd, wchar_t *account_name)
{
RPC_CLIENT_GET_ACCOUNT c;
CM_ACCOUNT *a;
// Validate arguments
if (hWnd == NULL)
{
return NULL;
}
Zero(&c, sizeof(c));
UniStrCpy(c.AccountName, sizeof(c.AccountName), account_name);
if (CALL(hWnd, CcGetAccount(cm->Client, &c)) == false)
{
return NULL;
}
a = ZeroMalloc(sizeof(CM_ACCOUNT));
a->EditMode = true;
a->CheckServerCert = c.CheckServerCert;
a->Startup = c.StartupAccount;
if (c.ServerCert != NULL)
{
a->ServerCert = CloneX(c.ServerCert);
}
a->ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
Copy(a->ClientOption, c.ClientOption, sizeof(CLIENT_OPTION));
a->ClientAuth = CopyClientAuth(c.ClientAuth);
Copy(a->ShortcutKey, c.ShortcutKey, SHA1_SIZE);
CiFreeClientGetAccount(&c);
a->LockMode = cm->CmSetting.LockMode;
return a;
}
// Create a new account object
CM_ACCOUNT *CmCreateNewAccountObject(HWND hWnd)
{
CM_ACCOUNT *a;
// Validate arguments
if (hWnd == NULL)
{
return NULL;
}
a = ZeroMalloc(sizeof(CM_ACCOUNT));
a->EditMode = false;
a->CheckServerCert = false;
a->Startup = false;
a->ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
// Initialize the client options
CmGenerateNewAccountName(hWnd, a->ClientOption->AccountName, sizeof(a->ClientOption->AccountName));
a->ClientOption->Port = 443; // Default port number
a->ClientOption->NumRetry = INFINITE;
a->ClientOption->RetryInterval = 15;
a->ClientOption->MaxConnection = 1;
a->ClientOption->HalfConnection = false;
a->ClientOption->UseEncrypt = true;
a->ClientOption->AdditionalConnectionInterval = 1;
if (cm->Client->Unix)
{
a->ClientOption->NoRoutingTracking = true;
}
a->ClientAuth = ZeroMalloc(sizeof(CLIENT_AUTH));
// Password authentication
a->ClientAuth->AuthType = CLIENT_AUTHTYPE_PASSWORD;
return a;
}
// Create an imported account name
void CmGenerateImportName(HWND hWnd, wchar_t *name, UINT size, wchar_t *old_name)
{
UINT i;
// Validate arguments
if (name == NULL || hWnd == NULL)
{
return;
}
for (i = 1;;i++)
{
wchar_t tmp[MAX_SIZE];
if (i == 1)
{
UniFormat(tmp, sizeof(tmp), _UU("CM_IMPORT_NAME_1"), old_name);
}
else
{
UniFormat(tmp, sizeof(tmp), _UU("CM_IMPORT_NAME_2"), old_name, i);
}
if (LvSearchStr(hWnd, L_ACCOUNT, 0, tmp) == INFINITE)
{
UniStrCpy(name, size, tmp);
return;
}
}
}
// Create a copy name
void CmGenerateCopyName(HWND hWnd, wchar_t *name, UINT size, wchar_t *old_name)
{
UINT i;
// Validate arguments
if (name == NULL || hWnd == NULL)
{
return;
}
for (i = 1;;i++)
{
wchar_t tmp[MAX_SIZE];
if (i == 1)
{
UniFormat(tmp, sizeof(tmp), _UU("CM_COPY_NAME_1"), old_name);
}
else
{
UniFormat(tmp, sizeof(tmp), _UU("CM_COPY_NAME_2"), i, old_name);
}
if (LvSearchStr(hWnd, L_ACCOUNT, 0, tmp) == INFINITE)
{
UniStrCpy(name, size, tmp);
return;
}
}
}
// Create a new account name
void CmGenerateNewAccountName(HWND hWnd, wchar_t *name, UINT size)
{
UINT i;
// Validate arguments
if (name == NULL || hWnd == NULL)
{
return;
}
for (i = 1;;i++)
{
wchar_t tmp[MAX_SIZE];
if (i == 1)
{
UniFormat(tmp, sizeof(tmp), _UU("CM_NEW_ACCOUNT_NAME_1"));
}
else
{
UniFormat(tmp, sizeof(tmp), _UU("CM_NEW_ACCOUNT_NAME_2"), i);
}
if (LvSearchStr(hWnd, L_ACCOUNT, 0, tmp) == INFINITE)
{
UniStrCpy(name, size, tmp);
return;
}
}
}
// Show the policy list
void CmPolicyDlgPrint(HWND hWnd, CM_POLICY *p)
{
CmPolicyDlgPrintEx(hWnd, p, false);
}
void CmPolicyDlgPrintEx(HWND hWnd, CM_POLICY *p, bool cascade_mode)
{
CmPolicyDlgPrintEx2(hWnd, p, cascade_mode, POLICY_CURRENT_VERSION);
}
void CmPolicyDlgPrintEx2(HWND hWnd, CM_POLICY *p, bool cascade_mode, UINT ver)
{
POLICY *pol;
UINT i;
LVB *b;
// Validate arguments
if (hWnd == NULL || p == NULL)
{
return;
}
pol = p->Policy;
b = LvInsertStart();
for (i = 0;i < NUM_POLICY_ITEM;i++)
{
wchar_t tmp[MAX_SIZE];
if (cascade_mode)
{
if (PolicyIsSupportedForCascade(i) == false)
{
continue;
}
}
if (IS_POLICY_FOR_CURRENT_VER(i, ver))
{
if (policy_item[i].TypeInt == false)
{
// bool type
UniStrCpy(tmp, sizeof(tmp), POLICY_BOOL(pol, i) ? _UU("POL_BOOL_ENABLE") : (p->Extension ? _UU("POL_BOOL_DISABLE_EX") : _UU("POL_BOOL_DISABLE")));
}
else
{
// int type
if (policy_item[i].AllowZero && POLICY_INT(pol, i) == 0)
{
UniStrCpy(tmp, sizeof(tmp), _UU("POL_INT_ZERO"));
}
else
{
UniFormat(tmp, sizeof(tmp), _UU(policy_item[i].FormatStr), POLICY_INT(pol, i));
}
}
LvInsertAdd(b, ICO_MACHINE, (void *)i, 2, GetPolicyTitle(i), tmp);
}
}
LvInsertEnd(b, hWnd, L_POLICY);
}
// Policy list dialog box
UINT CmPolicyDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
{
CM_POLICY *p = (CM_POLICY *)param;
NMHDR *n;
// Validate arguments
if (hWnd == NULL)
{
return 0;
}
switch (msg)
{
case WM_INITDIALOG:
FormatText(hWnd, 0, p->AccountName);
FormatText(hWnd, S_TITLE, p->AccountName);
p->hWnd = hWnd;
if (p->CmStatus != NULL)
{
p->CmStatus->hWndPolicy = hWnd;
}
// Initialize the column
LvInit(hWnd, L_POLICY);
LvInsertColumn(hWnd, L_POLICY, 0, _UU("POL_TITLE_STR"), 375);
LvInsertColumn(hWnd, L_POLICY, 1, _UU("POL_VALUE_STR"), 100);
// Display
CmPolicyDlgPrint(hWnd, p);
// Select the first
LvSelect(hWnd, L_POLICY, 0);
break;
case WM_COMMAND:
switch (wParam)
{
case IDOK:
case IDCANCEL:
Close(hWnd);
break;
}
break;
case WM_NOTIFY:
n = (NMHDR *)lParam;
switch (n->idFrom)
{
case L_POLICY:
switch (n->code)
{
case LVN_ITEMCHANGED:
// Change selection
if (LvIsSelected(hWnd, L_POLICY) == false)
{
SetText(hWnd, S_DESCRIPTION, L"");
}
else
{
UINT index = LvGetSelected(hWnd, L_POLICY);
UINT id = (UINT)LvGetParam(hWnd, L_POLICY, index);
if (id < NUM_POLICY_ITEM)
{
SetText(hWnd, S_DESCRIPTION, GetPolicyDescription(id));
}
}
break;
}
break;
}
break;
case WM_CLOSE:
EndDialog(hWnd, 0);
break;
}
LvSortHander(hWnd, msg, wParam, lParam, L_POLICY);
return 0;
}
// Show the policy list dialog
void CmPolicyDlg(HWND hWnd, CM_STATUS *st)
{
RPC_CLIENT_GET_CONNECTION_STATUS s;
POLICY *policy;
CM_POLICY cp;
// Validate arguments
if (hWnd == NULL || st == NULL)
{
return;
}
// Get the policy
Zero(&s, sizeof(s));
UniStrCpy(s.AccountName, sizeof(s.AccountName), st->AccountName);
if (CALL(hWnd, CcGetAccountStatus(cm->Client, &s)) == false)
{
return;
}
if (s.Active == false)
{
return;
}
policy = &s.Policy;
Zero(&cp, sizeof(cp));
UniStrCpy(cp.AccountName, sizeof(cp.AccountName), st->AccountName);
cp.Policy = policy;
cp.CmStatus = st;
Dialog(hWnd, D_CM_POLICY, CmPolicyDlgProc, &cp);
st->hWndPolicy = NULL;
CiFreeClientGetConnectionStatus(&s);
}
// Show the certificate
void CmStatusDlgPrintCert(HWND hWnd, CM_STATUS *st, bool server)
{
RPC_CLIENT_GET_CONNECTION_STATUS s;
X *x, *issuer;
// Validate arguments
if (hWnd == NULL || st == NULL)
{
return;
}
// Get the latest information
Zero(&s, sizeof(s));
UniStrCpy(s.AccountName, sizeof(s.AccountName), st->AccountName);
if (CALL(hWnd, CcGetAccountStatus(cm->Client, &s)) == false)
{
Close(hWnd);
return;
}
if (s.Active == false)
{
// Disconnect
Close(hWnd);
return;
}
if (server == false)
{
// Show the client certificate
x = s.ClientX;
}
else
{
// Show the server certificate
x = s.ServerX;
}
cm->WindowCount++;
issuer = CmGetIssuer(x);
CertDlg(hWnd, x, issuer, true);
FreeX(issuer);
cm->WindowCount--;
CiFreeClientGetConnectionStatus(&s);
}
// Show the information of the status dialog
void CmStatusDlgPrint(HWND hWnd, CM_STATUS *cmst)
{
RPC_CLIENT_GET_CONNECTION_STATUS s;
LVB *b;
// Validate arguments
if (hWnd == NULL || cmst == NULL)
{
return;
}
// Get the latest information
Zero(&s, sizeof(s));
UniStrCpy(s.AccountName, sizeof(s.AccountName), cmst->AccountName);
if (CALL(hWnd, CcGetAccountStatus(cm->Client, &s)) == false)
{
Close(hWnd);
return;
}
if (s.Active == false)
{
// Disconnect
Close(hWnd);
return;
}
// Show the status in the list box in the status dialog
b = LvInsertStart();
CmPrintStatusToListView(b, &s);
LvInsertEnd(b, hWnd, L_STATUS);
LvAutoSize(hWnd, L_STATUS);
SetEnable(hWnd, B_POLICY, s.Connected);
SetEnable(hWnd, B_SERVER_CERT, s.ServerX != NULL);
SetEnable(hWnd, B_CLIENT_CERT, s.ClientX != NULL);
CiFreeClientGetConnectionStatus(&s);
}
// Show the status in the list box in the status dialog
void CmPrintStatusToListView(LVB *b, RPC_CLIENT_GET_CONNECTION_STATUS *s)
{
CmPrintStatusToListViewEx(b, s, false);
}
void CmPrintStatusToListViewEx(LVB *b, RPC_CLIENT_GET_CONNECTION_STATUS *s, bool server_mode)
{
wchar_t tmp[MAX_SIZE];
char str[MAX_SIZE];
char vv[128];
// Validate arguments
if (b == NULL || s == NULL)
{
return;
}
if (server_mode == false)
{
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_ACCOUNT_NAME"), s->AccountName);
if (s->Connected == false)
{
wchar_t *st = _UU("CM_ST_CONNECTED_FALSE");
switch (s->SessionStatus)
{
case CLIENT_STATUS_CONNECTING:
st = _UU("CM_ST_CONNECTING");
break;
case CLIENT_STATUS_NEGOTIATION:
st = _UU("CM_ST_NEGOTIATION");
break;
case CLIENT_STATUS_AUTH:
st = _UU("CM_ST_AUTH");
break;
case CLIENT_STATUS_ESTABLISHED:
st = _UU("CM_ST_ESTABLISHED");
break;
case CLIENT_STATUS_RETRY:
st = _UU("CM_ST_RETRY");
break;
case CLIENT_STATUS_IDLE:
st = _UU("CM_ST_IDLE");
break;
}
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_CONNECTED"), st);
}
else
{
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_CONNECTED"), _UU("CM_ST_CONNECTED_TRUE"));
}
}
if (s->Connected)
{
if (s->VLanId == 0)
{
UniStrCpy(tmp, sizeof(tmp), _UU("CM_ST_NO_VLAN"));
}
else
{
UniToStru(tmp, s->VLanId);
}
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_VLAN_ID"), tmp);
if (server_mode == false)
{
StrToUni(tmp, sizeof(tmp), s->ServerName);
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_SERVER_NAME"), tmp);
UniFormat(tmp, sizeof(tmp), _UU("CM_ST_PORT_TCP"), s->ServerPort);
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_SERVER_PORT"), tmp);
}
StrToUni(tmp, sizeof(tmp), s->ServerProductName);
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_SERVER_P_NAME"), tmp);
UniFormat(tmp, sizeof(tmp), L"%u.%02u", s->ServerProductVer / 100, s->ServerProductVer % 100);
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_SERVER_P_VER"), tmp);
UniFormat(tmp, sizeof(tmp), L"Build %u", s->ServerProductBuild);
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_SERVER_P_BUILD"), tmp);
}
GetDateTimeStrEx64(tmp, sizeof(tmp), SystemToLocal64(s->StartTime), NULL);
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_START_TIME"), tmp);
GetDateTimeStrEx64(tmp, sizeof(tmp), SystemToLocal64(s->FirstConnectionEstablisiedTime), NULL);
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_FIRST_ESTAB_TIME"), s->FirstConnectionEstablisiedTime == 0 ? _UU("CM_ST_NONE") : tmp);
if (s->Connected)
{
GetDateTimeStrEx64(tmp, sizeof(tmp), SystemToLocal64(s->CurrentConnectionEstablishTime), NULL);
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_CURR_ESTAB_TIME"), tmp);
}
if (server_mode == false)
{
UniFormat(tmp, sizeof(tmp), _UU("CM_ST_NUM_STR"), s->NumConnectionsEatablished);
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_NUM_ESTABLISHED"), tmp);
}
if (s->Connected)
{
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_HALF_CONNECTION"), s->HalfConnection ? _UU("CM_ST_HALF_TRUE") : _UU("CM_ST_HALF_FALSE"));
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_QOS"), s->QoS ? _UU("CM_ST_QOS_TRUE") : _UU("CM_ST_QOS_FALSE"));
UniFormat(tmp, sizeof(tmp), L"%u", s->NumTcpConnections);
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_NUM_TCP"), tmp);
if (s->HalfConnection)
{
UniFormat(tmp, sizeof(tmp), L"%u", s->NumTcpConnectionsUpload);
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_NUM_TCP_UPLOAD"), tmp);
UniFormat(tmp, sizeof(tmp), L"%u", s->NumTcpConnectionsDownload);
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_NUM_TCP_DOWNLOAD"), tmp);
}
UniFormat(tmp, sizeof(tmp), L"%u", s->MaxTcpConnections);
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_MAX_TCP"), tmp);
if (s->UseEncrypt == false)
{
UniStrCpy(tmp, sizeof(tmp), _UU("CM_ST_USE_ENCRYPT_FALSE"));
}
else
{
if (StrLen(s->CipherName) != 0)
{
UniFormat(tmp, sizeof(tmp), _UU("CM_ST_USE_ENCRYPT_TRUE"), s->CipherName);
}
else
{
UniFormat(tmp, sizeof(tmp), _UU("CM_ST_USE_ENCRYPT_TRUE2"));
}
}
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_USE_ENCRYPT"), tmp);
if (s->UseCompress)
{
UINT percent = 0;
if ((s->TotalRecvSize + s->TotalSendSize) > 0)
{
percent = (UINT)((UINT64)100 - (UINT64)(s->TotalRecvSizeReal + s->TotalSendSizeReal) * (UINT64)100 /
(s->TotalRecvSize + s->TotalSendSize));
percent = MAKESURE(percent, 0, 100);
}
UniFormat(tmp, sizeof(tmp), _UU("CM_ST_COMPRESS_TRUE"), percent);
}
else
{
UniStrCpy(tmp, sizeof(tmp), _UU("CM_ST_COMPRESS_FALSE"));
}
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_USE_COMPRESS"), tmp);
if (IsEmptyStr(s->UnderlayProtocol) == false)
{
StrToUni(tmp, sizeof(tmp), s->UnderlayProtocol);
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_UNDERLAY_PROTOCOL"), tmp);
}
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_UDP_ACCEL_ENABLED"), (s->IsUdpAccelerationEnabled ? _UU("CM_ST_YES") : _UU("CM_ST_NO")));
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_UDP_ACCEL_USING"), (s->IsUsingUdpAcceleration ? _UU("CM_ST_YES") : _UU("CM_ST_NO")));
StrToUni(tmp, sizeof(tmp), s->SessionName);
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_SESSION_NAME"), tmp);
StrToUni(tmp, sizeof(tmp), s->ConnectionName);
if (UniStrCmpi(tmp, L"INITING") != 0)
{
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_CONNECTION_NAME"), tmp);
}
BinToStr(str, sizeof(str), s->SessionKey, sizeof(s->SessionKey));
StrToUni(tmp, sizeof(tmp), str);
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_SESSION_KEY"), tmp);
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_BRIDGE_MODE"), s->IsBridgeMode ? _UU("CM_ST_YES") : _UU("CM_ST_NO"));
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_MONITOR_MODE"), s->IsMonitorMode ? _UU("CM_ST_YES") : _UU("CM_ST_NO"));
ToStr3(vv, sizeof(vv), s->TotalSendSize);
UniFormat(tmp, sizeof(tmp), _UU("CM_ST_SIZE_BYTE_STR"), vv);
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_SEND_SIZE"), tmp);
ToStr3(vv, sizeof(vv), s->TotalRecvSize);
UniFormat(tmp, sizeof(tmp), _UU("CM_ST_SIZE_BYTE_STR"), vv);
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_RECV_SIZE"), tmp);
ToStr3(vv, sizeof(vv), s->Traffic.Send.UnicastCount);
UniFormat(tmp, sizeof(tmp), _UU("CM_ST_NUM_PACKET_STR"), vv);
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_SEND_UCAST_NUM"), tmp);
ToStr3(vv, sizeof(vv), s->Traffic.Send.UnicastBytes);
UniFormat(tmp, sizeof(tmp), _UU("CM_ST_SIZE_BYTE_STR"), vv);
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_SEND_UCAST_SIZE"), tmp);
ToStr3(vv, sizeof(vv), s->Traffic.Send.BroadcastCount);
UniFormat(tmp, sizeof(tmp), _UU("CM_ST_NUM_PACKET_STR"), vv);
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_SEND_BCAST_NUM"), tmp);
ToStr3(vv, sizeof(vv), s->Traffic.Send.BroadcastBytes);
UniFormat(tmp, sizeof(tmp), _UU("CM_ST_SIZE_BYTE_STR"), vv);
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_SEND_BCAST_SIZE"), tmp);
ToStr3(vv, sizeof(vv), s->Traffic.Recv.UnicastCount);
UniFormat(tmp, sizeof(tmp), _UU("CM_ST_NUM_PACKET_STR"), vv);
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_RECV_UCAST_NUM"), tmp);
ToStr3(vv, sizeof(vv), s->Traffic.Recv.UnicastBytes);
UniFormat(tmp, sizeof(tmp), _UU("CM_ST_SIZE_BYTE_STR"), vv);
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_RECV_UCAST_SIZE"), tmp);
ToStr3(vv, sizeof(vv), s->Traffic.Recv.BroadcastCount);
UniFormat(tmp, sizeof(tmp), _UU("CM_ST_NUM_PACKET_STR"), vv);
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_RECV_BCAST_NUM"), tmp);
ToStr3(vv, sizeof(vv), s->Traffic.Recv.BroadcastBytes);
UniFormat(tmp, sizeof(tmp), _UU("CM_ST_SIZE_BYTE_STR"), vv);
LvInsertAdd(b, 0, NULL, 2, _UU("CM_ST_RECV_BCAST_SIZE"), tmp);
}
}
// Status dialog procedure
UINT CmStatusDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
{
wchar_t tmp[MAX_SIZE];
CM_STATUS *s = (CM_STATUS *)param;
// Validate arguments
if (hWnd == NULL)
{
return 0;
}
switch (msg)
{
case WM_INITDIALOG:
SetIcon(hWnd, 0, ICO_TOWER);
UniFormat(tmp, sizeof(tmp), _UU("CM_ST_TITLE"), s->AccountName);
SetText(hWnd, 0, tmp);
FormatText(hWnd, S_TITLE, s->AccountName);
DlgFont(hWnd, S_TITLE, 0, 1);
Add(cm->StatusWindowList, hWnd);
SetTimer(hWnd, 1, 500, NULL);
LvInitEx(hWnd, L_STATUS, true);
ListView_SetImageList(DlgItem(hWnd, L_STATUS), NULL, LVSIL_NORMAL);
ListView_SetImageList(DlgItem(hWnd, L_STATUS), NULL, LVSIL_SMALL);
LvInsertColumn(hWnd, L_STATUS, 0, _UU("CM_ST_COLUMN_1"), 160);
LvInsertColumn(hWnd, L_STATUS, 1, _UU("CM_ST_COLUMN_2"), 270);
CmStatusDlgPrint(hWnd, s);
break;
case WM_TIMER:
switch (wParam)
{
case 1:
KillTimer(hWnd, 1);
CmStatusDlgPrint(hWnd, s);
SetTimer(hWnd, 1, 500, NULL);
break;
}
break;
case WM_COMMAND:
switch (wParam)
{
case IDOK:
case IDCANCEL:
// Close
Close(hWnd);
break;
case B_POLICY:
// Show the policy
CmPolicyDlg(hWnd, s);
break;
case B_SERVER_CERT:
CmStatusDlgPrintCert(hWnd, s, true);
break;
case B_CLIENT_CERT:
CmStatusDlgPrintCert(hWnd, s, false);
break;
}
break;
case WM_CLOSE:
Delete(cm->StatusWindowList, hWnd);
if (s->hWndPolicy != NULL)
{
EndDialog(s->hWndPolicy, false);
s->hWndPolicy = NULL;
}
EndDialog(hWnd, false);
break;
}
return 0;
}
// Show the status dialog
void CmStatusDlg(HWND hWnd, wchar_t *account_name)
{
CM_STATUS *s;
// Validate arguments
if (hWnd == NULL || account_name == NULL)
{
return;
}
s = ZeroMalloc(sizeof(CM_STATUS));
UniStrCpy(s->AccountName, sizeof(s->AccountName), account_name);
Dialog(hWnd, D_CONNECTION_STATUS, CmStatusDlgProc, s);
Free(s);
}
// Show the status
void CmStatus(HWND hWnd, wchar_t *account_name)
{
UINT i;
wchar_t tmp[MAX_SIZE];
// Validate arguments
if (hWnd == NULL || account_name == NULL)
{
return;
}
UniFormat(tmp, sizeof(tmp), _UU("CM_ST_TITLE"), account_name);
for (i = 0;i < LIST_NUM(cm->StatusWindowList);i++)
{
HWND h = LIST_DATA(cm->StatusWindowList, i);
if (h != NULL)
{
wchar_t tmp2[MAX_SIZE];
if (GetTxt(h, 0, tmp2, sizeof(tmp2)))
{
if (UniStrCmpi(tmp2, tmp) == 0)
{
SetActiveWindow(h);
return;
}
}
}
}
CmStatusDlg(hWnd, account_name);
}
// Delete
void CmDeleteAccount(HWND hWnd, wchar_t *account_name)
{
RPC_CLIENT_DELETE_ACCOUNT c;
// Validate arguments
if (hWnd == NULL || account_name == NULL)
{
return;
}
Zero(&c, sizeof(c));
UniStrCpy(c.AccountName, sizeof(c.AccountName), account_name);
CmVoice("delete_config_1");
if (MsgBoxEx(hWnd, MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2, _UU("CM_DELETE_ACCOUNT_MSG"), account_name)
== IDNO)
{
return;
}
CALL(hWnd, CcDeleteAccount(cm->Client, &c));
CmVoice("delete_config_2");
}
// Disconnect
void CmDisconnect(HWND hWnd, wchar_t *account_name)
{
RPC_CLIENT_CONNECT c;
// Validate arguments
if (hWnd == NULL || account_name == NULL)
{
return;
}
Zero(&c, sizeof(c));
UniStrCpy(c.AccountName, sizeof(c.AccountName), account_name);
cm->PositiveDisconnectFlag = true;
CALL(hWnd, CcDisconnect(cm->Client, &c));
}
// Show the promotional window
void SmShowPublicVpnServerHtml(HWND hWnd)
{
char *langstr = _SS("LANGSTR");
if(StrCmpi(langstr, "Japanese") == 0)
{
ShowHtml(hWnd, PUBLIC_SERVER_HTML, PUBLIC_SERVER_TAG);
}
else
{
ShowHtml(hWnd, PUBLIC_SERVER_HTML_EN, PUBLIC_SERVER_TAG);
}
}
// Connection
void CmConnect(HWND hWnd, wchar_t *account_name)
{
RPC_CLIENT_CONNECT c;
UINT i;
// Validate arguments
if (hWnd == NULL || account_name == NULL)
{
return;
}
if (IsEnable(hWnd, 0) == false)
{
return;
}
if (hWnd == cm->hMainWnd)
{
if (LvNum(hWnd, L_VLAN) == 0 && cm->Client->Win9x)
{
if (MsgBox(hWnd, MB_ICONINFORMATION | MB_YESNO, _UU("CM_NO_VLAN_2")) == IDNO)
{
return;
}
else
{
if (cm->server_name == NULL || cm->Client->Unix)
{
Command(hWnd, CMD_NEW_VLAN);
return;
}
else
{
MsgBox(hWnd, MB_ICONINFORMATION, _UU("CM_VLAN_REMOTE_ERROR"));
}
return;
}
}
}
// (If necessary) display a warning
if (CmWarningDesktop(hWnd, account_name) == false)
{
return;
}
if (cm->server_name == NULL)
{
if (cm->BadProcessChecked == false)
{
cm->BadProcessChecked = true;
CheckBadProcesses(hWnd);
}
}
if (cm->server_name == NULL)
{
// Check the Windows version
RPC_WINVER winver;
wchar_t winver_msg_client[3800];
GetWinVer(&winver);
Zero(winver_msg_client, sizeof(winver_msg_client));
if (IsSupportedWinVer(&winver) == false)
{
SYSTEMTIME st;
LocalTime(&st);
UniFormat(winver_msg_client, sizeof(winver_msg_client), _UU("WINVER_ERROR_FORMAT"),
_UU("WINVER_ERROR_PC_LOCAL"),
winver.Title,
_UU("WINVER_ERROR_VPNCLIENT"),
SUPPORTED_WINDOWS_LIST,
_UU("WINVER_ERROR_PC_LOCAL"),
_UU("WINVER_ERROR_VPNCLIENT"),
_UU("WINVER_ERROR_VPNCLIENT"),
_UU("WINVER_ERROR_VPNCLIENT"),
st.wYear, st.wMonth);
}
if (UniIsEmptyStr(winver_msg_client) == false)
{
OnceMsgEx(hWnd, _UU("WINVER_TITLE"), winver_msg_client,
true, ICO_WARNING, NULL);
}
}
i = LvSearchStr(hWnd, L_ACCOUNT, 0, account_name);
if (i != INFINITE)
{
wchar_t *tmp = LvGetStr(hWnd, L_ACCOUNT, i, 2);
if (tmp != NULL)
{
wchar_t tag[MAX_SIZE];
StrToUni(tag, sizeof(tag), PUBLIC_SERVER_NAME);
if (UniSearchStrEx(tmp, tag, 0, false) != INFINITE)
{
SmShowPublicVpnServerHtml(hWnd);
}
Free(tmp);
}
}
if (cm->CheckedAndShowedAdminPackMessage == false)
{
cm->CheckedAndShowedAdminPackMessage = true;
//CmCheckAndShowAdminPackTrialVersionNoticeMessage(NULL);
}
Zero(&c, sizeof(c));
UniStrCpy(c.AccountName, sizeof(c.AccountName), account_name);
CmSetForegroundProcessToCnService();
if (CALL(hWnd, CcConnect(cm->Client, &c)))
{
cm->ConnectStartedFlag = true;
}
}
// Determine whether to bold the specified menu item
bool CmIsBold(UINT id)
{
return false;
}
// Determine whether to enable the specified menu item
bool CmIsEnabled(HWND hWnd, UINT id)
{
UINT index;
wchar_t *name;
bool locked = false;
// Validate arguments
if (hWnd == NULL)
{
return false;
}
locked = cm->CmSetting.LockMode;
if (locked)
{
switch (id)
{
case CMD_NEW:
case CMD_CLONE:
case CMD_IMPORT_ACCOUNT:
case CMD_DELETE:
case CMD_OPTION:
case CMD_VOIDE_NONE:
case CMD_VOICE_NORMAL:
case CMD_VOICE_ODD:
case CMD_STARTUP:
case CMD_NOSTARTUP:
case CMD_TRAFFIC:
case CMD_MMCSS:
return false;
case CMD_NEW_VLAN:
case CMD_ENABLE_VLAN:
case CMD_DISABLE_VLAN:
case CMD_DELETE_VLAN:
case CMD_REINSTALL:
case CMD_WINNET:
if (cm->CmEasyModeSupported)
{
return false;
}
}
}
switch (id)
{
case CMD_LANGUAGE:
return MsIsNt();
case CMD_SHOWPORT:
case CMD_GRID:
if (cm->IconView)
{
return false;
}
return true;
case CMD_MMCSS:
if (MsIsVista() == false || IsEmptyStr(cm->server_name) == false)
{
return false;
}
if (OS_IS_SERVER(GetOsType()))
{
return false;
}
return true;
case CMD_TRAYICON:
case CMD_TRAFFIC:
return (cm->server_name == NULL);
case CMD_NETIF:
if (MsIsNt() == false)
{
return false;
}
return (cm->server_name == NULL);
case CMD_CM_SETTING:
return cm->CmSettingSupported;
case CMD_CONNECT:
case CMD_DISCONNECT:
case CMD_STATUS:
case CMD_RENAME:
case CMD_DELETE:
if (LvIsMultiMasked(hWnd, L_ACCOUNT))
{
return false;
}
if (LvIsSelected(hWnd, L_ACCOUNT) == false)
{
return false;
}
else
{
// Determine whether the selected account is under connecting
UINT i = LvGetSelected(hWnd, L_ACCOUNT);
wchar_t *str = LvGetStr(hWnd, L_ACCOUNT, i, 1);
wchar_t *name = LvGetStr(hWnd, L_ACCOUNT, i, 0);
bool is_connected = false;
if (str != NULL)
{
if (UniStrCmpi(str, _UU("CM_ACCOUNT_ONLINE")) == 0 || UniStrCmpi(str, _UU("CM_ACCOUNT_CONNECTING")) == 0)
{
is_connected = true;
}
Free(str);
}
if (name != NULL)
{
if (UniStrCmpi(name, _UU("CM_NEW_ICON")) == 0 || UniStrCmpi(name, _UU("CM_VGC_ICON")) == 0 || UniStrCmpi(name, _UU("CM_VGC_LINK")) == 0)
{
Free(name);
return false;
}
Free(name);
}
if (id == CMD_CONNECT || id == CMD_RENAME || id == CMD_DELETE)
{
return !is_connected;
}
else
{
return is_connected;
}
}
break;
case CMD_DISCONNECT_ALL:
if (CmGetNumConnected(hWnd) == 0)
{
return false;
}
else
{
return true;
}
case CMD_SHORTCUT:
// Create a shortcut
if (cm->Client->Rpc->Sock->RemoteIP.addr[0] != 127)
{
return false;
}
case CMD_EXPORT_ACCOUNT:
if (LvIsMultiMasked(hWnd, L_ACCOUNT))
{
return false;
}
name = LvGetSelectedStr(hWnd, L_ACCOUNT, 0);
if (name != NULL)
{
if (UniStrCmpi(name, _UU("CM_NEW_ICON")) == 0 || UniStrCmpi(name, _UU("CM_VGC_ICON")) == 0 || UniStrCmpi(name, _UU("CM_VGC_LINK")) == 0
)
{
Free(name);
return false;
}
Free(name);
}
return LvIsSelected(hWnd, L_ACCOUNT);
case CMD_CLONE:
if (LvIsMultiMasked(hWnd, L_ACCOUNT))
{
return false;
}
name = LvGetSelectedStr(hWnd, L_ACCOUNT, 0);
if (name != NULL)
{
if (UniStrCmpi(name, _UU("CM_NEW_ICON")) == 0 || UniStrCmpi(name, _UU("CM_VGC_ICON")) == 0 || UniStrCmpi(name, _UU("CM_VGC_LINK")) == 0
)
{
Free(name);
return false;
}
Free(name);
}
return LvIsSelected(hWnd, L_ACCOUNT);
case CMD_STARTUP:
case CMD_NOSTARTUP:
name = LvGetSelectedStr(hWnd, L_ACCOUNT, 0);
if (name != NULL)
{
if (UniStrCmpi(name, _UU("CM_NEW_ICON")) == 0 || UniStrCmpi(name, _UU("CM_VGC_ICON")) == 0 || UniStrCmpi(name, _UU("CM_VGC_LINK")) == 0
)
{
Free(name);
return false;
}
Free(name);
}
if (LvIsMultiMasked(hWnd, L_ACCOUNT))
{
return false;
}
if (LvIsSelected(hWnd, L_ACCOUNT) == false)
{
return false;
}
else
{
// Determine whether the selected account is a startup account
UINT i = LvGetSelected(hWnd, L_ACCOUNT);
bool is_startup = (bool)LvGetParam(hWnd, L_ACCOUNT, i);
if (id == CMD_STARTUP)
{
return !is_startup;
}
else
{
return is_startup;
}
}
break;
case CMD_NEW_VLAN:
if (cm->Client->Unix == false && cm->Client->Win9x == false)
{
if (cm->server_name != NULL)
{
return false;
}
}
if (cm->Client->Win9x)
{
if (LvNum(hWnd, L_VLAN) >= 1)
{
// You can not install two or more virtual LAN cards in Win9x
return false;
}
}
break;
case CMD_PROPERTY:
name = LvGetSelectedStr(hWnd, L_ACCOUNT, 0);
if (name != NULL)
{
if (UniStrCmpi(name, _UU("CM_NEW_ICON")) == 0 || UniStrCmpi(name, _UU("CM_VGC_ICON")) == 0 || UniStrCmpi(name, _UU("CM_VGC_LINK")) == 0)
{
Free(name);
return false;
}
Free(name);
}
if (LvIsMultiMasked(hWnd, L_ACCOUNT))
{
return false;
}
return LvIsSelected(hWnd, L_ACCOUNT);
case CMD_DELETE_VLAN:
if (LvIsMultiMasked(hWnd, L_VLAN))
{
return false;
}
return LvIsSelected(hWnd, L_VLAN);
case CMD_ENABLE_VLAN:
if (cm->Client->Win9x)
{
return false;
}
if (LvIsMultiMasked(hWnd, L_VLAN))
{
return false;
}
index = LvGetSelected(hWnd, L_VLAN);
if (index == INFINITE)
{
return false;
}
else
{
wchar_t *s = LvGetStr(hWnd, L_VLAN, index, 1);
if (s != NULL)
{
if (UniStrCmpi(s, _UU("CM_VLAN_DISABLED")) == 0)
{
Free(s);
return true;
}
Free(s);
}
return false;
}
break;
case CMD_DISABLE_VLAN:
if (cm->Client->Win9x)
{
return false;
}
if (LvIsMultiMasked(hWnd, L_VLAN))
{
return false;
}
index = LvGetSelected(hWnd, L_VLAN);
if (index == INFINITE)
{
return false;
}
else
{
wchar_t *s = LvGetStr(hWnd, L_VLAN, index, 1);
if (s != NULL)
{
if (UniStrCmpi(s, _UU("CM_VLAN_ENABLED")) == 0)
{
Free(s);
return true;
}
Free(s);
}
return false;
}
break;
case CMD_REINSTALL:
if (cm->server_name != NULL)
{
return false;
}
if (cm->Client->Win9x || cm->Client->Unix)
{
// Upgrading the virtual LAN card on a UNIX system or Win9x is unavailable
return false;
}
if (LvIsMultiMasked(hWnd, L_VLAN))
{
return false;
}
return LvIsSelected(hWnd, L_VLAN);
case CMD_WINNET:
{
UINT os_type = GetOsInfo()->OsType;
if (OS_IS_WINDOWS_NT(os_type) && GET_KETA(os_type, 100) >= 2)
{
if (cm->server_name != NULL)
{
return false;
}
return true;
}
else
{
return false;
}
}
break;
case CMD_EXIT:
return cm->TrayInited;
}
return true;
}
// Convert a VLAN device name to the display name
void CmVLanNameToPrintName(char *str, UINT size, char *name)
{
// Validate arguments
if (str == NULL || name == NULL)
{
return;
}
Format(str, size, VLAN_ADAPTER_NAME_TAG, name);
}
// Convert a display name to a VLAN device name
bool CmPrintNameToVLanName(char *name, UINT size, char *str)
{
// Validate arguments
if (name == NULL || str == NULL)
{
return false;
}
if (StartWith(str, VLAN_ADAPTER_NAME))
{
if (StrLen(str) < (StrLen(VLAN_ADAPTER_NAME) + 3))
{
return false;
}
StrCpy(name, size, str + StrLen(VLAN_ADAPTER_NAME) + 3);
return true;
}
if (StartWith(str, VLAN_ADAPTER_NAME_OLD))
{
if (StrLen(str) < (StrLen(VLAN_ADAPTER_NAME_OLD) + 3))
{
return false;
}
StrCpy(name, size, str + StrLen(VLAN_ADAPTER_NAME_OLD) + 3);
return true;
}
return false;
}
// Initialize the account list
void CmInitAccountList(HWND hWnd)
{
CmInitAccountListEx(hWnd, false);
}
void CmInitAccountListEx(HWND hWnd, bool easy)
{
UINT width[5];
BUF *b;
// Validate arguments
if (hWnd == NULL)
{
return;
}
// Read the setting
b = MsRegReadBin(REG_CURRENT_USER, CM_REG_KEY, "AccountListColumnWidth");
if ((b != NULL) && (b->Size == sizeof(width)))
{
Copy(width, b->Buf, sizeof(width));
}
else if ((b != NULL) && (b->Size == (sizeof(width) - sizeof(UINT))))
{
// Migrating from previous versions
Zero(width, sizeof(width));
Copy(width, b->Buf, sizeof(width) - sizeof(UINT));
width[4] = width[3];
width[3] = 0;
}
else
{
Zero(width, sizeof(width));
}
FreeBuf(b);
LvInitEx2(hWnd, L_ACCOUNT, false, easy);
// LvSetStyle(hWnd, L_ACCOUNT, LVS_EX_TRACKSELECT);
// Initialize the column
if (easy == false)
{
LvInsertColumn(hWnd, L_ACCOUNT, 0, _UU("CM_ACCOUNT_COLUMN_1"), width[0] == 0 ? 215 : width[0]);
LvInsertColumn(hWnd, L_ACCOUNT, 1, _UU("CM_ACCOUNT_COLUMN_2"), width[1] == 0 ? 80 : width[1]);
LvInsertColumn(hWnd, L_ACCOUNT, 2, _UU("CM_ACCOUNT_COLUMN_3"), width[2] == 0 ? 220 : width[2]);
LvInsertColumn(hWnd, L_ACCOUNT, 3, _UU("CM_ACCOUNT_COLUMN_3_2"), width[3] == 0 ? 90 : width[3]);
LvInsertColumn(hWnd, L_ACCOUNT, 4, _UU("CM_ACCOUNT_COLUMN_4"), (width[4] == 0 || width[4] == 250) ? 120 : width[4]);
}
else
{
LvInsertColumn(hWnd, L_ACCOUNT, 0, _UU("CM_ACCOUNT_COLUMN_1"), 345);
LvInsertColumn(hWnd, L_ACCOUNT, 1, _UU("CM_ACCOUNT_COLUMN_2"), 140);
LvInsertColumn(hWnd, L_ACCOUNT, 2, _UU("CM_ACCOUNT_COLUMN_3"), 0);
LvInsertColumn(hWnd, L_ACCOUNT, 3, _UU("CM_ACCOUNT_COLUMN_3_2"), 0);
LvInsertColumn(hWnd, L_ACCOUNT, 4, _UU("CM_ACCOUNT_COLUMN_4"), 0);
}
}
// Release the account list
void CmSaveAccountListPos(HWND hWnd)
{
UINT width[5];
UINT i;
// Validate arguments
if (hWnd == NULL)
{
return;
}
for (i = 0;i < 5;i++)
{
width[i] = LvGetColumnWidth(hWnd, L_ACCOUNT, i);
}
MsRegWriteBin(REG_CURRENT_USER, CM_REG_KEY, "AccountListColumnWidth", width, sizeof(width));
}
// Initialize the VLAN list
void CmInitVLanList(HWND hWnd)
{
UINT width[4];
BUF *b;
// Validate arguments
if (hWnd == NULL)
{
return;
}
// Read the setting
b = MsRegReadBin(REG_CURRENT_USER, CM_REG_KEY, "VLanListColumnWidth");
if ((b != NULL) && (b->Size == sizeof(width)))
{
Copy(width, b->Buf, sizeof(width));
}
else
{
Zero(width, sizeof(width));
}
FreeBuf(b);
LvInit(hWnd, L_VLAN);
// LvSetStyle(hWnd, L_ACCOUNT, LVS_EX_TRACKSELECT);
// Initialize the column
LvInsertColumn(hWnd, L_VLAN, 0, _UU("CM_VLAN_COLUMN_1"), width[0] == 0 ? 310 : width[0]);
LvInsertColumn(hWnd, L_VLAN, 1, _UU("CM_VLAN_COLUMN_2"), width[1] == 0 ? 120 : width[1]);
LvInsertColumn(hWnd, L_VLAN, 2, _UU("CM_VLAN_COLUMN_3"), width[2] == 0 ? 175 : width[2]);
LvInsertColumn(hWnd, L_VLAN, 3, _UU("CM_VLAN_COLUMN_4"), width[3] == 0 ? 120 : width[3]);
}
// Release the VLAN list
void CmSaveVLanListPos(HWND hWnd)
{
UINT width[4];
UINT i;
// Validate arguments
if (hWnd == NULL)
{
return;
}
for (i = 0;i < 4;i++)
{
width[i] = LvGetColumnWidth(hWnd, L_VLAN, i);
}
MsRegWriteBin(REG_CURRENT_USER, CM_REG_KEY, "VLanListColumnWidth", width, sizeof(width));
}
// Update the account list
void CmRefreshAccountList(HWND hWnd)
{
CmRefreshAccountListEx(hWnd, false);
CmRefreshEasy();
}
void CmRefreshAccountListEx(HWND hWnd, bool easy)
{
CmRefreshAccountListEx2(hWnd, easy, false);
}
void CmRefreshAccountListEx2(HWND hWnd, bool easy, bool style_changed)
{
UINT num = 0;
RPC_CLIENT_ENUM_ACCOUNT a;
UINT num_connecting = 0, num_connected = 0;
wchar_t tmp[MAX_SIZE];
wchar_t new_inserted_item[MAX_ACCOUNT_NAME_LEN + 1];
bool select_new_insteted_item = true;
// Validate arguments
if (hWnd == NULL)
{
return;
}
// Switching of icon / detail view
LvSetView(hWnd, L_ACCOUNT, cm->IconView == false || easy);
// Show grid
if (cm->ShowGrid || easy)
{
LvSetStyle(hWnd, L_ACCOUNT, LVS_EX_GRIDLINES);
}
else
{
LvRemoveStyle(hWnd, L_ACCOUNT, LVS_EX_GRIDLINES);
}
if (style_changed)
{
// Change the font
if (easy == false)
{
if (cm->VistaStyle)
{
SetFontMeiryo(hWnd, L_ACCOUNT, 9);
}
else
{
SetFontDefault(hWnd, L_ACCOUNT);
}
if (cm->VistaStyle && (cm->IconView == false))
{
LvSetStyle(hWnd, L_ACCOUNT, LVS_EX_FULLROWSELECT);
}
else
{
LvRemoveStyle(hWnd, L_ACCOUNT, LVS_EX_FULLROWSELECT);
}
}
}
Zero(new_inserted_item, sizeof(new_inserted_item));
if (LvNum(hWnd, L_ACCOUNT) == 0)
{
select_new_insteted_item = false;
}
// Enumerate the account list
if (CALL(hWnd, CcEnumAccount(cm->Client, &a)))
{
UINT i;
LVB *b = LvInsertStart();
if (cm->CmSetting.LockMode == false && (easy == false))
{
// Creating a new connection
LvInsertAdd(b, ICO_NEW, NULL, 4, _UU("CM_NEW_ICON"), L"", L"", L"");
if (cm->Client->IsVgcSupported)
{
// VPN Gate
LvInsertAdd(b, ICO_RESEARCH, NULL, 4, _UU("CM_VGC_ICON"), L"", L"", L"");
}
else if (cm->Client->ShowVgcLink)
{
// VPN Gate Link
LvInsertAdd(b, ICO_INTERNET, NULL, 4, _UU("CM_VGC_LINK"), L"", L"", L"");
}
}
for (i = 0;i < a.NumItem;i++)
{
RPC_CLIENT_ENUM_ACCOUNT_ITEM *t = a.Items[i];
UINT icon;
wchar_t tmp[MAX_SIZE];
wchar_t tmp2[MAX_SIZE];
char tmp3[MAX_SIZE];
wchar_t tmp4[MAX_SIZE];
IP ip;
char ip_str[MAX_SIZE];
// Special treatment in the case of IPv6 address
if (StrToIP6(&ip, t->ServerName) && StartWith(t->ServerName, "[") == false)
{
Format(ip_str, sizeof(ip_str),
"[%s]", t->ServerName);
}
else
{
StrCpy(ip_str, sizeof(ip_str), t->ServerName);
}
// Determine the icon
if (t->Active == false)
{
if (t->StartupAccount == false)
{
icon = ICO_SERVER_OFFLINE;
}
else
{
icon = ICO_SERVER_OFFLINE_EX;
}
}
else
{
num++;
if (t->StartupAccount == false)
{
icon = ICO_SERVER_ONLINE;
}
else
{
icon = ICO_SERVER_ONLINE_EX;
}
}
// Adding
if (easy == false)
{
//CmVLanNameToPrintName(tmp3, sizeof(tmp3), t->DeviceName);
StrCpy(tmp3, sizeof(tmp3), t->DeviceName);
StrToUni(tmp, sizeof(tmp), tmp3);
}
else
{
StrToUni(tmp, sizeof(tmp), t->DeviceName);
}
if (t->Port == 0 || cm->ShowPort == false)
{
// Port number is unknown
UniFormat(tmp2, sizeof(tmp2), L"%S (%s)", ip_str, CmGetProtocolName(t->ProxyType));
}
else
{
// Port number are also shown
UniFormat(tmp2, sizeof(tmp2), L"%S:%u (%s)", ip_str, t->Port, CmGetProtocolName(t->ProxyType));
}
if (LvSearchStr(hWnd, L_ACCOUNT, 0, t->AccountName) == INFINITE)
{
UniStrCpy(new_inserted_item, sizeof(new_inserted_item), t->AccountName);
}
// Virtual HUB name
StrToUni(tmp4, sizeof(tmp4), t->HubName);
if (easy == false)
{
LvInsertAdd(b, icon, (void *)t->StartupAccount, 5, t->AccountName,
t->Active == false ? _UU("CM_ACCOUNT_OFFLINE") :
(t->Connected ? _UU("CM_ACCOUNT_ONLINE") : _UU("CM_ACCOUNT_CONNECTING")),
tmp2, tmp4,
tmp);
}
else
{
LvInsertAdd(b, icon, (void *)t->StartupAccount, 5, t->AccountName,
t->Active == false ? _UU("CM_ACCOUNT_OFFLINE") :
(t->Connected ? _UU("CM_ACCOUNT_ONLINE") : _UU("CM_ACCOUNT_CONNECTING")),
tmp2, tmp4,
tmp);
}
if (t->Active)
{
if (t->Connected)
{
num_connected++;
}
else
{
num_connecting++;
}
}
}
LvInsertEnd(b, hWnd, L_ACCOUNT);
CiFreeClientEnumAccount(&a);
if (select_new_insteted_item)
{
if (UniStrLen(new_inserted_item) >= 1)
{
LvSelect(hWnd, L_ACCOUNT, INFINITE);
LvSelect(hWnd, L_ACCOUNT, LvSearchStr(hWnd, L_ACCOUNT, 0, new_inserted_item));
}
}
}
if (easy == false)
{
// For voice guidance, detect new connection and connection lost
if (cm->UpdateConnectedNumFlag == false)
{
cm->UpdateConnectedNumFlag = true;
cm->OldConnectedNum = num;
}
else
{
if (cm->OldConnectedNum != num)
{
if (cm->OldConnectedNum < num)
{
CmVoice("connect");
}
else
{
CmVoice("disconnect");
if (cm->CmSetting.EasyMode && cm->PositiveDisconnectFlag == false)
{
CmShowEasy();
}
cm->PositiveDisconnectFlag = false;
}
cm->OldConnectedNum = num;
}
}
if (num_connecting == 0 && num_connected == 0)
{
// There is no connecting or connected account
UniStrCpy(tmp, sizeof(tmp), _UU("CM_TRAY_NOT_CONNECTED"));
}
else if (num_connected == 0)
{
// There is only connecting account
UniFormat(tmp, sizeof(tmp), _UU("CM_TRAY_CONNECTED_1"), num_connecting);
}
else if (num_connecting == 0)
{
// There is only connected account
UniFormat(tmp, sizeof(tmp), _UU("CM_TRAY_CONNECTED_2"), num_connected);
}
else
{
// There are both
UniFormat(tmp, sizeof(tmp), _UU("CM_TRAY_CONNECTED_0"), num_connected, num_connecting);
}
if (num_connecting == 0 && num_connected == 0)
{
cm->TrayAnimation = false;
cm->TraySpeedAnimation = false;
}
else
{
cm->TrayAnimation = true;
if (num_connecting == 0)
{
cm->TraySpeedAnimation = false;
}
else
{
cm->TraySpeedAnimation = true;
}
}
CmChangeTrayString(hWnd, tmp);
}
Refresh(hWnd);
//Updated the Jump List
CmUpdateJumpList(0);
}
// Updating the VLAN list
void CmRefreshVLanList(HWND hWnd)
{
CmRefreshVLanListEx(hWnd, false);
}
void CmRefreshVLanListEx(HWND hWnd, bool style_changed)
{
RPC_CLIENT_ENUM_VLAN e;
// Validate arguments
if (hWnd == NULL)
{
return;
}
LvSetView(hWnd, L_VLAN, cm->IconView == false);
// Show grid
if (cm->ShowGrid)
{
LvSetStyle(hWnd, L_VLAN, LVS_EX_GRIDLINES);
}
else
{
LvRemoveStyle(hWnd, L_VLAN, LVS_EX_GRIDLINES);
}
if (style_changed)
{
// Change the font
if (cm->VistaStyle)
{
SetFontMeiryo(hWnd, L_VLAN, 9);
}
else
{
SetFontDefault(hWnd, L_VLAN);
}
if (cm->VistaStyle && (cm->IconView == false))
{
LvSetStyle(hWnd, L_VLAN, LVS_EX_FULLROWSELECT);
}
else
{
LvRemoveStyle(hWnd, L_VLAN, LVS_EX_FULLROWSELECT);
}
}
// Enumeration
Zero(&e, sizeof(e));
if (CALL(hWnd, CcEnumVLan(cm->Client, &e)))
{
LVB *b = LvInsertStart();
UINT i;
for (i = 0;i < e.NumItem;i++)
{
wchar_t name[MAX_SIZE];
wchar_t mac[MAX_SIZE];
wchar_t ver[MAX_SIZE];
char str[MAX_SIZE];
wchar_t *status;
RPC_CLIENT_ENUM_VLAN_ITEM *v = e.Items[i];
// Device name
CmVLanNameToPrintName(str, sizeof(str), v->DeviceName);
StrToUni(name, sizeof(name), str);
// Status
status = v->Enabled ? _UU("CM_VLAN_ENABLED") : _UU("CM_VLAN_DISABLED");
// MAC address
StrToUni(mac, sizeof(mac), v->MacAddress);
// Version
StrToUni(ver, sizeof(ver), v->Version);
LvInsertAdd(b, v->Enabled ? ICO_NIC_ONLINE : ICO_NIC_OFFLINE, NULL, 4,
name, status, mac, ver);
}
LvInsertEnd(b, hWnd, L_VLAN);
CiFreeClientEnumVLan(&e);
}
}
// Get a protocol name string
wchar_t *CmGetProtocolName(UINT n)
{
return GetProtocolName(n);
}
// Display update
void CmRefresh(HWND hWnd)
{
CmRefreshEx(hWnd, false);
}
void CmRefreshEx(HWND hWnd, bool style_changed)
{
// Validate arguments
if (hWnd == NULL)
{
return;
}
// Update size
CmMainWindowOnSize(hWnd);
// Updating the VLAN list
CmRefreshVLanListEx(hWnd, style_changed);
// Update the account list
CmRefreshAccountListEx2(hWnd, false, style_changed);
// Update the status bar
CmRefreshStatusBar(hWnd);
}
// Determine whether to check the specified menu item
bool CmIsChecked(UINT id)
{
switch (id)
{
case CMD_TRAYICON:
return cm->HideTrayIcon == false;
case CMD_STATUSBAR:
return cm->HideStatusBar == false;
case CMD_VISTASTYLE:
return cm->VistaStyle;
case CMD_ICON:
return cm->IconView;
case CMD_DETAIL:
return cm->IconView == false;
case CMD_GRID:
return cm->ShowGrid;
case CMD_VOIDE_NONE:
return cm->DisableVoice;
case CMD_SHOWPORT:
return cm->ShowPort;
case CMD_VOICE_NORMAL:
if (cm->DisableVoice)
{
return false;
}
else
{
return cm->VoiceId == VOICE_SSK;
}
case CMD_VOICE_ODD:
if (cm->DisableVoice)
{
return false;
}
else
{
return cm->VoiceId == VOICE_AHO;
}
}
return false;
}
// The menu popped-up
void CmMainWindowOnPopupMenu(HWND hWnd, HMENU hMenu, UINT pos)
{
UINT num_menu, i, id;
// Validate arguments
if (hWnd == NULL || hMenu == NULL)
{
return;
}
num_menu = GetMenuItemCount(hMenu);
for (i = 0;i < num_menu;i++)
{
id = GetMenuItemID(hMenu, i);
if (id != INFINITE)
{
bool enable_flag = CmIsEnabled(hWnd, id);
bool checked_flag = CmIsChecked(id);
bool bold_flag = CmIsBold(id);
MENUITEMINFO info;
Zero(&info, sizeof(info));
info.cbSize = sizeof(info);
info.fMask = MIIM_STATE;
info.fState = (enable_flag ? MFS_ENABLED : MFS_DISABLED) |
(checked_flag ? MFS_CHECKED : MFS_UNCHECKED) |
(bold_flag ? MFS_DEFAULT : 0);
if (id == CMD_ICON || id == CMD_DETAIL || id == CMD_VOIDE_NONE ||
id == CMD_VOICE_NORMAL || id == CMD_VOICE_ODD)
{
info.fMask |= MIIM_FTYPE;
info.fType = MFT_RADIOCHECK;
}
SetMenuItemInfo(hMenu, id, false, &info);
}
if (id == CMD_RECENT)
{
HMENU sub = CmCreateRecentSubMenu(hWnd, CM_TRAY_MENU_RECENT_ID_START);
if (sub != NULL)
{
DeleteMenu(hMenu, i, MF_BYPOSITION);
MsInsertMenu(hMenu, i, MF_BYPOSITION | MF_ENABLED | MF_POPUP | MF_STRING,
(UINT_PTR)sub, _UU("CM_TRAY_MENU_RECENT"));
}
else
{
MENUITEMINFO info;
Zero(&info, sizeof(info));
info.cbSize = sizeof(info);
info.fMask = MIIM_STATE;
info.fState = MFS_DISABLED;
SetMenuItemInfo(hMenu, id, false, &info);
}
}
}
}
// Set the main window title
wchar_t *CmGenerateMainWindowTitle()
{
wchar_t tmp[MAX_SIZE];
if (cm->server_name == NULL)
{
UniFormat(tmp, sizeof(tmp), L"%s", _UU("CM_TITLE"));
}
else
{
UniFormat(tmp, sizeof(tmp), L"%s - %S", _UU("CM_TITLE"), cm->server_name);
}
return CopyUniStr(tmp);
}
// Initialize the task tray
void CmInitTray(HWND hWnd)
{
bool ret;
// Validate arguments
if (hWnd == NULL)
{
return;
}
if (cm->server_name != NULL)
{
return;
}
if (cm->TrayInited)
{
return;
}
ret = MsShowIconOnTray(hWnd, LoadSmallIcon(CmGetTrayIconId(false, 0)), _UU("CM_TRAY_INITING"), WM_CM_TRAY_MESSAGE);
cm->TrayInited = true;
cm->TrayAnimation = false;
cm->TraySucceed = ret;
SetTimer(hWnd, 2, CM_TRAY_ANIMATION_INTERVAL / 4, NULL);
}
// Change the string in the task tray
void CmChangeTrayString(HWND hWnd, wchar_t *str)
{
// Validate arguments
if (hWnd == NULL || str == NULL)
{
return;
}
if (cm->TrayInited == false)
{
return;
}
MsChangeIconOnTray(NULL, str);
}
// Release the task tray
void CmFreeTray(HWND hWnd)
{
// Validate arguments
if (hWnd == NULL)
{
return;
}
if (cm->TrayInited == false)
{
return;
}
MsHideIconOnTray();
cm->TrayInited = false;
}
void CmFreeTrayExternal(void *hWnd)
{
CmFreeTray((HWND)hWnd);
}
// Periodical processing to the task tray
void CmPollingTray(HWND hWnd)
{
UINT interval;
bool ret;
// Validate arguments
if (hWnd == NULL)
{
return;
}
if (cm->TrayInited == false)
{
return;
}
ret = MsChangeIconOnTrayEx(LoadSmallIcon(CmGetTrayIconId(cm->TrayAnimation, cm->TrayAnimationCounter)),
NULL, NULL, NULL, NIIF_NONE, !cm->TraySucceed);
if (cm->TraySucceed == false)
{
cm->TraySucceed = ret;
}
cm->TrayAnimationCounter++;
KillTimer(hWnd, 2);
interval = CM_TRAY_ANIMATION_INTERVAL / 4;
if (cm->TraySpeedAnimation)
{
interval /= 4;
}
SetTimer(hWnd, 2, interval, NULL);
}
// Get the icon ID of the task tray for animation
UINT CmGetTrayIconId(bool animation, UINT animation_counter)
{
if (animation == false)
{
return ICO_TRAY0;
}
else
{
switch (animation_counter % 4)
{
case 0:
return ICO_TRAY1;
case 1:
return ICO_TRAY2;
case 2:
return ICO_TRAY3;
default:
return ICO_TRAY4;
}
}
}
// Initialize the main window
void CmMainWindowOnInit(HWND hWnd)
{
wchar_t *s;
BUF *b;
bool startup_mode = cm->StartupMode;
CM_SETTING a;
bool fake = false;
// Validate arguments
if (hWnd == NULL)
{
return;
}
// Font settings of list
SetFontMeiryo(hWnd, L_ACCOUNT, 9);
SetFontMeiryo(hWnd, L_VLAN, 9);
// Get the configuration of the current vpnclient
Zero(&a, sizeof(a));
CcGetCmSetting(cm->Client, &a);
if (a.EasyMode)
{
fake = true;
}
InitMenuInternational(GetMenu(hWnd), "CM_MENU");
cm->HideStatusBar = MsRegReadInt(REG_CURRENT_USER, CM_REG_KEY, "HideStatusBar");
cm->HideTrayIcon = MsRegReadInt(REG_CURRENT_USER, CM_REG_KEY, "HideTrayIcon");
cm->IconView = MsRegReadInt(REG_CURRENT_USER, CM_REG_KEY, "IconView");
cm->ShowGrid = MsRegReadInt(REG_CURRENT_USER, CM_REG_KEY, "ShowGrid");
if (MsRegIsValue(REG_CURRENT_USER, CM_REG_KEY, "VistaStyle"))
{
cm->VistaStyle = MsRegReadInt(REG_CURRENT_USER, CM_REG_KEY, "VistaStyle");
}
else
{
cm->VistaStyle = MsIsVista();
}
if (MsRegIsValue(REG_CURRENT_USER, CM_REG_KEY, "ShowPort"))
{
cm->ShowPort = MsRegReadInt(REG_CURRENT_USER, CM_REG_KEY, "ShowPort");
}
else
{
cm->ShowPort = false;
}
if (MsRegIsValue(REG_CURRENT_USER, CM_REG_KEY, "DisableVoice"))
{
cm->DisableVoice = MsRegReadInt(REG_CURRENT_USER, CM_REG_KEY, "DisableVoice");
}
else
{
cm->DisableVoice = true;
}
cm->VoiceId = MsRegReadInt(REG_CURRENT_USER, CM_REG_KEY, "VoiceId");
cm->StatusWindowList = NewList(NULL);
SetIcon(hWnd, 0, ICO_VPN);
s = CmGenerateMainWindowTitle();
SetText(hWnd, 0, s);
Free(s);
// Initialize the window position
b = MsRegReadBin(REG_CURRENT_USER, CM_REG_KEY, "WindowPlacement");
if (b != NULL && b->Size == sizeof(WINDOWPLACEMENT))
{
// Restore the window position
WINDOWPLACEMENT *p;
p = ZeroMalloc(b->Size);
Copy(p, b->Buf, b->Size);
if (startup_mode)
{
p->showCmd = SW_SHOWMINIMIZED;
}
if (fake)
{
Copy(&cm->FakeWindowPlacement, p, sizeof(WINDOWPLACEMENT));
}
else
{
SetWindowPlacement(hWnd, p);
}
Free(p);
}
else
{
// Initialize the window position
SetWindowPos(hWnd, NULL, 0, 0, CM_DEFAULT_WIDTH, CM_DEFAULT_HEIGHT, SWP_NOREDRAW);
Center(hWnd);
if (startup_mode)
{
ShowWindow(hWnd, SW_SHOWMINIMIZED);
}
if (fake)
{
WINDOWPLACEMENT p;
Zero(&p, sizeof(p));
p.length = sizeof(p);
GetWindowPlacement(hWnd, &p);
Copy(&cm->FakeWindowPlacement, &p, sizeof(WINDOWPLACEMENT));
}
}
FreeBuf(b);
if (fake)
{
SetWindowPos(hWnd, NULL, -200, -200, 100, 100,
SWP_NOREDRAW | SWP_SHOWWINDOW);
}
// Initialize the status bar related items
cm->hMainWnd = hWnd;
cm->hStatusBar = CreateStatusWindowW(WS_CHILD |
(cm->HideStatusBar == false ? WS_VISIBLE : 0),
_UU("CM_TITLE"),
hWnd, S_STATUSBAR);
UniStrCpy(cm->StatudBar1, sizeof(cm->StatudBar1), _UU("CM_TITLE"));
UniStrCpy(cm->StatudBar2, sizeof(cm->StatudBar2), _UU("CM_CONN_NO"));
UniFormat(cm->StatudBar3, sizeof(cm->StatudBar3), _UU("CM_PRODUCT_NAME"), CEDAR_BUILD);
cm->Icon2 = LoadSmallIcon(ICO_SERVER_OFFLINE);
cm->Icon3 = LoadSmallIcon(ICO_VPN);
// Initialize the account list
CmInitAccountList(hWnd);
// Initialize the VLAN list
CmInitVLanList(hWnd);
// Display update
CmRefreshEx(hWnd, true);
// Start a thread of notification client
CmInitNotifyClientThread();
// Timer setting
SetTimer(hWnd, 1, 128, NULL);
SetTimer(hWnd, 6, 5000, NULL);
// Initialize the task tray
if (cm->server_name == NULL)
{
if (cm->HideTrayIcon == false)
{
CmInitTray(hWnd);
}
}
CmVoice("start");
if (startup_mode || a.EasyMode)
{
SetTimer(hWnd, 3, 1, NULL);
}
if (cm->import_file_name != NULL)
{
// Import a file specified as an argument
CmSendImportMessage(hWnd, cm->import_file_name, cm->CmSettingInitialFlag == CM_SETTING_INIT_NONE ? CM_IMPORT_FILENAME_MSG : CM_IMPORT_FILENAME_MSG_OVERWRITE);
/*if (a.LockMode == false)
{
CmImportAccountMainEx(hWnd, cm->import_file_name, cm->CmSettingInitialFlag != CM_SETTING_INIT_NONE);
}
else
{
MsgBox(cm->hEasyWnd ? cm->hEasyWnd : hWnd, MB_ICONEXCLAMATION, _UU("CM_VPN_FILE_IMPORT_NG"));
}*/
}
// Apply the CM_SETTING
CmApplyCmSetting();
cm->StartupFinished = true;
}
// Start a thread of notification client
void CmInitNotifyClientThread()
{
cm->NotifyClient = CcConnectNotify(cm->Client);
if (cm->NotifyClient == false)
{
Close(cm->hMainWnd);
exit(0);
}
cm->NotifyClientThread = NewThread(CmNotifyClientThread, NULL);
}
// Notification client thread
void CmNotifyClientThread(THREAD *thread, void *param)
{
NOTIFY_CLIENT *nc;
// Validate arguments
if (thread == NULL)
{
return;
}
nc = cm->NotifyClient;
// Wait for the next notification
while (cm->Halt == false)
{
if (CcWaitNotify(nc))
{
// Send a message
PostMessage(cm->hMainWnd, WM_CM_NOTIFY, 0, 0);
}
else
{
// Disconnected
if (cm->Halt == false)
{
if (cm != NULL)
{
CmFreeTrayExternal((void *)cm->hMainWnd);
}
CncExit();
exit(0);
}
break;
}
}
}
// Stop the thread of the notification client
void CmFreeNotifyClientThread()
{
cm->Halt = true;
// Disconnect
CcStopNotify(cm->NotifyClient);
// Wait for the termination of the thread
WaitThread(cm->NotifyClientThread, INFINITE);
// Connection termination
CcDisconnectNotify(cm->NotifyClient);
ReleaseThread(cm->NotifyClientThread);
}
// Resize the main window
void CmMainWindowOnSize(HWND hWnd)
{
RECT r;
UINT client_width, client_height;
UINT status_height;
// Validate arguments
if (hWnd == NULL)
{
return;
}
// Get the size of the client area of the main window
GetClientRect(hWnd, &r);
client_width = MAX(r.right - r.left, 0);
client_height = MAX(r.bottom - r.top, 0);
SendMsg(hWnd, S_STATUSBAR, WM_SIZE, 0, 0);
// Get the size of the status bar
GetWindowRect(DlgItem(hWnd, S_STATUSBAR), &r);
status_height = MAX(r.bottom - r.top, 0);
if (cm->HideStatusBar == false)
{
client_height = MAX(client_height - status_height, 0);
}
MoveWindow(DlgItem(hWnd, L_ACCOUNT), 0, 0, client_width, client_height * 3 / 5 - 3, true);
MoveWindow(DlgItem(hWnd, L_VLAN), 0, client_height * 3 / 5, client_width, client_height * 2 / 5, true);
// Re-draw the status bar
CmRedrawStatusBar(hWnd);
}
// Disconnect all accounts currently connected
void CmDisconnectAll(HWND hWnd)
{
UINT i, num;
LIST *o;
// Validate arguments
if (hWnd == NULL)
{
return;
}
// Display a warning
num = CmGetNumConnected(hWnd);
if (num == 0)
{
return;
}
if (MsgBoxEx(hWnd, MB_ICONEXCLAMATION | MB_YESNO | MB_DEFBUTTON2, _UU("CM_DISCONNECT_ALL"), num) == IDNO)
{
return;
}
cm->PositiveDisconnectFlag = true;
// Create a list of connected items
o = NewListFast(NULL);
num = LvNum(hWnd, L_ACCOUNT);
for (i = 0;i < num;i++)
{
wchar_t *s = LvGetStr(hWnd, L_ACCOUNT, i, 1);
if (s != NULL)
{
if (UniStrCmpi(s, _UU("CM_ACCOUNT_ONLINE")) == 0 || UniStrCmpi(s, _UU("CM_ACCOUNT_CONNECTING")) == 0)
{
Add(o, LvGetStr(hWnd, L_ACCOUNT, i, 0));
}
Free(s);
}
}
for (i = 0;i < LIST_NUM(o);i++)
{
wchar_t *s = LIST_DATA(o, i);
if (s != NULL)
{
CmDisconnect(hWnd, s);
Free(s);
}
}
ReleaseList(o);
}
// Get a number of currently connected connection settings
UINT CmGetNumConnected(HWND hWnd)
{
UINT i, num, num_active;
// Validate arguments
if (hWnd == NULL)
{
return 0;
}
num_active = 0;
num = LvNum(hWnd, L_ACCOUNT);
for (i = 0;i < num;i++)
{
wchar_t *s = LvGetStr(hWnd, L_ACCOUNT, i, 1);
if (s != NULL)
{
if (UniStrCmpi(s, _UU("CM_ACCOUNT_ONLINE")) == 0 || UniStrCmpi(s, _UU("CM_ACCOUNT_CONNECTING")) == 0)
{
num_active++;
}
Free(s);
}
}
return num_active;
}
// Update the status bar information
void CmRefreshStatusBar(HWND hWnd)
{
UINT num_active = CmGetNumConnected(hWnd);
// Validate arguments
if (hWnd == NULL)
{
return;
}
if (num_active == 0)
{
UniStrCpy(cm->StatudBar2, sizeof(cm->StatudBar2), _UU("CM_CONN_NO"));
cm->Icon2 = LoadSmallIcon(ICO_SERVER_OFFLINE);
}
else
{
UniFormat(cm->StatudBar2, sizeof(cm->StatudBar2), _UU("CM_NUM_CONN_COUNT"), num_active);
cm->Icon2 = LoadSmallIcon(ICO_SERVER_ONLINE);
}
CmRedrawStatusBar(hWnd);
}
// Re-draw the status bar
void CmRedrawStatusBar(HWND hWnd)
{
HWND h;
RECT r;
int width;
int x1, x2, x3;
int xx[3];
wchar_t tmp[MAX_SIZE];
HICON icon;
// Validate arguments
if (hWnd == NULL)
{
return;
}
h = cm->hStatusBar;
// Get the width of the status bar
GetWindowRect(h, &r);
width = MAX(r.right - r.left, 0);
x2 = (UINT)(180.0 * GetTextScalingFactor());
x3 = (UINT)(245.0 * GetTextScalingFactor());
x1 = MAX(width - x2 - x3, 0);
// Divide into three parts
xx[0] = x1;
xx[1] = x2 + x1;
xx[2] = x3 + x2 + x1;
SendMsg(h, 0, SB_SETPARTS, 3, (LPARAM)xx);
// Set an icon
icon = (HICON)SendMsg(h, 0, SB_GETICON, 1, 0);
if (icon != cm->Icon2)
{
SendMsg(h, 0, SB_SETICON, 1, (LPARAM)cm->Icon2);
}
icon = (HICON)SendMsg(h, 0, SB_GETICON, 2, 0);
if (icon != cm->Icon3)
{
SendMsg(h, 0, SB_SETICON, 2, (LPARAM)cm->Icon3);
}
// Set a string
SendMsg(h, 0, SB_GETTEXTW, 0, (LPARAM)tmp);
if (UniStrCmp(tmp, cm->StatudBar1))
{
SendMsg(h, 0, SB_SETTEXTW, 0, (LPARAM)cm->StatudBar1);
}
SendMsg(h, 0, SB_GETTEXTW, 1, (LPARAM)tmp);
if (UniStrCmp(tmp, cm->StatudBar2))
{
SendMsg(h, 0, SB_SETTEXTW, 1, (LPARAM)cm->StatudBar2);
}
SendMsg(h, 0, SB_GETTEXTW, 2, (LPARAM)tmp);
if (UniStrCmp(tmp, cm->StatudBar3))
{
SendMsg(h, 0, SB_SETTEXTW, 2, (LPARAM)cm->StatudBar3);
}
}
// Save the position information of the main window
void CmSaveMainWindowPos(HWND hWnd)
{
WINDOWPLACEMENT p;
// Validate arguments
if (hWnd == NULL)
{
return;
}
// Save settings
MsRegWriteInt(REG_CURRENT_USER, CM_REG_KEY, "HideStatusBar", cm->HideStatusBar);
MsRegWriteInt(REG_CURRENT_USER, CM_REG_KEY, "HideTrayIcon", cm->HideTrayIcon);
MsRegWriteInt(REG_CURRENT_USER, CM_REG_KEY, "IconView", cm->IconView);
MsRegWriteInt(REG_CURRENT_USER, CM_REG_KEY, "ShowGrid", cm->ShowGrid);
MsRegWriteInt(REG_CURRENT_USER, CM_REG_KEY, "DisableVoice", cm->DisableVoice);
MsRegWriteInt(REG_CURRENT_USER, CM_REG_KEY, "VoiceId", cm->VoiceId);
MsRegWriteInt(REG_CURRENT_USER, CM_REG_KEY, "VistaStyle", cm->VistaStyle);
MsRegWriteInt(REG_CURRENT_USER, CM_REG_KEY, "ShowPort", cm->ShowPort);
// Save the window position
Zero(&p, sizeof(p));
p.length = sizeof(p);
GetWindowPlacement(hWnd, &p);
if (IsZero(&cm->FakeWindowPlacement, sizeof(cm->FakeWindowPlacement)) == false)
{
Copy(&p, &cm->FakeWindowPlacement, sizeof(cm->FakeWindowPlacement));
}
MsRegWriteBin(REG_CURRENT_USER, CM_REG_KEY, "WindowPlacement", &p, sizeof(p));
CmSaveAccountListPos(hWnd);
CmSaveVLanListPos(hWnd);
}
// Close the main window
void CmMainWindowOnQuit(HWND hWnd)
{
UINT i;
// Validate arguments
if (hWnd == NULL)
{
return;
}
if (cm->TrayInited)
{
if (MsgBox(hWnd, MB_YESNO | MB_ICONQUESTION,
_UU("CM_EXIT_MESSAGE")) == IDNO)
{
return;
}
}
if (cm->OnCloseDispatched)
{
return;
}
cm->OnCloseDispatched = true;
CmCloseEasy();
// Release the tray icon
CmFreeTray(hWnd);
// Save the position information of the main window
CmSaveMainWindowPos(hWnd);
// Close the status window
for (i = 0;i < LIST_NUM(cm->StatusWindowList);i++)
{
HWND h = LIST_DATA(cm->StatusWindowList, i);
//EndDialog(h, 0);
PostMessage(h, WM_CLOSE, 0, 0);
}
ReleaseList(cm->StatusWindowList);
cm->StatusWindowList = NULL;
if (cm->WindowCount != 0)
{
// Abort
exit(0);
}
// Close
CmFreeNotifyClientThread();
EndDialog(hWnd, false);
}
// Start the mutex to be used in starting
bool CmStartStartupMutex()
{
INSTANCE *o = NewSingleInstance(STARTUP_MUTEX_NAME);
if (o == NULL)
{
return false;
}
cm->StartupMutex = o;
return true;
}
// Release the mutex to be used in starting
void CmEndStartupMutex()
{
if (cm->StartupMutex != NULL)
{
FreeSingleInstance(cm->StartupMutex);
cm->StartupMutex = NULL;
}
}
// Main window
void MainCMWindow()
{
HWND h;
wchar_t *s;
CM_SETTING a;
if (CmStartStartupMutex() == false)
{
return;
}
s = CmGenerateMainWindowTitle();
h = SearchWindow(s);
Free(s);
Zero(&a, sizeof(a));
CcGetCmSetting(cm->Client, &a);
if (cm->server_name != NULL && a.EasyMode)
{
CmEndStartupMutex();
MsgBox(NULL, MB_ICONEXCLAMATION, _UU("CM_EASY_MODE_NOT_ON_REMOTE"));
return;
}
// Change the operating mode
if (cm->CmSettingSupported)
{
if (cm->CmSettingInitialFlag == CM_SETTING_INIT_SELECT)
{
if (h != NULL)
{
CmEndStartupMutex();
}
// Show the selection screen
CmSetting(NULL);
if (h != NULL)
{
goto SEND_MESSAGES;
}
else
{
return;
}
}
else if ((cm->CmSettingInitialFlag == CM_SETTING_INIT_EASY && cm->CmEasyModeSupported) || cm->CmSettingInitialFlag == CM_SETTING_INIT_NORMAL)
{
// State transition
CM_SETTING a;
Zero(&a, sizeof(a));
CcGetCmSetting(cm->Client, &a);
if (cm->CmSettingInitialFlag == CM_SETTING_INIT_EASY)
{
a.EasyMode = true;
}
else
{
a.EasyMode = false;
}
CcSetCmSetting(cm->Client, &a);
}
}
if (h == NULL)
{
// Create a window because there is no window of the same title
if (cm->server_name == NULL)
{
CmInitTryToExecUiHelper();
if (IsDebug() == false)
{
CnWaitForCnServiceReady();
}
}
Dialog(NULL, D_CM_MAIN, CmMainWindowProc, NULL);
CmFreeTryToExecUiHelper();
}
else
{
SEND_MESSAGES:
CmEndStartupMutex();
// If a window of the same title already exists, activate it and exit itself
SetForegroundWindow(h);
SendMessage(h, WM_CM_SHOW, 0, 0);
SetForegroundWindow(h);
if (cm->CmSettingInitialFlag != CM_SETTING_INIT_NONE && cm->CmSettingInitialFlag != CM_SETTING_INIT_CONNECT)
{
// Notify since CM_SETTING has been changed
SendMessage(h, WM_CM_SETTING_CHANGED_MESSAGE, 0, 0);
}
if (cm->import_file_name != NULL)
{
UINT msg;
if (cm->CmSettingInitialFlag == CM_SETTING_INIT_NONE)
{
msg = CM_IMPORT_FILENAME_MSG;
}
else
{
msg = CM_IMPORT_FILENAME_MSG_OVERWRITE;
}
CmSendImportMessage(h, cm->import_file_name, msg);
}
}
CmEndStartupMutex();
}
// Send an import message
void CmSendImportMessage(HWND hWnd, wchar_t *filename, UINT msg)
{
COPYDATASTRUCT cpy;
// Validate arguments
if (hWnd == NULL || filename == NULL)
{
return;
}
// Specify the file to be imported
Zero(&cpy, sizeof(cpy));
cpy.cbData = UniStrSize(filename);
cpy.lpData = filename;
cpy.dwData = msg;
SendMessage(hWnd, WM_COPYDATA, 0, (LPARAM)&cpy);
}
// Login dialog
UINT CmLoginDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
{
// Validate arguments
wchar_t server_name[MAX_SIZE];
char password[MAX_PASSWORD_LEN + 1];
bool bad_pass;
if (hWnd == NULL)
{
return 0;
}
switch (msg)
{
case WM_INITDIALOG:
if (cm->server_name != NULL)
{
StrToUni(server_name, sizeof(server_name), cm->server_name);
}
else
{
UniStrCpy(server_name, sizeof(server_name), _UU("CM_PW_LOCALMACHINE"));
}
FormatText(hWnd, S_TITLE, server_name);
break;
case WM_COMMAND:
switch (wParam)
{
case IDOK:
if (cm->server_name != NULL)
{
StrToUni(server_name, sizeof(server_name), cm->server_name);
}
else
{
UniStrCpy(server_name, sizeof(server_name), _UU("CM_PW_LOCALMACHINE"));
}
GetTxtA(hWnd, E_PASSWORD, password, sizeof(password));
cm->Client = CcConnectRpc(cm->server_name == NULL ? "127.0.0.1" : cm->server_name,
password, &bad_pass, NULL, 0);
if (cm->Client == NULL)
{
MsgBox(hWnd, MB_ICONSTOP, _UU("CM_BAD_PASSWORD"));
FocusEx(hWnd, E_PASSWORD);
}
else
{
EndDialog(hWnd, true);
}
break;
case IDCANCEL:
Close(hWnd);
break;
}
break;
case WM_CLOSE:
EndDialog(hWnd, false);
break;
}
return 0;
}
// Login
bool LoginCM()
{
// Try to login with an empty password first
bool bad_pass, no_remote;
wchar_t server_name[MAX_SIZE];
RPC_CLIENT_VERSION a;
RETRY:
if (cm->server_name != NULL)
{
StrToUni(server_name, sizeof(server_name), cm->server_name);
}
else
{
UniStrCpy(server_name, sizeof(server_name), _UU("CM_PW_LOCALMACHINE"));
}
// Attempt to connect
if ((cm->Client = CcConnectRpc(
cm->server_name == NULL ? "localhost" : cm->server_name,
cm->password == NULL ? "" : cm->password, &bad_pass, &no_remote, cm->StartupMode == false ? 0 : 60000)) == NULL)
{
if (no_remote)
{
// Remote connection was denied
if (MsgBoxEx(NULL, MB_ICONEXCLAMATION | MB_RETRYCANCEL, _UU("CM_NO_REMOTE"), server_name) == IDRETRY)
{
// Retry
goto RETRY;
}
else
{
return false;
}
}
else if (bad_pass)
{
if (Dialog(NULL, D_CM_LOGIN, CmLoginDlgProc, NULL) == false)
{
return false;
}
}
else
{
// Connection failure
if (cm->StartupMode == false && MsgBoxEx(NULL, MB_ICONEXCLAMATION | MB_RETRYCANCEL, _UU("CM_CONNECT_FAILED"), server_name) == IDRETRY)
{
// Retry
goto RETRY;
}
else
{
return false;
}
}
}
Zero(&a, sizeof(a));
CcGetClientVersion(cm->Client, &a);
if (a.ClientBuildInt >= 5192)
{
cm->CmSettingSupported = true;
cm->CmEasyModeSupported = true;
if (OS_IS_WINDOWS_9X(a.OsType))
{
cm->CmEasyModeSupported = false;
}
}
return true;
}
// Main process
void MainCM()
{
// If there is /remote in the argument, show the screen of the remote connection
TOKEN_LIST *cmdline = GetCommandLineToken();
UINT i = 0;
bool isRemote = false;
if (cm->server_name != NULL)
{
Free(cm->server_name);
}
cm->server_name = NULL;
if (cm->password != NULL)
{
Free(cm->password);
}
cm->password = NULL;
for(i = 0; i < cmdline->NumTokens; ++i)
{
if (StrCmpi(cmdline->Token[i], "/remote") == 0)
{
isRemote = true;
}
else if (StrCmpi(cmdline->Token[i], "/hostname") == 0 && i + 1 < cmdline->NumTokens)
{
isRemote = true;
if (cm->server_name != NULL)
{
Free(cm->server_name);
}
cm->server_name = CopyStr(cmdline->Token[++i]);
}
else if (StrCmpi(cmdline->Token[i], "/password") == 0 && i + 1 < cmdline->NumTokens)
{
if (cm->password != NULL)
{
Free(cm->password);
}
cm->password = CopyStr(cmdline->Token[++i]);
}
else if (StrCmpi(cmdline->Token[i], "/startup") == 0)
{
// Startup mode
cm->StartupMode = true;
}
}
if (isRemote && cm->server_name == NULL)
{
char *hostname = RemoteDlg(NULL, CM_REG_KEY, ICO_VPN, _UU("CM_TITLE"), _UU("CM_REMOTE_TITLE"), NULL);
if (hostname == NULL)
{
return;
}
if (cm->server_name != NULL)
{
Free(cm->server_name);
}
cm->server_name = NULL;
if (StrCmpi(hostname, "localhost") != 0 && StrCmpi(hostname, "127.0.0.1") != 0 )
{
cm->server_name = hostname;
}
}
FreeToken(cmdline);
if (IsZero(cm->ShortcutKey, SHA1_SIZE) == false)
{
//if (MsGetCurrentTerminalSessionId() == 0)
{
// Start the shortcut connection
CmConnectShortcut(cm->ShortcutKey);
}/*
else
{
MsgBoxEx(NULL, MB_ICONEXCLAMATION, _UU("CM_SHORTCUT_DESKTOP_MSG"),
MsGetCurrentTerminalSessionId());
}*/
return;
}
// Login
if (LoginCM() == false)
{
return;
}
//Update the jump list
CmUpdateJumpList(0);
// Main window
MainCMWindow();
// Log out
LogoutCM();
if (cm->Update != NULL)
{
FreeUpdateUi(cm->Update);
cm->Update = NULL;
}
}
// Log out
void LogoutCM()
{
if (cm->Client != NULL)
{
CcDisconnectRpc(cm->Client);
}
}
// Client Connection Manager start function
void CMExec()
{
// Initialize
InitCM(true);
// Main process
MainCM();
// Release
FreeCM();
}
// HUB enumeration thread
void CmEnumHubThread(THREAD *t, void *param)
{
CM_ENUM_HUB *e = (CM_ENUM_HUB *)param;
HWND hWnd;
// Validate arguments
if (t == NULL || param == NULL)
{
return;
}
e->Thread = t;
hWnd = e->hWnd;
LockList(cm->EnumHubList);
{
Add(cm->EnumHubList, e);
}
UnlockList(cm->EnumHubList);
// Thread initialization is completed
NoticeThreadInit(t);
// Create a session
e->Session = NewRpcSession(cm->Cedar, e->ClientOption);
if (e->Session)
{
// Enumeration of HUB
e->Hub = EnumHub(e->Session);
if (e->Hub != NULL)
{
// Enumeration completed
// Add to the combo box
if (CbNum(hWnd, C_HUBNAME) == 0)
{
UINT i;
wchar_t tmp[MAX_SIZE];
for (i = 0;i < e->Hub->NumTokens;i++)
{
StrToUni(tmp, sizeof(tmp), e->Hub->Token[i]);
CbAddStr(hWnd, C_HUBNAME, tmp, 0);
}
}
// Release the memory
FreeToken(e->Hub);
}
// Release the session
ReleaseSession(e->Session);
}
LockList(cm->EnumHubList);
{
Delete(cm->EnumHubList, e);
}
UnlockList(cm->EnumHubList);
Free(e->ClientOption);
Free(e);
}
// The start of the HUB enumeration
void CmEnumHubStart(HWND hWnd, CLIENT_OPTION *o)
{
CM_ENUM_HUB *e;
THREAD *t;
// Validate arguments
if (hWnd == NULL || o == NULL)
{
return;
}
if (StrLen(o->Hostname) == 0 ||
o->Port == 0)
{
return;
}
if (o->ProxyType != PROXY_DIRECT)
{
if (StrLen(o->ProxyName) == 0 ||
o->ProxyPort == 0)
{
return;
}
}
if (LvNum(hWnd, C_HUBNAME) != 0)
{
return;
}
e = ZeroMalloc(sizeof(CM_ENUM_HUB));
e->ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
e->hWnd = hWnd;
Copy(e->ClientOption, o, sizeof(CLIENT_OPTION));
t = NewThread(CmEnumHubThread, e);
WaitThreadInit(t);
ReleaseThread(t);
}
// Initialize the HUB enumeration process
void CmInitEnumHub()
{
cm->EnumHubList = NewList(NULL);
}
// Release the HUB enumeration process
void CmFreeEnumHub()
{
LIST *o;
UINT i;
if (cm->EnumHubList == NULL)
{
return;
}
o = NewList(NULL);
LockList(cm->EnumHubList);
{
UINT i;
for (i = 0;i < LIST_NUM(cm->EnumHubList);i++)
{
CM_ENUM_HUB *e = LIST_DATA(cm->EnumHubList, i);
Add(o, e->Thread);
AddRef(e->Thread->ref);
}
}
UnlockList(cm->EnumHubList);
for (i = 0;i < LIST_NUM(o);i++)
{
THREAD *t = LIST_DATA(o, i);
WaitThread(t, INFINITE);
ReleaseThread(t);
}
ReleaseList(o);
ReleaseList(cm->EnumHubList);
}
// Initialize the Client Connection Manager
void InitCM(bool set_app_id)
{
UNI_TOKEN_LIST *ut;
if (cm != NULL)
{
return;
}
if (set_app_id)
{
if(JL_SetCurrentProcessExplicitAppUserModelID(APPID_CM) != S_OK)
{
}
}
CmDeleteOldStartupTrayFile();
MsSetShutdownParameters(0x4ff, SHUTDOWN_NORETRY);
// Memory allocation
cm = ZeroMalloc(sizeof(CM));
// If the command line argument is set treat it as a server name
ut = GetCommandLineUniToken();
if (ut->NumTokens >= 1)
{
if (UniStrLen(ut->Token[0]) != 0)
{
if (UniStrCmpi(ut->Token[0], L"cm") != 0 && ut->Token[0][0] != L'/')
{
BUF *b = UniStrToBin(ut->Token[0]);
if (b->Size == SHA1_SIZE)
{
// Treated as a shortcut key for the connection settings
Copy(cm->ShortcutKey, b->Buf, SHA1_SIZE);
}
else
{
if (UniEndWith(ut->Token[0], L".vpn") == false)
{
// Treated as a server name
cm->server_name = CopyUniToStr(ut->Token[0]);
}
else
{
// Treated as import file name
cm->import_file_name = CopyUniStr(ut->Token[0]);
}
}
FreeBuf(b);
}
else if (UniStrCmpi(ut->Token[0], L"/easy") == 0)
{
// Simple mode
if (ut->NumTokens >= 2)
{
// Connection settings to be imported is specified
cm->import_file_name = CopyUniStr(ut->Token[1]);
}
cm->CmSettingInitialFlag = CM_SETTING_INIT_EASY;
}
else if (UniStrCmpi(ut->Token[0], L"/normal") == 0)
{
// Normal mode
if (ut->NumTokens >= 2)
{
// Connection settings to be imported is specified
cm->import_file_name = CopyUniStr(ut->Token[1]);
}
cm->CmSettingInitialFlag = CM_SETTING_INIT_NORMAL;
}
else if (UniStrCmpi(ut->Token[0], L"/connect") == 0)
{
// Import process by the simple installer
if (ut->NumTokens >= 2)
{
// Connection settings to be imported is specified
cm->import_file_name = CopyUniStr(ut->Token[1]);
}
cm->CmSettingInitialFlag = CM_SETTING_INIT_CONNECT;
}
else if (UniStrCmpi(ut->Token[0], L"/select") == 0)
{
// Selection screen
cm->CmSettingInitialFlag = CM_SETTING_INIT_SELECT;
}
}
}
UniFreeToken(ut);
InitWinUi(_UU("CM_TITLE"), _SS("DEFAULT_FONT"), _II("DEFAULT_FONT_SIZE"));
// Alpha blending related
UseAlpha = MsRegReadInt(REG_CURRENT_USER, CM_REG_KEY, "UseAlpha");
AlphaValue = MsRegReadInt(REG_CURRENT_USER, CM_REG_KEY, "AlphaValue");
cm->Cedar = NewCedar(NULL, NULL);
CmInitEnumHub();
}
// Stop the Client Connection Manager
void FreeCM()
{
if (cm == NULL)
{
return;
}
CmFreeEnumHub();
ReleaseCedar(cm->Cedar);
FreeWinUi();
// Release the memory
if (cm->server_name != NULL)
{
Free(cm->server_name);
}
Free(cm);
cm = NULL;
}
//////////////////////////////////////////////////////////////////////////
//JumpList ToDo
// By Takao Ito
void *CmUpdateJumpList(UINT start_id)
{
HMENU h = NULL;
UINT i;
RPC_CLIENT_ENUM_ACCOUNT a;
LIST *o;
bool easy;
JL_PCustomDestinationList pcdl;
JL_PObjectCollection poc;
JL_PShellLink shell;
JL_PObjectArray poaRemoved;
HRESULT hr;
if (cm->server_name != NULL)
{
// Is not used in the case of an external PC
return NULL;
}
//Try to add
if(SUCCEEDED(JL_CreateCustomDestinationList(&pcdl,APPID_CM)))
{
JL_DeleteJumpList(pcdl,APPID_CM);
easy = cm->CmSetting.EasyMode;
Zero(&a, sizeof(a));
if (CcEnumAccount(cm->Client, &a) == ERR_NO_ERROR)
{
o = NewListFast(CiCompareClientAccountEnumItemByLastConnectDateTime);
for (i = 0;i < a.NumItem;i++)
{
RPC_CLIENT_ENUM_ACCOUNT_ITEM *item = a.Items[i];
item->tmp1 = i;
if (item->LastConnectDateTime != 0)
{
Add(o, item);
}
}
Sort(o);
if(LIST_NUM(o) > 0)
{
if(SUCCEEDED(JL_BeginList(pcdl, &poaRemoved)))
{
//Create a collection
if(SUCCEEDED(JL_CreateObjectCollection(&poc)))
{
for (i = 0;i < MIN(LIST_NUM(o), CM_NUM_RECENT);i++)
{
RPC_CLIENT_ENUM_ACCOUNT_ITEM *item = (RPC_CLIENT_ENUM_ACCOUNT_ITEM *)LIST_DATA(o, i);
// wchar_t tmp[MAX_PATH];
wchar_t *account_name;
char *server_name;
char *hub_name;
// CM_ACCOUNT *a;
UCHAR key[SHA1_SIZE];
RPC_CLIENT_GET_ACCOUNT c;
account_name = item->AccountName;
server_name = item->ServerName;
hub_name = item->HubName;
//
//a = CmGetExistAccountObject(hWnd, account_name);
//if (a == NULL)
//{
//continue;
//}
//Copy(key, a->ShortcutKey, SHA1_SIZE);
//
Zero(&c, sizeof(c));
UniStrCpy(c.AccountName, sizeof(c.AccountName), account_name);
if (CALL(NULL, CcGetAccount(cm->Client, &c)) == false)
{
break;
}
Copy(key, c.ShortcutKey, SHA1_SIZE);
if (IsZero(key, SHA1_SIZE))
{
//MsgBox(hWnd, MB_ICONINFORMATION, _UU("CM_SHORTCUT_UNSUPPORTED"));
}
else
{
//wchar_t target[MAX_PATH];
////wchar_t workdir[MAX_PATH];
//wchar_t args[MAX_PATH];
////wchar_t comment[MAX_SIZE];
//wchar_t icon[MAX_PATH];
char key_str[64];
wchar_t target[MAX_PATH];
//wchar_t workdir[MAX_PATH];
wchar_t args[MAX_PATH];
wchar_t commentW[MAX_SIZE];
wchar_t icon[MAX_PATH];
int iconNum;
//char icon = "C:\\Server.ico";
BinToStr(key_str, sizeof(key_str), key, SHA1_SIZE);
UniStrCpy(target, sizeof(target), MsGetExeFileNameW());
StrToUni(args, sizeof(args), key_str);
UniStrCpy(icon, sizeof(icon), MsGetExeFileNameW());
UniFormat(commentW, sizeof(commentW), _UU("CM_SHORTCUT_COMMENT"), account_name);
if(item->Connected)
{
iconNum = 1;
}
else
{
iconNum = 2;
}
hr = JL_CreateShellLink(
target,
args,
account_name,
icon,iconNum,
commentW,
&shell);
if(SUCCEEDED(hr))
{
if(SUCCEEDED(JL_ObjectCollectionAddShellLink(poc, shell)))
{
//Print("Add JumpList %d c:%s\n",i, comment);
//wprintf(comment);
}
JL_ReleaseShellLink(shell);
}
}
CiFreeClientGetAccount(&c);
}
hr = JL_AddCategoryToList(pcdl,poc,_UU("CM_JUMPLIST_RCCONNECT"),poaRemoved);
if(SUCCEEDED(hr))
{
//wprintf(L"AddCategory\n");
hr = JL_CommitList(pcdl);
if(SUCCEEDED(hr))
{
//wprintf(L"JumpList Commit\n");
}
}
else
{
//wprintf(L"Erro JumpList AddCategory %x\n", hr);
}
//Release
JL_ReleaseObjectCollection(poc);
}
}
}
ReleaseList(o);
CiFreeClientEnumAccount(&a);
}
/*
JL_BeginList(pcdl, &poaRemoved);
JL_CreateObjectCollection(&poc);
// Tesht
for (i = 0; i < 5; i++)
{
JL_CreateShellLink(
"",
"",
L"Connect",
NULL,0,
NULL,
&shell);
JL_ObjectCollectionAddShellLink(poc, shell);
JL_ReleaseShellLink(shell);
}
JL_AddCategoryToList(pcdl,poc,_UU("CM_JUMPLIST_RCCONNECT"),poaRemoved);
JL_CommitList(pcdl);
JL_ReleaseObjectCollection(poc);
JL_ReleaseCustomDestinationList(pcdl);
*/
}
return h;
}
#endif // WIN32
Reference in New Issue View Git Blame Copy Permalink