//---------------------------------------------------------------------------
int __fastcall TRichEdit20::FindText(const UnicodeString SearchStr, int StartPos,
int /*Length*/, TSearchTypes Options, bool Down)
{
int Result;
if (FVersion20)
{
::FINDTEXTEX Find;
memset(&Find, 0, sizeof(Find));
Find.chrg.cpMin = StartPos;
Find.chrg.cpMax = -1;
Find.lpstrText = UnicodeString(SearchStr).c_str();
unsigned int Flags =
FLAGMASK(Options.Contains(stWholeWord), FR_WHOLEWORD) |
FLAGMASK(Options.Contains(stMatchCase), FR_MATCHCASE) |
FLAGMASK(Down, FR_DOWN);
Result = SendMessage(Handle, EM_FINDTEXTEX, Flags, (LPARAM)&Find);
}
else
{
assert(Down);
Result = TRichEdit::FindText(SearchStr, StartPos, Text.Length(), Options);
}
return Result;
}
//---------------------------------------------------------------------------
UnicodeString __fastcall TGenerateUrlDialog::GenerateUrl(UnicodeString Path)
{
UnicodeString Url =
FData->GenerateSessionUrl(
FLAGMASK(WinSCPSpecificCheck->Checked, sufSpecific) |
FLAGMASK(UserNameCheck->Enabled && UserNameCheck->Checked, sufUserName) |
FLAGMASK(PasswordCheck->Enabled && PasswordCheck->Checked, sufPassword) |
FLAGMASK(HostKeyCheck->Enabled && HostKeyCheck->Checked, sufHostKey));
if ((RemoteDirectoryCheck->Enabled && RemoteDirectoryCheck->Checked) ||
(FPaths != NULL))
{
if (StartsStr(L"/", Path));
{
Path.Delete(1, 1);
}
Url += EncodeUrlPath(Path);
}
if (SaveExtensionCheck->Enabled && SaveExtensionCheck->Checked)
{
Url += UnicodeString(UrlParamSeparator) + UrlSaveParamName;
}
return Url;
}
//---------------------------------------------------------------------------
int __fastcall TCustomCommandDialog::GetParams()
{
return
(FParams & ~(ccApplyToDirectories | ccRecursive | ccLocal |
ccShowResults | ccCopyResults)) |
FLAGMASK(!RemoteCommandButton->Checked, ccLocal) |
FLAGMASK(ApplyToDirectoriesCheck->Checked, ccApplyToDirectories) |
FLAGMASK(RecursiveCheck->Checked && RecursiveCheck->Enabled, ccRecursive) |
FLAGMASK(ShowResultsCheck->Checked && ShowResultsCheck->Enabled, ccShowResults) |
FLAGMASK(CopyResultsCheck->Checked && CopyResultsCheck->Enabled, ccCopyResults);
}
//---------------------------------------------------------------------------
int __fastcall TFullSynchronizeDialog::ActualCopyParamAttrs()
{
int Result;
if (SynchronizeTimestampsButton->Checked)
{
Result = cpaIncludeMaskOnly;
}
else
{
switch (Mode)
{
case smRemote:
Result = CopyParamAttrs.Upload;
break;
case smLocal:
Result = CopyParamAttrs.Download;
break;
default:
assert(false);
//fallthru
case smBoth:
Result = CopyParamAttrs.General;
break;
}
}
return
Result |
FLAGMASK(SynchronizeByTimeCheck->Checked, cpaNoPreserveTime) |
cpaNoNewerOnly;
}
//---------------------------------------------------------------------------
void __fastcall TSynchronizeDialog::DoStartStop(bool Start, bool Synchronize)
{
if (FOnStartStop)
{
TSynchronizeParamType SParams = GetParams();
SParams.Options =
(SParams.Options & ~(soSynchronize | soSynchronizeAsk)) |
FLAGMASK(Synchronize, soSynchronize);
if (Start)
{
DebugAssert(*FOnFeedSynchronizeError == NULL);
*FOnFeedSynchronizeError =
(FLAGSET(SParams.Options, soContinueOnError) ? &FeedSynchronizeError : TFeedSynchronizeError(NULL));
delete FSynchronizeOptions;
FSynchronizeOptions = new TSynchronizeOptions;
FOnGetOptions(SParams.Params, *FSynchronizeOptions);
}
else
{
*FOnFeedSynchronizeError = NULL;
}
FOnStartStop(this, Start, SParams, CopyParams, FSynchronizeOptions, DoAbort,
NULL, DoLog);
}
}
//---------------------------------------------------------------------------
void __fastcall TCopyDialog::UpdateControls()
{
if (!FToRemote && FLAGSET(FOptions, coAllowRemoteTransfer))
{
UnicodeString Directory = DirectoryEdit->Text;
bool RemoteTransfer = (Directory.Pos(L"\\") == 0) && (Directory.Pos(L"/") > 0);
if (RemoteTransfer != FLAGSET(FOutputOptions, cooRemoteTransfer))
{
FOutputOptions =
(FOutputOptions & ~cooRemoteTransfer) |
FLAGMASK(RemoteTransfer, cooRemoteTransfer);
AdjustTransferControls();
}
}
UnicodeString InfoStr = FCopyParams.GetInfoStr(L"; ", FCopyParamAttrs);
CopyParamLabel->Caption = InfoStr;
CopyParamLabel->Hint = InfoStr;
CopyParamLabel->ShowHint =
(CopyParamLabel->Canvas->TextWidth(InfoStr) > (CopyParamLabel->Width * 3 / 2));
bool RemoteTransfer = FLAGSET(FOutputOptions, cooRemoteTransfer);
EnableControl(QueueCheck2,
((FOptions & (coDisableQueue | coTemp)) == 0) && !RemoteTransfer);
QueueIndividuallyCheck->Visible =
FLAGCLEAR(FOptions, coNoQueueIndividually) &&
QueueCheck2->Enabled && QueueCheck2->Checked &&
(FFileList != NULL) && (FFileList->Count > 1);
TransferSettingsButton->Style =
FLAGCLEAR(FOptions, coDoNotUsePresets) ?
TCustomButton::bsSplitButton : TCustomButton::bsPushButton;
}
//---------------------------------------------------------------------------
int __fastcall TFullSynchronizeDialog::GetParams()
{
return FParams |
FLAGMASK(SynchronizeDeleteCheck->Checked, spDelete) |
FLAGMASK(SynchronizeExistingOnlyCheck->Checked, spExistingOnly) |
FLAGMASK(SynchronizePreviewChangesCheck->Checked, spPreviewChanges) |
FLAGMASK(SynchronizeSelectedOnlyCheck->Checked, spSelectedOnly) |
FLAGMASK(SynchronizeTimestampsButton->Checked && FLAGCLEAR(Options, fsoDisableTimestamp),
spTimestamp) |
FLAGMASK(MirrorFilesButton->Checked, spMirror) |
FLAGMASK(!SynchronizeByTimeCheck->Checked, spNotByTime) |
FLAGMASK(SynchronizeBySizeCheck->Checked, spBySize);
}
//---------------------------------------------------------------------------
void __fastcall TCopyDialog::CopyParamListPopup(TRect R, int AdditionalOptions)
{
bool RemoteTransfer = FLAGSET(FOutputOptions, cooRemoteTransfer);
::CopyParamListPopup(R, FPresetsMenu,
FCopyParams, FPreset, CopyParamClick,
cplCustomize | AdditionalOptions |
FLAGMASK(
FLAGCLEAR(FOptions, coDisableSaveSettings) && !RemoteTransfer,
cplSaveSettings),
FCopyParamAttrs,
FSaveSettings);
}
//---------------------------------------------------------------------------
void __fastcall TSynchronizeDialog::DoStartStop(bool Start, bool Synchronize)
{
if (FOnStartStop)
{
TSynchronizeParamType SParams = GetParams();
SParams.Options =
(SParams.Options & ~(soSynchronize | soSynchronizeAsk)) |
FLAGMASK(Synchronize, soSynchronize);
if (Start)
{
delete FSynchronizeOptions;
FSynchronizeOptions = new TSynchronizeOptions;
FOnGetOptions(SParams.Params, *FSynchronizeOptions);
}
FOnStartStop(this, Start, SParams, CopyParams, FSynchronizeOptions, DoAbort,
NULL, DoLog);
}
}
//---------------------------------------------------------------------------
int get_userpass_input(prompts_t * p, unsigned char * /*in*/, int /*inlen*/)
{
assert(p != NULL);
TSecureShell * SecureShell = reinterpret_cast<TSecureShell *>(p->frontend);
assert(SecureShell != NULL);
int Result;
TStrings * Prompts = new TStringList();
TStrings * Results = new TStringList();
try
{
for (int Index = 0; Index < int(p->n_prompts); Index++)
{
prompt_t * Prompt = p->prompts[Index];
Prompts->AddObject(Prompt->prompt, (TObject *)(FLAGMASK(Prompt->echo, pupEcho)));
// this fails, when new passwords do not match on change password prompt,
// and putty retries the prompt
assert(Prompt->resultsize == 0);
Results->Add(L"");
}
if (SecureShell->PromptUser(p->to_server, p->name, p->name_reqd,
p->instruction, p->instr_reqd, Prompts, Results))
{
for (int Index = 0; Index < int(p->n_prompts); Index++)
{
prompt_t * Prompt = p->prompts[Index];
prompt_set_result(Prompt, AnsiString(Results->Strings[Index]).c_str());
}
Result = 1;
}
else
{
Result = 0;
}
}
__finally
{
delete Prompts;
delete Results;
}
return Result;
}
//---------------------------------------------------------------------------
TSynchronizeParamType __fastcall TSynchronizeDialog::GetParams()
{
TSynchronizeParamType Result = FParams;
Result.RemoteDirectory = RemoteDirectoryEdit->Text;
Result.LocalDirectory = LocalDirectoryEdit->Text;
Result.Params =
(Result.Params & ~(spDelete | spExistingOnly | spSelectedOnly | spTimestamp)) |
FLAGMASK(SynchronizeDeleteCheck->Checked, spDelete) |
FLAGMASK(SynchronizeExistingOnlyCheck->Checked, spExistingOnly) |
FLAGMASK(SynchronizeSelectedOnlyCheck->Checked, spSelectedOnly);
Result.Options =
(Result.Options & ~(soRecurse | soSynchronize | soSynchronizeAsk | soContinueOnError)) |
FLAGMASK(SynchronizeRecursiveCheck->Checked, soRecurse) |
FLAGMASK(SynchronizeSynchronizeCheck->State == cbChecked, soSynchronize) |
FLAGMASK(SynchronizeSynchronizeCheck->State == cbGrayed, soSynchronizeAsk) |
FLAGMASK(ContinueOnErrorCheck->Checked, soContinueOnError);
return Result;
}
//---------------------------------------------------------------------------
bool __fastcall TAuthenticateForm::PromptUser(TPromptKind Kind, UnicodeString Name,
UnicodeString Instructions, TStrings * Prompts, TStrings * Results, bool ForceLog,
bool StoredCredentialsTried)
{
bool Result;
TList * Edits = GeneratePrompt(Instructions, Prompts);
try
{
bool ShowSessionRememberPasswordPanel = false;
bool ShowSavePasswordPanel = false;
TSessionData * Data = NULL;
bool PasswordPrompt =
((Kind == pkPassword) || (Kind == pkTIS) || (Kind == pkCryptoCard) ||
(Kind == pkKeybInteractive)) &&
(Prompts->Count == 1) && FLAGCLEAR(int(Prompts->Objects[0]), pupEcho);
if (PasswordPrompt && StoredCredentialsTried)
{
Data = StoredSessions->FindSame(FSessionData);
ShowSavePasswordPanel = (Data != NULL) && !Data->Password.IsEmpty();
}
// do not offer to rememeber password,
// if we are offering to save the password to stored session
if (!ShowSavePasswordPanel &&
(Prompts->Count == 1) &&
FLAGSET(int(Prompts->Objects[0]), pupRemember) &&
ALWAYS_TRUE(PasswordPrompt))
{
ShowSessionRememberPasswordPanel = true;
}
SavePasswordCheck->Checked = false;
SavePasswordPanel->Visible = ShowSavePasswordPanel;
SessionRememberPasswordCheck->Checked = false;
SessionRememberPasswordPanel->Visible = ShowSessionRememberPasswordPanel;
if (PasswordPanel->AutoSize)
{
PasswordPanel->AutoSize = false;
PasswordPanel->AutoSize = true;
}
PasswordPanel->Realign();
assert(Results->Count == Edits->Count);
for (int Index = 0; Index < Edits->Count; Index++)
{
TCustomEdit * Edit = reinterpret_cast<TCustomEdit *>(Edits->Items[Index]);
Edit->Text = Results->Strings[Index];
}
Result = Execute(Name, PasswordPanel,
((Edits->Count > 0) ?
reinterpret_cast<TWinControl *>(Edits->Items[0]) :
static_cast<TWinControl *>(PasswordOKButton)),
PasswordOKButton, PasswordCancelButton, true, false, ForceLog);
if (Result)
{
for (int Index = 0; Index < Edits->Count; Index++)
{
TCustomEdit * Edit = reinterpret_cast<TCustomEdit *>(Edits->Items[Index]);
Results->Strings[Index] = Edit->Text;
Prompts->Objects[Index] = (TObject *)
((int(Prompts->Objects[Index]) & ~pupRemember) |
FLAGMASK(((Index == 0) && SessionRememberPasswordCheck->Checked), pupRemember));
}
if (SavePasswordCheck->Checked)
{
assert(Data != NULL);
assert(Results->Count >= 1);
FSessionData->Password = Results->Strings[0];
Data->Password = Results->Strings[0];
// modified only, explicit
StoredSessions->Save(false, true);
}
}
}
__finally
{
delete Edits;
}
return Result;
}
//---------------------------------------------------------------------------
void __fastcall TSynchronizeChecklistDialog::LoadItem(TListItem * Item)
{
UnicodeString S;
const TSynchronizeChecklist::TItem * ChecklistItem = FChecklist->Item[Item->Index];
Item->Data = const_cast<TSynchronizeChecklist::TItem *>(ChecklistItem);
Item->Checked = ChecklistItem->Checked;
if (ChecklistItem->ImageIndex >= 0)
{
Item->ImageIndex = ChecklistItem->ImageIndex;
}
else
{
Item->ImageIndex = FakeFileImageIndex(ChecklistItem->GetFileName(),
FLAGMASK(ChecklistItem->IsDirectory, FILE_ATTRIBUTE_DIRECTORY));
}
S = ChecklistItem->GetFileName();
if (ChecklistItem->IsDirectory)
{
S = IncludeTrailingBackslash(S);
}
Item->Caption = S;
if (ChecklistItem->Action == TSynchronizeChecklist::saDeleteRemote)
{
Item->SubItems->Add(L"");
Item->SubItems->Add(L"");
Item->SubItems->Add(L"");
}
else
{
S = ChecklistItem->Local.Directory;
if (AnsiSameText(FLocalDirectory, S.SubString(1, FLocalDirectory.Length())))
{
S[1] = L'.';
S.Delete(2, FLocalDirectory.Length() - 1);
}
else
{
assert(false);
}
Item->SubItems->Add(S);
if (ChecklistItem->Action == TSynchronizeChecklist::saDownloadNew)
{
Item->SubItems->Add(L"");
Item->SubItems->Add(L"");
}
else
{
if (ChecklistItem->IsDirectory)
{
Item->SubItems->Add(L"");
}
else
{
Item->SubItems->Add(
FormatBytes(ChecklistItem->Local.Size,
WinConfiguration->FormatSizeBytes, WinConfiguration->FormatSizeBytes));
}
Item->SubItems->Add(UserModificationStr(ChecklistItem->Local.Modification,
ChecklistItem->Local.ModificationFmt));
}
}
Item->SubItems->Add(L"");
if (ChecklistItem->Action == TSynchronizeChecklist::saDeleteLocal)
{
Item->SubItems->Add(L"");
Item->SubItems->Add(L"");
Item->SubItems->Add(L"");
}
else
{
S = ChecklistItem->Remote.Directory;
if (AnsiSameText(FRemoteDirectory, S.SubString(1, FRemoteDirectory.Length())))
{
S[1] = L'.';
S.Delete(2, FRemoteDirectory.Length() - 1);
}
else
{
assert(false);
}
Item->SubItems->Add(S);
if (ChecklistItem->Action == TSynchronizeChecklist::saUploadNew)
{
Item->SubItems->Add(L"");
Item->SubItems->Add(L"");
}
else
{
if (ChecklistItem->IsDirectory)
{
Item->SubItems->Add(L"");
}
else
{
Item->SubItems->Add(
FormatBytes(ChecklistItem->Remote.Size,
WinConfiguration->FormatSizeBytes, WinConfiguration->FormatSizeBytes));
}
Item->SubItems->Add(UserModificationStr(ChecklistItem->Remote.Modification,
ChecklistItem->Remote.ModificationFmt));
}
}
}
int GetUserpassInput(prompts_t * p, const uint8_t * /*in*/, int /*inlen*/)
{
DebugAssert(p != nullptr);
TSecureShell * SecureShell = NB_STATIC_DOWNCAST(TSecureShell, p->frontend);
DebugAssert(SecureShell != nullptr);
int Result;
std::unique_ptr<TStrings> Prompts(new TStringList());
std::unique_ptr<TStrings> Results(new TStringList());
{
UnicodeString Name = UTF8ToString(p->name);
UnicodeString AName = Name;
TPromptKind PromptKind = SecureShell->IdentifyPromptKind(AName);
bool UTF8Prompt = (PromptKind != pkPassphrase);
for (size_t Index = 0; Index < p->n_prompts; ++Index)
{
prompt_t * Prompt = p->prompts[Index];
UnicodeString S;
if (UTF8Prompt)
{
S = UTF8ToString(Prompt->prompt);
}
else
{
S = UnicodeString(AnsiString(Prompt->prompt));
}
Prompts->AddObject(S, reinterpret_cast<TObject *>(static_cast<size_t>(FLAGMASK(Prompt->echo, pupEcho))));
// this fails, when new passwords do not match on change password prompt,
// and putty retries the prompt
DebugAssert(Prompt->resultsize == 0);
Results->Add(L"");
}
UnicodeString Instructions = UTF8ToString(p->instruction);
if (SecureShell->PromptUser(p->to_server != 0, Name, p->name_reqd != 0,
Instructions, p->instr_reqd != 0, Prompts.get(), Results.get()))
{
for (size_t Index = 0; Index < p->n_prompts; ++Index)
{
prompt_t * Prompt = p->prompts[Index];
RawByteString S;
if (UTF8Prompt)
{
S = RawByteString(UTF8String(Results->GetString(Index)));
}
else
{
S = RawByteString(AnsiString(Results->GetString(Index)));
}
prompt_set_result(Prompt, S.c_str());
}
Result = 1;
}
else
{
Result = 0;
}
}
__finally
{
// delete Prompts;
// delete Results;
};
return Result;
}
int GetUserpassInput(prompts_t * p, const uint8_t * /*in*/, int /*inlen*/)
{
assert(p != nullptr);
TSecureShell * SecureShell = NB_STATIC_DOWNCAST(TSecureShell, p->frontend);
assert(SecureShell != nullptr);
int Result;
std::unique_ptr<TStrings> Prompts(new TStringList());
std::unique_ptr<TStrings> Results(new TStringList());
{
for (size_t Index = 0; Index < p->n_prompts; ++Index)
{
prompt_t * Prompt = p->prompts[Index];
Prompts->AddObject(Prompt->prompt, reinterpret_cast<TObject *>(static_cast<size_t>(FLAGMASK(Prompt->echo, pupEcho))));
// this fails, when new passwords do not match on change password prompt,
// and putty retries the prompt
assert(Prompt->resultsize == 0);
Results->Add(L"");
}
if (SecureShell->PromptUser(p->to_server != 0, p->name, p->name_reqd != 0,
UnicodeString(p->instruction), p->instr_reqd != 0, Prompts.get(), Results.get()))
{
for (size_t Index = 0; Index < p->n_prompts; ++Index)
{
prompt_t * Prompt = p->prompts[Index];
prompt_set_result(Prompt, AnsiString(Results->GetString(Index).c_str()).c_str());
}
Result = 1;
}
else
{
Result = 0;
}
}
return Result;
}
//---------------------------------------------------------------------------
int __fastcall TCopyDialog::GetOutputOptions()
{
return FOutputOptions |
FLAGMASK(FSaveSettings, cooSaveSettings) |
FLAGMASK(NeverShowAgainCheck->Checked, cooDoNotShowAgain);
}
