mirror of
https://github.com/SoftEtherVPN/SoftEtherVPN.git
synced 2024-11-07 18:20:41 +03:00
28e8d4bcce
With server certificate validation enabled, vpnclient unconditionally stopped connection on untrusted server certificate. Added account configuration parameter to retry connection if server certivicate failed validation.
643 lines
24 KiB
C
643 lines
24 KiB
C
// SoftEther VPN Source Code - Developer Edition Master Branch
|
|
// 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.
|
|
|
|
|
|
// CMInner.h
|
|
// Internal header for the CM.c
|
|
|
|
#define STARTUP_MUTEX_NAME GC_SW_SOFTETHER_PREFIX "vpncmgr_startup_mutex"
|
|
|
|
#define NAME_OF_VPN_CLIENT_MANAGER "vpncmgr"
|
|
|
|
void CmVoice(char *name);
|
|
|
|
typedef struct CM_UAC_HELPER
|
|
{
|
|
THREAD *Thread;
|
|
volatile bool Halt;
|
|
EVENT *HaltEvent;
|
|
} CM_UAC_HELPER;
|
|
|
|
typedef struct CM_VOICE
|
|
{
|
|
UINT voice_id;
|
|
char *perfix;
|
|
} CM_VOICE;
|
|
|
|
static CM_VOICE cm_voice[] =
|
|
{
|
|
{VOICE_SSK, "ssk" },
|
|
{VOICE_AHO, "aho" },
|
|
};
|
|
|
|
typedef struct CM_ENUM_HUB
|
|
{
|
|
HWND hWnd;
|
|
THREAD *Thread;
|
|
SESSION *Session;
|
|
CLIENT_OPTION *ClientOption;
|
|
TOKEN_LIST *Hub;
|
|
} CM_ENUM_HUB;
|
|
|
|
#define CM_SETTING_INIT_NONE 0
|
|
#define CM_SETTING_INIT_EASY 1 // Transition to the simple mode
|
|
#define CM_SETTING_INIT_NORMAL 2 // Transition to the normal mode
|
|
#define CM_SETTING_INIT_SELECT 3 // Show a selection screen
|
|
#define CM_SETTING_INIT_CONNECT 4 // Import process by the simple installer
|
|
|
|
typedef struct CM
|
|
{
|
|
HWND hMainWnd;
|
|
HWND hStatusBar;
|
|
REMOTE_CLIENT *Client;
|
|
char *server_name;
|
|
char *password;
|
|
wchar_t *import_file_name;
|
|
bool HideStatusBar;
|
|
bool HideTrayIcon;
|
|
bool ShowGrid;
|
|
bool VistaStyle;
|
|
bool ShowPort;
|
|
wchar_t StatudBar1[MAX_SIZE];
|
|
wchar_t StatudBar2[MAX_SIZE];
|
|
wchar_t StatudBar3[MAX_SIZE];
|
|
HICON Icon2, Icon3;
|
|
bool IconView;
|
|
THREAD *NotifyClientThread;
|
|
NOTIFY_CLIENT *NotifyClient;
|
|
volatile bool Halt;
|
|
bool OnCloseDispatched;
|
|
LIST *StatusWindowList;
|
|
CEDAR *Cedar;
|
|
LIST *EnumHubList;
|
|
UINT WindowCount;
|
|
bool DisableVoice;
|
|
UINT VoiceId;
|
|
UINT OldConnectedNum;
|
|
bool UpdateConnectedNumFlag;
|
|
UCHAR ShortcutKey[SHA1_SIZE];
|
|
bool TrayInited;
|
|
bool TraySucceed;
|
|
bool TrayAnimation;
|
|
bool TraySpeedAnimation;
|
|
UINT TrayAnimationCounter;
|
|
bool StartupMode;
|
|
THREAD *TryExecUiHelperThread;
|
|
volatile bool TryExecUiHelperHalt;
|
|
HANDLE TryExecUiHelperProcessHandle;
|
|
EVENT *TryExecUiHelperHaltEvent;
|
|
bool WindowsShutdowning;
|
|
bool CmSettingSupported;
|
|
bool CmEasyModeSupported;
|
|
bool CmSettingInitialFlag;
|
|
CM_SETTING CmSetting;
|
|
HWND hEasyWnd;
|
|
bool StartupFinished;
|
|
bool ConnectStartedFlag;
|
|
bool PositiveDisconnectFlag;
|
|
wchar_t EasyLastSelectedAccountName[MAX_ACCOUNT_NAME_LEN + 1];
|
|
WINDOWPLACEMENT FakeWindowPlacement;
|
|
bool CheckedAndShowedAdminPackMessage;
|
|
INSTANCE *StartupMutex;
|
|
bool BadProcessChecked;
|
|
bool PopupMenuOpen;
|
|
WINUI_UPDATE *Update;
|
|
} CM;
|
|
|
|
typedef struct CM_STATUS
|
|
{
|
|
wchar_t AccountName[MAX_ACCOUNT_NAME_LEN + 1]; // Account name
|
|
HWND hWndPolicy; // Policy dialog
|
|
} CM_STATUS;
|
|
|
|
typedef struct CM_POLICY
|
|
{
|
|
HWND hWnd;
|
|
wchar_t AccountName[MAX_ACCOUNT_NAME_LEN + 1]; // Account name
|
|
POLICY *Policy; // Policy dialog
|
|
CM_STATUS *CmStatus; // CM_STATUS
|
|
bool Extension; // Extension
|
|
} CM_POLICY;
|
|
|
|
typedef struct CM_ACCOUNT
|
|
{
|
|
bool EditMode; // Edit mode (false: New mode)
|
|
bool LinkMode; // Link mode
|
|
bool NatMode; // NAT mode
|
|
CLIENT_OPTION *ClientOption; // Client option
|
|
CLIENT_AUTH *ClientAuth; // Authentication data
|
|
bool Startup; // Startup account
|
|
bool CheckServerCert; // Check the server certificate
|
|
bool RetryOnServerCert; // Retry on invalid server certificate
|
|
X *ServerCert; // Server certificate
|
|
char old_server_name[MAX_HOST_NAME_LEN + 1]; // Old server name
|
|
bool Inited; // Initialization flag
|
|
POLICY Policy; // Policy (only link mode)
|
|
struct SM_HUB *Hub; // HUB
|
|
RPC *Rpc; // RPC
|
|
bool OnlineFlag; // Online flag
|
|
bool Flag1; // Flag 1
|
|
bool HideClientCertAuth; // Hide the client authentication
|
|
bool HideSecureAuth; // Hide the smart card authentication
|
|
bool HideTrustCert; // Hide the trusted certificate authority button
|
|
UCHAR ShortcutKey[SHA1_SIZE]; // Shortcut key
|
|
bool LockMode; // Setting lock mode
|
|
bool Link_ConnectNow; // Start the connection immediately
|
|
UINT PolicyVer; // Policy version
|
|
} CM_ACCOUNT;
|
|
|
|
typedef struct CM_CHANGE_PASSWORD
|
|
{
|
|
CLIENT_OPTION *ClientOption; // Client Option
|
|
char Username[MAX_USERNAME_LEN + 1]; // User name
|
|
char HubName[MAX_HUBNAME_LEN + 1]; // HUB name
|
|
} CM_CHANGE_PASSWORD;
|
|
|
|
typedef struct CM_TRAFFIC
|
|
{
|
|
bool ServerMode; // Server mode
|
|
bool Double; // 2x mode
|
|
bool Raw; // Raw data mode
|
|
UINT Port; // Port number
|
|
char Host[MAX_HOST_NAME_LEN + 1]; // Host name
|
|
UINT NumTcp; // Number of TCP connections
|
|
UINT Type; // Type
|
|
UINT Span; // Period
|
|
} CM_TRAFFIC;
|
|
|
|
typedef struct CM_TRAFFIC_DLG
|
|
{
|
|
HWND hWnd; // Window handle
|
|
CM_TRAFFIC *Setting; // Setting
|
|
TTS *Tts; // Measurement server
|
|
TTC *Ttc; // Measurement client
|
|
THREAD *HaltThread; // Thread for stopping
|
|
THREAD *ClientEndWaitThread; // Thread to wait for the client to finish
|
|
bool Started; // Started flag
|
|
bool Stopping; // Stopping
|
|
UINT RetCode; // Return value
|
|
TT_RESULT Result; // Result
|
|
EVENT *ResultShowEvent; // Display result event
|
|
bool CloseDialogAfter; // Flag of whether or not to close the dialog
|
|
} CM_TRAFFIC_DLG;
|
|
|
|
// Internet connection settings
|
|
typedef struct CM_INTERNET_SETTING
|
|
{
|
|
UINT ProxyType; // Type of proxy server
|
|
char ProxyHostName[MAX_HOST_NAME_LEN + 1]; // Proxy server host name
|
|
UINT ProxyPort; // Proxy server port number
|
|
char ProxyUsername[MAX_USERNAME_LEN + 1]; // Proxy server user name
|
|
char ProxyPassword[MAX_USERNAME_LEN + 1]; // Proxy server password
|
|
} CM_INTERNET_SETTING;
|
|
|
|
static CM *cm = NULL;
|
|
|
|
void CmFreeTrayExternal(void *hWnd);
|
|
|
|
// Normal RPC call macro
|
|
__forceinline static bool CALL(HWND hWnd, UINT code)
|
|
{
|
|
UINT ret = code;
|
|
if (ret != ERR_NO_ERROR)
|
|
{
|
|
if (ret == ERR_DISCONNECTED)
|
|
{
|
|
if (cm != NULL)
|
|
{
|
|
Close(cm->hMainWnd);
|
|
}
|
|
else
|
|
{
|
|
MsgBox(hWnd, MB_ICONSTOP, _UU("SM_DISCONNECTED"));
|
|
}
|
|
|
|
if (cm != NULL)
|
|
{
|
|
CmFreeTrayExternal((void *)cm->hMainWnd);
|
|
}
|
|
exit(0);
|
|
}
|
|
else
|
|
{
|
|
UINT flag = MB_ICONEXCLAMATION;
|
|
if (ret == ERR_VLAN_IS_USED)
|
|
{
|
|
CmVoice("using_vlan");
|
|
}
|
|
if (hWnd != NULL && cm != NULL && cm->hEasyWnd != NULL)
|
|
{
|
|
hWnd = cm->hEasyWnd;
|
|
}
|
|
if (hWnd != NULL && cm != NULL && hWnd == cm->hEasyWnd)
|
|
{
|
|
flag |= MB_SETFOREGROUND | MB_TOPMOST;
|
|
}
|
|
MsgBox(hWnd, flag, _E(ret));
|
|
}
|
|
}
|
|
|
|
if (ret == ERR_NO_ERROR)
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Extended RPC call macro (get an error value)
|
|
__forceinline static UINT CALLEX(HWND hWnd, UINT code)
|
|
{
|
|
UINT ret = code;
|
|
if (ret != ERR_NO_ERROR)
|
|
{
|
|
if (ret == ERR_DISCONNECTED)
|
|
{
|
|
if (cm != NULL)
|
|
{
|
|
Close(cm->hMainWnd);
|
|
}
|
|
else
|
|
{
|
|
MsgBox(hWnd, MB_ICONSTOP, _UU("SM_DISCONNECTED"));
|
|
}
|
|
if (cm != NULL)
|
|
{
|
|
CmFreeTrayExternal((void *)cm->hMainWnd);
|
|
}
|
|
exit(0);
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
typedef struct CM_LOADX
|
|
{
|
|
X *x;
|
|
} CM_LOADX;
|
|
|
|
typedef struct CM_SETTING_DLG
|
|
{
|
|
bool CheckPassword;
|
|
UCHAR HashedPassword[SHA1_SIZE];
|
|
} CM_SETTING_DLG;
|
|
|
|
typedef struct CM_EASY_DLG
|
|
{
|
|
bool EndDialogCalled;
|
|
} CM_EASY_DLG;
|
|
|
|
|
|
|
|
// Task tray related
|
|
#define WM_CM_TRAY_MESSAGE (WM_APP + 44)
|
|
#define WM_CM_SETTING_CHANGED_MESSAGE (WM_APP + 45)
|
|
#define WM_CM_EASY_REFRESH (WM_APP + 46)
|
|
#define WM_CM_SHOW (WM_APP + 47)
|
|
#define CMD_EASY_DBLCLICK 40697
|
|
#define CMD_VGC_CONNECT 40698
|
|
#define CM_TRAY_ANIMATION_INTERVAL 3000
|
|
#define CM_TRAY_MAX_ITEMS 4096
|
|
#define CM_TRAY_MENU_ID_START 12000
|
|
#define CM_TRAY_MENU_CONNECT_ID_START (CM_TRAY_MENU_ID_START + CM_TRAY_MAX_ITEMS)
|
|
#define CM_TRAY_MENU_STATUS_ID_START (CM_TRAY_MENU_CONNECT_ID_START + CM_TRAY_MAX_ITEMS)
|
|
#define CM_TRAY_MENU_DISCONNECT_ID_START (CM_TRAY_MENU_STATUS_ID_START + CM_TRAY_MAX_ITEMS)
|
|
#define CM_TRAY_MENU_RECENT_ID_START (CM_TRAY_MENU_DISCONNECT_ID_START + CM_TRAY_MAX_ITEMS)
|
|
#define CM_TRAY_IS_CONNECT_ID(id) (((id) >= CM_TRAY_MENU_CONNECT_ID_START) && (id) < CM_TRAY_MENU_STATUS_ID_START)
|
|
#define CM_TRAY_IS_STATUS_ID(id) (((id) >= CM_TRAY_MENU_STATUS_ID_START) && (id) < CM_TRAY_MENU_DISCONNECT_ID_START)
|
|
#define CM_TRAY_IS_DISCONNECT_ID(id) (((id) >= CM_TRAY_MENU_DISCONNECT_ID_START) && (id) < (CM_TRAY_MENU_DISCONNECT_ID_START + CM_TRAY_MAX_ITEMS))
|
|
#define CM_TRAY_IS_RECENT_ID(id) (((id) >= CM_TRAY_MENU_RECENT_ID_START) && (id) < (CM_TRAY_MENU_RECENT_ID_START + CM_TRAY_MAX_ITEMS))
|
|
|
|
|
|
// Function prototype
|
|
void InitCM(bool set_app_id);
|
|
void FreeCM();
|
|
void MainCM();
|
|
bool LoginCM();
|
|
void LogoutCM();
|
|
UINT CmLoginDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param);
|
|
void MainCMWindow();
|
|
void CmSendImportMessage(HWND hWnd, wchar_t *filename, UINT msg);
|
|
UINT CmMainWindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param);
|
|
void CmMainWindowOnSize(HWND hWnd);
|
|
void CmMainWindowOnInit(HWND hWnd);
|
|
void CmMainWindowOnQuit(HWND hWnd);
|
|
void CmSaveMainWindowPos(HWND hWnd);
|
|
void CmMainWindowOnCommand(HWND hWnd, WPARAM wParam, LPARAM lParam);
|
|
void CmMainWindowOnCommandEx(HWND hWnd, WPARAM wParam, LPARAM lParam, bool easy);
|
|
bool CmIsEnabled(HWND hWnd, UINT id);
|
|
bool CmIsChecked(UINT id);
|
|
bool CmIsBold(UINT id);
|
|
void CmMainWindowOnPopupMenu(HWND hWnd, HMENU hMenu, UINT pos);
|
|
void CmSaveMainWindowPos(HWND hWnd);
|
|
void CmRedrawStatusBar(HWND hWnd);
|
|
void CmRefresh(HWND hWnd);
|
|
void CmRefreshEx(HWND hWnd, bool style_changed);
|
|
void CmSetForegroundProcessToCnService();
|
|
void CmInitAccountList(HWND hWnd);
|
|
void CmInitAccountListEx(HWND hWnd, bool easy);
|
|
void CmInitVLanList(HWND hWnd);
|
|
void CmRefreshAccountList(HWND hWnd);
|
|
void CmRefreshAccountListEx(HWND hWnd, bool easy);
|
|
void CmRefreshAccountListEx2(HWND hWnd, bool easy, bool style_changed);
|
|
void CmRefreshVLanList(HWND hWnd);
|
|
void CmRefreshVLanListEx(HWND hWnd, bool style_changed);
|
|
void CmSaveAccountListPos(HWND hWnd);
|
|
void CmSaveVLanListPos(HWND hWnd);
|
|
wchar_t *CmGetProtocolName(UINT n);
|
|
void CmVLanNameToPrintName(char *str, UINT size, char *name);
|
|
bool CmPrintNameToVLanName(char *name, UINT size, char *str);
|
|
void CmMainWindowOnNotify(HWND hWnd, NMHDR *n);
|
|
void CmOnKey(HWND hWnd, bool ctrl, bool alt, UINT key);
|
|
void CmAccountListRightClick(HWND hWnd);
|
|
void CmVLanListRightClick(HWND hWnd);
|
|
void CmConnect(HWND hWnd, wchar_t *account_name);
|
|
void CmDisconnect(HWND hWnd, wchar_t *account_name);
|
|
void CmInitNotifyClientThread();
|
|
void CmFreeNotifyClientThread();
|
|
void CmNotifyClientThread(THREAD *thread, void *param);
|
|
void CmDeleteAccount(HWND hWnd, wchar_t *account_name);
|
|
void CmStatus(HWND hWnd, wchar_t *account_name);
|
|
void CmStatusDlg(HWND hWnd, wchar_t *account_name);
|
|
UINT CmStatusDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param);
|
|
void CmStatusDlgPrint(HWND hWnd, CM_STATUS *cmst);
|
|
void CmPrintStatusToListView(LVB *b, RPC_CLIENT_GET_CONNECTION_STATUS *s);
|
|
void CmPrintStatusToListViewEx(LVB *b, RPC_CLIENT_GET_CONNECTION_STATUS *s, bool server_mode);
|
|
void CmStatusDlgPrintCert(HWND hWnd, CM_STATUS *st, bool server);
|
|
void CmPolicyDlg(HWND hWnd, CM_STATUS *st);
|
|
UINT CmPolicyDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param);
|
|
void CmPolicyDlgPrint(HWND hWnd, CM_POLICY *p);
|
|
void CmPolicyDlgPrintEx(HWND hWnd, CM_POLICY *p, bool cascade_mode);
|
|
void CmPolicyDlgPrintEx2(HWND hWnd, CM_POLICY *p, bool cascade_mode, bool ver);
|
|
void CmNewAccount(HWND hWnd);
|
|
void CmEditAccount(HWND hWnd, wchar_t *account_name);
|
|
void CmGenerateNewAccountName(HWND hWnd, wchar_t *name, UINT size);
|
|
void CmGenerateCopyName(HWND hWnd, wchar_t *name, UINT size, wchar_t *old_name);
|
|
void CmGenerateImportName(HWND hWnd, wchar_t *name, UINT size, wchar_t *old_name);
|
|
CM_ACCOUNT *CmCreateNewAccountObject(HWND hWnd);
|
|
CM_ACCOUNT *CmGetExistAccountObject(HWND hWnd, wchar_t *account_name);
|
|
void CmEnumHubStart(HWND hWnd, CLIENT_OPTION *o);
|
|
void CmInitEnumHub();
|
|
void CmFreeEnumHub();
|
|
void CmFreeAccountObject(HWND hWnd, CM_ACCOUNT *a);
|
|
bool CmEditAccountDlg(HWND hWnd, CM_ACCOUNT *a);
|
|
UINT CmEditAccountDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param);
|
|
void CmEditAccountDlgUpdate(HWND hWnd, CM_ACCOUNT *a);
|
|
void CmEditAccountDlgInit(HWND hWnd, CM_ACCOUNT *a);
|
|
void CmEditAccountDlgOnOk(HWND hWnd, CM_ACCOUNT *a);
|
|
void CmEditAccountDlgStartEnumHub(HWND hWnd, CM_ACCOUNT *a);
|
|
bool CmLoadXAndK(HWND hWnd, X **x, K **k);
|
|
bool CmLoadK(HWND hWnd, K **k);
|
|
bool CmLoadKEx(HWND hWnd, K **k, char *filename, UINT size);
|
|
bool CmLoadKExW(HWND hWnd, K **k, wchar_t *filename, UINT size);
|
|
bool CmLoadXFromFileOrSecureCard(HWND hWnd, X **x);
|
|
void CmLoadXFromFileOrSecureCardDlgInit(HWND hWnd, CM_LOADX *p);
|
|
void CmLoadXFromFileOrSecureCardDlgUpdate(HWND hWnd, CM_LOADX *p);
|
|
UINT CmLoadXFromFileOrSecureCardDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param);
|
|
bool CmLoadX(HWND hWnd, X **x);
|
|
bool CmLoadXEx(HWND hWnd, X **x, char *filename, UINT size);
|
|
bool CmLoadXExW(HWND hWnd, X **x, wchar_t *filename, UINT size);
|
|
X *CmGetIssuer(X *x);
|
|
bool CmProxyDlg(HWND hWnd, CLIENT_OPTION *a);
|
|
void CmProxyDlgUpdate(HWND hWnd, CLIENT_OPTION *a);
|
|
UINT CmProxyDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param);
|
|
bool CmDetailDlg(HWND hWnd, CM_ACCOUNT *a);
|
|
UINT CmDetailDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param);
|
|
char *CmNewVLanDlg(HWND hWnd);
|
|
UINT CmNewVLanDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param);
|
|
void CmCopyAccount(HWND hWnd, wchar_t *account_name);
|
|
void CmExportAccount(HWND hWnd, wchar_t *account_name);
|
|
void CmSortcut(HWND hWnd, wchar_t *account_name);
|
|
void CmImportAccount(HWND hWnd);
|
|
void CmImportAccountMain(HWND hWnd, wchar_t *filename);
|
|
void CmImportAccountMainEx(HWND hWnd, wchar_t *filename, bool overwrite);
|
|
void CmTrustDlg(HWND hWnd);
|
|
UINT CmTrustDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param);
|
|
void CmTrustDlgUpdate(HWND hWnd);
|
|
void CmTrustDlgRefresh(HWND hWnd);
|
|
void CmTrustImport(HWND hWnd);
|
|
void CmTrustExport(HWND hWnd);
|
|
void CmTrustView(HWND hWnd);
|
|
void CmPassword(HWND hWnd);
|
|
UINT CmPasswordProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param);
|
|
void CmPasswordRefresh(HWND hWnd);
|
|
void CmRefreshStatusBar(HWND hWnd);
|
|
UINT CmGetNumConnected(HWND hWnd);
|
|
void CmDisconnectAll(HWND hWnd);
|
|
wchar_t *CmGenerateMainWindowTitle();
|
|
void CmConfigDlg(HWND hWnd);
|
|
UINT CmConfigDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param);
|
|
void CmConfigDlgInit(HWND hWnd);
|
|
void CmConfigDlgRefresh(HWND hWnd);
|
|
void CmConfigDlgOnOk(HWND hWnd);
|
|
bool CmWarningDesktop(HWND hWnd, wchar_t *account_name);
|
|
UINT CmDesktopDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param);
|
|
void CmDesktopDlgInit(HWND hWnd, wchar_t *account_name);
|
|
bool CmStopInstallVLan(HWND hWnd);
|
|
void CmChangePassword(HWND hWnd, CLIENT_OPTION *o, char *hubname, char *username);
|
|
UINT CmChangePasswordProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param);
|
|
void CmChangePasswordUpdate(HWND hWnd, CM_CHANGE_PASSWORD *p);
|
|
void SmShowPublicVpnServerHtml(HWND hWnd);
|
|
void CmConnectShortcut(UCHAR *key);
|
|
UINT CmSelectSecure(HWND hWnd, UINT current_id);
|
|
void CmClientSecureManager(HWND hWnd);
|
|
UINT CmClientSelectSecure(HWND hWnd);
|
|
UINT CmSelectSecureDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param);
|
|
void CmSelectSecureDlgInit(HWND hWnd, UINT default_id);
|
|
void CmSelectSecureDlgUpdate(HWND hWnd);
|
|
void CmSecureManager(HWND hWnd, UINT id);
|
|
void CmSecureManagerEx(HWND hWnd, UINT id, bool no_new_cert);
|
|
UINT CmSecureManagerDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param);
|
|
void CmSecureManagerDlgInit(HWND hWnd, UINT id);
|
|
void CmSecureManagerDlgUpdate(HWND hWnd, UINT id);
|
|
void CmSecureManagerDlgRefresh(HWND hWnd, UINT id);
|
|
void CmSecureManagerDlgPrintList(HWND hWnd, LIST *o);
|
|
void CmSecureManagerDlgPrintListEx(HWND hWnd, UINT id, LIST *o, UINT type);
|
|
wchar_t *CmSecureObjTypeToStr(UINT type);
|
|
UINT CmSecureType(HWND hWnd);
|
|
UINT CmSecureTypeDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param);
|
|
void CmSecureManagerDlgImport(HWND hWnd, UINT id);
|
|
void CmSecureManagerDlgDelete(HWND hWnd, UINT id);
|
|
void CmSecureManagerDlgExport(HWND hWnd, UINT id);
|
|
void CmSecureManagerDlgNewCert(HWND hWnd, UINT id);
|
|
void CmSecurePin(HWND hWnd, UINT id);
|
|
UINT CmSecurePinDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param);
|
|
void CmSecurePinDlgUpdate(HWND hWnd);
|
|
void CmInitTray(HWND hWnd);
|
|
void CmPollingTray(HWND hWnd);
|
|
void CmFreeTray(HWND hWnd);
|
|
void CmChangeTrayString(HWND hWnd, wchar_t *str);
|
|
UINT CmGetTrayIconId(bool animation, UINT animation_counter);
|
|
void CmShowOrHideWindow(HWND hWnd);
|
|
void CmShowTrayMenu(HWND hWnd);
|
|
HMENU CmCreateTraySubMenu(HWND hWnd, bool flag, UINT start_id);
|
|
HMENU CmCreateRecentSubMenu(HWND hWnd, UINT start_id);
|
|
bool CmCheckPkcsEula(HWND hWnd, UINT id);
|
|
UINT CmPkcsEulaDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param);
|
|
void CmDeleteOldStartupTrayFile();
|
|
UINT CmTrafficDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param);
|
|
void CmTrafficDlgInit(HWND hWnd);
|
|
bool CmTrafficDlgUpdate(HWND hWnd);
|
|
void CmTrafficDlgOnOk(HWND hWnd);
|
|
bool CmTrafficLoadFromReg(CM_TRAFFIC *t);
|
|
void CmTrafficGetDefaultSetting(CM_TRAFFIC *t);
|
|
void CmTrafficSaveToReg(CM_TRAFFIC *t);
|
|
void CmTrafficDlgToStruct(HWND hWnd, CM_TRAFFIC *t);
|
|
void CmExecTraffic(HWND hWnd, CM_TRAFFIC *t);
|
|
UINT CmTrafficRunDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param);
|
|
void CmTrafficRunDlgInit(HWND hWnd, CM_TRAFFIC_DLG *d);
|
|
void CmTrafficRunDlgStart(HWND hWnd, CM_TRAFFIC_DLG *d);
|
|
void CmTrafficRunDlgPrintProc(void *param, wchar_t *str);
|
|
void CmTrafficRunDlgAddStr(HWND hWnd, wchar_t *str);
|
|
void CmTrafficRunDlgHalt(HWND hWnd, CM_TRAFFIC_DLG *d);
|
|
void CmTrafficRunDlgHaltThread(THREAD *t, void *param);
|
|
void CmTrafficRunDlgClientWaitThread(THREAD *t, void *param);
|
|
void CmTrafficResult(HWND hWnd, TT_RESULT *r);
|
|
UINT CmTrafficResultDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param);
|
|
void CmTrafficResultDlgInit(HWND hWnd, TT_RESULT *res);
|
|
void CmTryToExecUiHelper();
|
|
void CmInitTryToExecUiHelper();
|
|
void CmFreeTryToExecUiHelper();
|
|
void CmTryToExecUiHelperThread(THREAD *thread, void *param);
|
|
bool CmSetting(HWND hWnd);
|
|
UINT CmSettingDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param);
|
|
void CmSettingDlgInit(HWND hWnd, CM_SETTING_DLG *d);
|
|
void CmSettingDlgUpdate(HWND hWnd, CM_SETTING_DLG *d);
|
|
void CmSettingDlgOnOk(HWND hWnd, CM_SETTING_DLG *d);
|
|
void CmApplyCmSetting();
|
|
void CmMainWindowOnTrayClicked(HWND hWnd, WPARAM wParam, LPARAM lParam);
|
|
void CmShowEasy();
|
|
void CmCloseEasy();
|
|
void CmMainWindowOnShowEasy(HWND hWnd);
|
|
UINT CmEasyDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param);
|
|
void CmEasyDlgInit(HWND hWnd, CM_EASY_DLG *d);
|
|
void CmEasyDlgUpdate(HWND hWnd, CM_EASY_DLG *d);
|
|
void CmEasyDlgRefresh(HWND hWnd, CM_EASY_DLG *d);
|
|
void CmRefreshEasy();
|
|
void CmEasyDlgOnNotify(HWND hWnd, CM_EASY_DLG *d, NMHDR *n);
|
|
void CmEasyDlgOnKey(HWND hWnd, CM_EASY_DLG *d, bool ctrl, bool alt, UINT key);
|
|
void CmEasyDlgOnCommand(HWND hWnd, CM_EASY_DLG *d, WPARAM wParam, LPARAM lParam);
|
|
|
|
bool CmStartStartupMutex();
|
|
void CmEndStartupMutex();
|
|
void CmSetUacWindowActive();
|
|
void CmUacHelperThread(THREAD *thread, void *param);
|
|
void CmProxyDlgUseForIE(HWND hWnd, CLIENT_OPTION *o);
|
|
void CmGetSystemInternetSetting(CM_INTERNET_SETTING *setting);
|
|
void CmProxyDlgSet(HWND hWnd, CLIENT_OPTION *o, CM_INTERNET_SETTING *setting);
|
|
bool CmGetProxyServerNameAndPortFromIeProxyRegStr(char *name, UINT name_size, UINT *port, char *str, char *server_type);
|
|
void *CmUpdateJumpList(UINT start_id);
|
|
|
|
|