CFG_RW *NewCfgRwEx2A(FOLDER **root, char *cfg_name_a, bool dont_backup, char *template_name_a)
{
CFG_RW *ret;
wchar_t *cfg_name_w = CopyStrToUni(cfg_name_a);
wchar_t *template_name_w = CopyStrToUni(template_name_a);
ret = NewCfgRwEx2W(root, cfg_name_w, dont_backup, template_name_w);
Free(cfg_name_w);
Free(template_name_w);
return ret;
}
// Reading a string resource
wchar_t *ViLoadString(HINSTANCE hInst, UINT id)
{
wchar_t *ret = NULL;
if (OS_IS_WINDOWS_9X(GetOsInfo()->OsType))
{
char *a = ViLoadStringA(hInst, id);
if (a != NULL)
{
ret = CopyStrToUni(a);
Free(a);
}
}
else
{
UINT tmp_size = 60000;
wchar_t *tmp = Malloc(tmp_size);
if (LoadStringW(hInst, id, tmp, tmp_size) != 0)
{
ret = CopyUniStr(tmp);
}
Free(tmp);
}
return ret;
}
// Extract the license agreement from the EXE file
wchar_t *ViExtractEula(char *exe)
{
BUF *b;
UINT tmp_size;
char *tmp;
wchar_t *ret;
// Validate arguments
if (exe == NULL)
{
return false;
}
b = ViExtractResource(exe, RT_RCDATA, "LICENSE");
if (b == NULL)
{
return NULL;
}
tmp_size = b->Size + 1;
tmp = ZeroMalloc(tmp_size);
Copy(tmp, b->Buf, b->Size);
FreeBuf(b);
ret = CopyStrToUni(tmp);
Free(tmp);
return ret;
}
char *ParseCommandA(wchar_t *str, char *name)
{
wchar_t *tmp1, *tmp2;
char *ret;
// Validate arguments
if (str == NULL)
{
return NULL;
}
if (name != NULL)
{
tmp1 = CopyStrToUni(name);
}
else
{
tmp1 = NULL;
}
tmp2 = ParseCommand(str, tmp1);
if (tmp2 == NULL)
{
ret = NULL;
}
else
{
ret = CopyUniToStr(tmp2);
Free(tmp2);
}
Free(tmp1);
return ret;
}
char *FolderDlgInnerA(HWND hWnd, wchar_t *title, char *default_dir)
{
BROWSEINFOA info;
char display_name[MAX_PATH];
FOLDER_DLG_INNER_DATA data;
LPMALLOC pMalloc;
char *ret = NULL;
char *title_a;
if (UniIsEmptyStr(title))
{
title = NULL;
}
if (IsEmptyStr(default_dir))
{
default_dir = NULL;
}
Zero(&data, sizeof(data));
data.default_dir = CopyStrToUni(default_dir);
Zero(display_name, sizeof(display_name));
Zero(&info, sizeof(info));
info.hwndOwner = hWnd;
info.pidlRoot = NULL;
info.pszDisplayName = display_name;
title_a = CopyUniToStr(title);
info.lpszTitle = title_a;
info.ulFlags = BIF_NEWDIALOGSTYLE | BIF_RETURNONLYFSDIRS | BIF_VALIDATE | BIF_SHAREABLE;
info.lpfn = FolderDlgInnerCallbackA;
info.lParam = (LPARAM)&data;
if (SUCCEEDED(SHGetMalloc(&pMalloc)))
{
LPITEMIDLIST pidl;
pidl = SHBrowseForFolderA(&info);
if (pidl)
{
char tmp[MAX_PATH];
if (SHGetPathFromIDListA(pidl, tmp))
{
ret = CopyStr(tmp);
}
pMalloc->Free(pidl);
}
pMalloc->Release();
}
Free(data.default_dir);
Free(title_a);
return ret;
}
CFG_RW *NewCfgRwEx(FOLDER **root, char *cfg_name, bool dont_backup)
{
wchar_t *cfg_name_w = CopyStrToUni(cfg_name);
CFG_RW *ret = NewCfgRwExW(root, cfg_name_w, dont_backup);
Free(cfg_name_w);
return ret;
}
bool LoadTable(char *filename)
{
wchar_t *filename_a = CopyStrToUni(filename);
bool ret = LoadTableW(filename_a);
Free(filename_a);
return ret;
}
// Read the settings from the file
FOLDER *CfgRead(char *name)
{
wchar_t *name_w = CopyStrToUni(name);
FOLDER *ret = CfgReadW(name_w);
Free(name_w);
return ret;
}
bool CfgSaveEx(CFG_RW *rw, FOLDER *f, char *name)
{
wchar_t *name_w = CopyStrToUni(name);
bool ret = CfgSaveExW(rw, f, name_w);
Free(name_w);
return ret;
}
// Get the width of the specified string
UINT StrWidth(char *str)
{
wchar_t *s;
UINT ret;
// Validate arguments
if (str == NULL)
{
return 0;
}
s = CopyStrToUni(str);
ret = UniStrWidth(s);
Free(s);
return ret;
}
// 指定した文字列の横幅を取得する
UINT StrWidth(char *str)
{
wchar_t *s;
UINT ret;
// 引数チェック
if (str == NULL)
{
return 0;
}
s = CopyStrToUni(str);
ret = UniStrWidth(s);
Free(s);
return ret;
}
// Format the string (argument list)
void FormatArgs(char *buf, UINT size, char *fmt, va_list args)
{
wchar_t *tag;
wchar_t *ret;
// Validate arguments
if (buf == NULL || fmt == NULL)
{
return;
}
tag = CopyStrToUni(fmt);
ret = InternalFormatArgs(tag, args, true);
UniToStr(buf, size, ret);
Free(ret);
Free(tag);
}
// Display the string on the screen
void PrintStr(char *str)
{
wchar_t *unistr = NULL;
// Validate arguments
if (str == NULL)
{
return;
}
#ifdef OS_UNIX
fputs(str, stdout);
#else // OS_UNIX
unistr = CopyStrToUni(str);
UniPrintStr(unistr);
Free(unistr);
#endif // OS_UNIX
}
// Show the folder selection dialog
wchar_t *FolderDlgW(HWND hWnd, wchar_t *title, wchar_t *default_dir)
{
wchar_t *ret;
if (MsIsNt() == false)
{
char *default_dir_a = CopyUniToStr(default_dir);
char *ret_a = FolderDlgA(hWnd, title, default_dir_a);
ret = CopyStrToUni(ret_a);
Free(ret_a);
Free(default_dir_a);
return ret;
}
ret = FolderDlgInnerW(hWnd, title, default_dir);
return ret;
}
// Display a string with arguments
void PrintArgs(char *fmt, va_list args)
{
wchar_t *ret;
wchar_t *fmt_wchar;
char *tmp;
// Validate arguments
if (fmt == NULL)
{
return;
}
fmt_wchar = CopyStrToUni(fmt);
ret = InternalFormatArgs(fmt_wchar, args, true);
tmp = CopyUniToStr(ret);
PrintStr(tmp);
Free(tmp);
Free(ret);
Free(fmt_wchar);
}
// Show the prompt
wchar_t *Prompt(wchar_t *prompt_str)
{
wchar_t *ret = NULL;
wchar_t *tmp = NULL;
// Validate arguments
if (prompt_str == NULL)
{
prompt_str = L"";
}
#ifdef OS_WIN32
UniPrint(L"%s", prompt_str);
tmp = Malloc(MAX_PROMPT_STRSIZE);
if (fgetws(tmp, MAX_PROMPT_STRSIZE - 1, stdin) != NULL)
{
bool escape = false;
UINT i, len;
len = UniStrLen(tmp);
for (i = 0;i < len;i++)
{
if (tmp[i] == 0x04 || tmp[i] == 0x1A)
{
escape = true;
break;
}
}
if (escape == false)
{
UniTrimCrlf(tmp);
ret = UniCopyStr(tmp);
}
}
Free(tmp);
#else // OS_WIN32
{
char *prompt = CopyUniToStr(prompt_str);
char *s = readline(prompt);
Free(prompt);
if (s != NULL)
{
TrimCrlf(s);
Trim(s);
if (IsEmptyStr(s) == false)
{
add_history(s);
}
ret = CopyStrToUni(s);
free(s);
}
}
#endif // OS_WIN32
if (ret == NULL)
{
Print("\n");
}
return ret;
}
bool DispatchNextCmdEx(CONSOLE *c, wchar_t *exec_command, char *prompt, CMD cmd[], UINT num_cmd, void *param)
{
wchar_t *str;
wchar_t *tmp;
char *cmd_name;
bool b_exit = false;
wchar_t *cmd_param;
UINT ret = ERR_NO_ERROR;
TOKEN_LIST *t;
TOKEN_LIST *candidate;
bool no_end_crlf = false;
UINT i;
// Validate arguments
if (c == NULL || (num_cmd >= 1 && cmd == NULL))
{
return false;
}
if (exec_command == NULL)
{
// Show the prompt
RETRY:
tmp = CopyStrToUni(prompt);
if (c->ProgrammingMode)
{
wchar_t tmp2[MAX_PATH];
UniFormat(tmp2, sizeof(tmp2), L"[PROMPT:%u:%s]\r\n", c->RetCode, tmp);
Free(tmp);
tmp = CopyUniStr(tmp2);
}
str = c->ReadLine(c, tmp, false);
Free(tmp);
if (str != NULL && IsEmptyUniStr(str))
{
Free(str);
goto RETRY;
}
}
else
{
wchar_t tmp[MAX_SIZE];
// Use exec_command
if (UniStartWith(exec_command, L"vpncmd") == false)
{
if (prompt != NULL)
{
if (c->ConsoleType != CONSOLE_CSV)
{
UniFormat(tmp, sizeof(tmp), L"%S%s", prompt, exec_command);
c->Write(c, tmp);
}
}
}
str = CopyUniStr(exec_command);
}
if (str == NULL)
{
// User canceled
return false;
}
UniTrimCrlf(str);
UniTrim(str);
if (UniIsEmptyStr(str))
{
// Do Nothing
Free(str);
return true;
}
// Divide into command name and parameter
if (SeparateCommandAndParam(str, &cmd_name, &cmd_param) == false)
{
// Do Nothing
Free(str);
return true;
}
if (StrLen(cmd_name) >= 2 && cmd_name[0] == '?' && cmd_name[1] != '?')
{
char tmp[MAX_SIZE];
wchar_t *s;
StrCpy(tmp, sizeof(tmp), cmd_name + 1);
StrCpy(cmd_name, 0, tmp);
s = UniCopyStr(L"/?");
Free(cmd_param);
cmd_param = s;
}
if (StrLen(cmd_name) >= 2 && EndWith(cmd_name, "?") && cmd_name[StrLen(cmd_name) - 2] != '?')
{
wchar_t *s;
cmd_name[StrLen(cmd_name) - 1] = 0;
s = UniCopyStr(L"/?");
Free(cmd_param);
cmd_param = s;
}
// Get the candidate of command
t = ZeroMalloc(sizeof(TOKEN_LIST));
t->NumTokens = num_cmd;
t->Token = ZeroMalloc(sizeof(char *) * t->NumTokens);
for (i = 0;i < t->NumTokens;i++)
{
t->Token[i] = CopyStr(cmd[i].Name);
}
if (IsHelpStr(cmd_name))
{
if (UniIsEmptyStr(cmd_param))
{
wchar_t tmp[MAX_SIZE];
// Display the list of commands that can be used
UniFormat(tmp, sizeof(tmp), _UU("CMD_HELP_1"), t->NumTokens);
c->Write(c, tmp);
PrintCandidateHelp(c, NULL, t, 1);
c->Write(c, L"");
c->Write(c, _UU("CMD_HELP_2"));
}
else
{
char *cmd_name;
// Display the help for the specified command
if (SeparateCommandAndParam(cmd_param, &cmd_name, NULL))
{
bool b = true;
if (IsHelpStr(cmd_name))
{
b = false;
}
if (b)
{
wchar_t str[MAX_SIZE];
UniFormat(str, sizeof(str), L"%S /help", cmd_name);
DispatchNextCmdEx(c, str, NULL, cmd, num_cmd, param);
no_end_crlf = true;
}
Free(cmd_name);
}
}
}
else if (StrCmpi(cmd_name, "exit") == 0 || StrCmpi(cmd_name, "quit") == 0)
{
// Exit
b_exit = true;
}
else
{
candidate = GetRealnameCandidate(cmd_name, t);
if (candidate == NULL || candidate->NumTokens == 0)
{
wchar_t tmp[MAX_SIZE];
// No candidate
UniFormat(tmp, sizeof(tmp), _UU("CON_UNKNOWN_CMD"), cmd_name);
c->Write(c, tmp);
c->RetCode = ERR_BAD_COMMAND_OR_PARAM;
}
else if (candidate->NumTokens >= 2)
{
wchar_t tmp[MAX_SIZE];
// There is more than one candidate
UniFormat(tmp, sizeof(tmp), _UU("CON_AMBIGIOUS_CMD"), cmd_name);
c->Write(c, tmp);
c->Write(c, _UU("CON_AMBIGIOUS_CMD_1"));
PrintCandidateHelp(c, NULL, candidate, 1);
c->Write(c, _UU("CON_AMBIGIOUS_CMD_2"));
c->RetCode = ERR_BAD_COMMAND_OR_PARAM;
}
else
{
char *real_cmd_name;
UINT i;
// The candidate was shortlisted to one
real_cmd_name = candidate->Token[0];
for (i = 0;i < num_cmd;i++)
{
if (StrCmpi(cmd[i].Name, real_cmd_name) == 0)
{
if (cmd[i].Proc != NULL)
{
// Show the description of the command if it isn't in CSV mode
if(c->ConsoleType != CONSOLE_CSV)
{
wchar_t tmp[256];
wchar_t *note;
GetCommandHelpStr(cmd[i].Name, ¬e, NULL, NULL);
UniFormat(tmp, sizeof(tmp), _UU("CMD_EXEC_MSG_NAME"), cmd[i].Name, note);
c->Write(c, tmp);
}
// Call the procedure of the command
ret = cmd[i].Proc(c, cmd[i].Name, cmd_param, param);
if (ret == INFINITE)
{
// Exit command
b_exit = true;
}
else
{
c->RetCode = ret;
}
}
}
}
}
FreeToken(candidate);
}
FreeToken(t);
Free(str);
Free(cmd_name);
Free(cmd_param);
if (no_end_crlf == false)
{
//c->Write(c, L"");
}
if (b_exit)
{
return false;
}
return true;
}
// Plaintext password authentication of user
bool SamAuthUserByPlainPassword(CONNECTION *c, HUB *hub, char *username, char *password, bool ast, UCHAR *mschap_v2_server_response_20, RADIUS_LOGIN_OPTION *opt)
{
bool b = false;
wchar_t *name = NULL;
bool auth_by_nt = false;
HUB *h;
// Validate arguments
if (hub == NULL || c == NULL || username == NULL)
{
return false;
}
if (GetGlobalServerFlag(GSF_DISABLE_RADIUS_AUTH) != 0)
{
return false;
}
h = hub;
AddRef(h->ref);
// Get the user name on authentication system
AcLock(hub);
{
USER *u;
u = AcGetUser(hub, ast == false ? username : "******");
if (u)
{
Lock(u->lock);
{
if (u->AuthType == AUTHTYPE_RADIUS)
{
// Radius authentication
AUTHRADIUS *auth = (AUTHRADIUS *)u->AuthData;
if (ast || auth->RadiusUsername == NULL || UniStrLen(auth->RadiusUsername) == 0)
{
name = CopyStrToUni(username);
}
else
{
name = CopyUniStr(auth->RadiusUsername);
}
auth_by_nt = false;
}
else if (u->AuthType == AUTHTYPE_NT)
{
// NT authentication
AUTHNT *auth = (AUTHNT *)u->AuthData;
if (ast || auth->NtUsername == NULL || UniStrLen(auth->NtUsername) == 0)
{
name = CopyStrToUni(username);
}
else
{
name = CopyUniStr(auth->NtUsername);
}
auth_by_nt = true;
}
}
Unlock(u->lock);
ReleaseUser(u);
}
}
AcUnlock(hub);
if (name != NULL)
{
if (auth_by_nt == false)
{
// Radius authentication
char radius_server_addr[MAX_SIZE];
UINT radius_server_port;
char radius_secret[MAX_SIZE];
char suffix_filter[MAX_SIZE];
wchar_t suffix_filter_w[MAX_SIZE];
UINT interval;
Zero(suffix_filter, sizeof(suffix_filter));
Zero(suffix_filter_w, sizeof(suffix_filter_w));
// Get the Radius server information
if (GetRadiusServerEx2(hub, radius_server_addr, sizeof(radius_server_addr), &radius_server_port, radius_secret, sizeof(radius_secret), &interval, suffix_filter, sizeof(suffix_filter)))
{
Unlock(hub->lock);
StrToUni(suffix_filter_w, sizeof(suffix_filter_w), suffix_filter);
if (UniIsEmptyStr(suffix_filter_w) || UniEndWith(name, suffix_filter_w))
{
// Attempt to login
b = RadiusLogin(c, radius_server_addr, radius_server_port,
radius_secret, StrLen(radius_secret),
name, password, interval, mschap_v2_server_response_20, opt);
}
Lock(hub->lock);
}
else
{
HLog(hub, "LH_NO_RADIUS_SETTING", name);
}
}
else
{
// NT authentication (Not available for non-Win32)
#ifdef OS_WIN32
IPC_MSCHAP_V2_AUTHINFO mschap;
Unlock(hub->lock);
if (ParseAndExtractMsChapV2InfoFromPassword(&mschap, password) == false)
{
// Plaintext password authentication
b = MsCheckLogon(name, password);
}
else
{
UCHAR challenge8[8];
UCHAR nt_pw_hash_hash[16];
char nt_name[MAX_SIZE];
UniToStr(nt_name, sizeof(nt_name), name);
// MS-CHAPv2 authentication
MsChapV2_GenerateChallenge8(challenge8, mschap.MsChapV2_ClientChallenge,
mschap.MsChapV2_ServerChallenge,
mschap.MsChapV2_PPPUsername);
Debug("MsChapV2_PPPUsername = %s, nt_name = %s\n", mschap.MsChapV2_PPPUsername, nt_name);
b = MsPerformMsChapV2AuthByLsa(nt_name, challenge8, mschap.MsChapV2_ClientResponse, nt_pw_hash_hash);
if (b)
{
if (mschap_v2_server_response_20 != NULL)
{
MsChapV2Server_GenerateResponse(mschap_v2_server_response_20, nt_pw_hash_hash,
mschap.MsChapV2_ClientResponse, challenge8);
}
}
}
Lock(hub->lock);
#else // OS_WIN32
// Nothing to do other than Win32
#endif // OS_WIN32
}
// Memory release
Free(name);
}
ReleaseHub(h);
return b;
}
// Parse the command list
LIST *ParseCommandList(CONSOLE *c, char *cmd_name, wchar_t *command, PARAM param[], UINT num_param)
{
UINT i;
LIST *o;
bool ok = true;
TOKEN_LIST *param_list;
TOKEN_LIST *real_name_list;
bool help_mode = false;
wchar_t *tmp;
// Validate arguments
if (c == NULL || command == NULL || (num_param >= 1 && param == NULL) || cmd_name == NULL)
{
return NULL;
}
// Initialization
for (i = 0;i < num_param;i++)
{
if (IsEmptyStr(param[i].Name) == false)
{
if (param[i].Name[0] == '[')
{
param[i].Tmp = "";
}
else
{
param[i].Tmp = NULL;
}
}
else
{
param[i].Tmp = "";
}
}
real_name_list = ZeroMalloc(sizeof(TOKEN_LIST));
real_name_list->NumTokens = num_param;
real_name_list->Token = ZeroMalloc(sizeof(char *) * real_name_list->NumTokens);
for (i = 0;i < real_name_list->NumTokens;i++)
{
real_name_list->Token[i] = CopyStr(param[i].Name);
}
// Generate a list of parameter name specified by the user
param_list = GetCommandNameList(command);
for (i = 0;i < param_list->NumTokens;i++)
{
char *s = param_list->Token[i];
if (StrCmpi(s, "help") == 0 || StrCmpi(s, "?") == 0)
{
help_mode = true;
break;
}
}
tmp = ParseCommand(command, L"");
if (tmp != NULL)
{
if (UniStrCmpi(tmp, L"?") == 0)
{
help_mode = true;
}
Free(tmp);
}
if (help_mode)
{
// Show the help
PrintCmdHelp(c, cmd_name, real_name_list);
FreeToken(param_list);
FreeToken(real_name_list);
return NULL;
}
for (i = 0;i < param_list->NumTokens;i++)
{
// Get the corresponding commands for all parameter names which is specified by the user
TOKEN_LIST *candidate = GetRealnameCandidate(param_list->Token[i], real_name_list);
if (candidate != NULL && candidate->NumTokens >= 1)
{
if (candidate->NumTokens >= 2)
{
wchar_t tmp[MAX_SIZE];
// There is more than one candidate
UniFormat(tmp, sizeof(tmp), _UU("CON_AMBIGIOUS_PARAM"), param_list->Token[i]);
c->Write(c, tmp);
UniFormat(tmp, sizeof(tmp), _UU("CON_AMBIGIOUS_PARAM_1"), cmd_name);
c->Write(c, tmp);
PrintCandidateHelp(c, cmd_name, candidate, 1);
c->Write(c, _UU("CON_AMBIGIOUS_PARAM_2"));
ok = false;
}
else
{
UINT j;
char *real_name = candidate->Token[0];
// There is only one candidate
for (j = 0;j < num_param;j++)
{
if (StrCmpi(param[j].Name, real_name) == 0)
{
param[j].Tmp = param_list->Token[i];
}
}
}
}
else
{
wchar_t tmp[MAX_SIZE];
// No candidate
UniFormat(tmp, sizeof(tmp), _UU("CON_INVALID_PARAM"), param_list->Token[i], cmd_name, cmd_name);
c->Write(c, tmp);
ok = false;
}
FreeToken(candidate);
}
if (ok == false)
{
FreeToken(param_list);
FreeToken(real_name_list);
return NULL;
}
// Creating a list
o = NewParamValueList();
// Read all the parameters of the specified name in the parameter list
for (i = 0;i < num_param;i++)
{
bool prompt_input_value = false;
PARAM *p = ¶m[i];
if (p->Tmp != NULL || p->PromptProc != NULL)
{
wchar_t *name = CopyStrToUni(p->Name);
wchar_t *tmp;
wchar_t *str;
if (p->Tmp != NULL)
{
tmp = CopyStrToUni(p->Tmp);
}
else
{
tmp = CopyStrToUni(p->Name);
}
str = ParseCommand(command, tmp);
Free(tmp);
if (str != NULL)
{
wchar_t *unistr;
bool ret;
EVAL_VALUE:
// Reading succeeded
unistr = str;
if (p->EvalProc != NULL)
{
// Evaluate the value if EvalProc is specified
ret = p->EvalProc(c, unistr, p->EvalProcParam);
}
else
{
// Accept any value if EvalProc is not specified
ret = true;
}
if (ret == false)
{
// The specified value is invalid
if (p->PromptProc == NULL)
{
// Cancel
ok = false;
Free(name);
Free(str);
break;
}
else if (c->ProgrammingMode)
{
// In the programming mode, return the error immediately.
ok = false;
Free(name);
Free(str);
break;
}
else
{
// Request to re-enter
Free(str);
str = NULL;
goto SHOW_PROMPT;
}
}
else
{
PARAM_VALUE *v;
// Finished loading, add it to the list
v = ZeroMalloc(sizeof(PARAM_VALUE));
v->Name = CopyStr(p->Name);
v->StrValue = CopyUniToStr(str);
v->UniStrValue = CopyUniStr(str);
v->IntValue = ToInt(v->StrValue);
Insert(o, v);
}
}
else
{
// Failed to read. The parameter is not specified
if (p->PromptProc != NULL)
{
wchar_t *tmp;
SHOW_PROMPT:
// Prompt because it is a mandatory parameter
tmp = NULL;
if (c->ProgrammingMode == false)
{
tmp = p->PromptProc(c, p->PromptProcParam);
}
if (tmp == NULL)
{
// User canceled
ok = false;
Free(str);
Free(name);
break;
}
else
{
// Entered by the user
c->Write(c, L"");
str = tmp;
prompt_input_value = true;
goto EVAL_VALUE;
}
}
}
Free(str);
Free(name);
}
}
FreeToken(param_list);
FreeToken(real_name_list);
if (ok)
{
return o;
}
else
{
FreeParamValueList(o);
return NULL;
}
}
