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; } }