//---------------------------------------------------------------------------
void __fastcall TGUIConfiguration::LoadData(THierarchicalStorage * Storage)
{
TConfiguration::LoadData(Storage);
// duplicated from core\configuration.cpp
#define KEYEX(TYPE, VAR, NAME) VAR = Storage->Read ## TYPE(NAME, VAR)
#pragma warn -eas
REGCONFIG(false);
#pragma warn +eas
#undef KEYEX
if (Storage->OpenSubKey(L"Interface\\CopyParam", false, true))
try
{
// must be loaded before eventual setting defaults for CopyParamList
FDefaultCopyParam.Load(Storage);
int CopyParamListCount = Storage->ReadInteger(L"CopyParamList", -1);
FCopyParamListDefaults = (CopyParamListCount < 0);
if (!FCopyParamListDefaults)
{
FCopyParamList->Clear();
FCopyParamList->Load(Storage, CopyParamListCount);
}
else if (FCopyParamList->Modified)
{
FCopyParamList->Clear();
FCopyParamListDefaults = false;
}
FCopyParamList->Reset();
}
__finally
{
Storage->CloseSubKey();
}
// Make it compatible with versions prior to 3.7.1 that have not saved PuttyPath
// with quotes. First check for absence of quotes.
// Add quotes either if the path is set to default putty path (even if it does
// not exists) or when the path points to existing file (so there are no parameters
// yet in the string). Note that FileExists may display error dialog, but as
// it should be called only for custom users path, let's expect that the user
// can take care of it.
if ((FPuttyPath.SubString(1, 1) != L"\"") &&
(CompareFileName(ExpandEnvironmentVariables(FPuttyPath), FDefaultPuttyPathOnly) ||
FileExists(ExpandEnvironmentVariables(FPuttyPath))))
{
FPuttyPath = FormatCommand(FPuttyPath, L"");
}
if (Storage->OpenSubKey(L"Interface\\NewDirectory2", false, true))
try
{
FNewDirectoryProperties.Load(Storage);
}
__finally
{
Storage->CloseSubKey();
}
}
//---------------------------------------------------------------------
void __fastcall TCleanupDialog::InitControls()
{
for (int i = wdConfiguration; i <= wdTemporaryFolders; i++)
{
UnicodeString Caption;
UnicodeString Location;
switch (i)
{
case wdConfiguration:
Caption = LoadStr(CLEANUP_CONFIG);
Location = Configuration->ConfigurationSubKey;
break;
case wdStoredSessions:
Caption = LoadStr(CLEANUP_SESSIONS);
Location = Configuration->StoredSessionsSubKey;
break;
case wdHostKeys:
Caption = LoadStr(CLEANUP_HOSTKEYS);
Location = Configuration->SshHostKeysSubKey;
break;
case wdConfigurationIniFile:
Caption = LoadStr(CLEANUP_INIFILE);
Location = ExpandEnvironmentVariables(Configuration->IniFileStorageNameForReading);
break;
case wdRandomSeedFile:
Caption = LoadStr(CLEANUP_SEEDFILE);
Location = ExpandEnvironmentVariables(Configuration->RandomSeedFile);
break;
case wdTemporaryFolders:
Caption = LoadStr(CLEANUP_TEMP_FOLDERS);
Location = WinConfiguration->TemporaryDir(true);
break;
default:
FAIL;
break;
}
TListItem * Item = DataListView->Items->Add();
Item->Caption = Caption;
if (i < wdConfigurationIniFile)
{
Location = Configuration->RootKeyStr + L'\\' +
Configuration->RegistryStorageKey + L'\\' + Location;
}
Item->SubItems->Add(Location);
assert(Item->Index == i - 1);
}
AutoSizeListColumnsWidth(DataListView);
}
void __fastcall BrowseForExecutableT(T * Control, UnicodeString Title,
UnicodeString Filter, bool FileNameCommand, bool Escape)
{
UnicodeString Executable, Program, Params, Dir;
Executable = Control->Text;
if (FileNameCommand)
{
ReformatFileNameCommand(Executable);
}
SplitCommand(Executable, Program, Params, Dir);
TOpenDialog * FileDialog = new TOpenDialog(Application);
try
{
if (Escape)
{
Program = ReplaceStr(Program, L"\\\\", L"\\");
}
UnicodeString ExpandedProgram = ExpandEnvironmentVariables(Program);
FileDialog->FileName = ExpandedProgram;
UnicodeString InitialDir = ExtractFilePath(ExpandedProgram);
if (!InitialDir.IsEmpty())
{
FileDialog->InitialDir = InitialDir;
}
FileDialog->Filter = Filter;
FileDialog->Title = Title;
if (FileDialog->Execute())
{
TNotifyEvent PrevOnChange = Control->OnChange;
Control->OnChange = NULL;
try
{
// preserve unexpanded file, if the destination has not changed actually
if (!CompareFileName(ExpandedProgram, FileDialog->FileName))
{
Program = FileDialog->FileName;
if (Escape)
{
Program = ReplaceStr(Program, L"\\", L"\\\\");
}
}
Control->Text = FormatCommand(Program, Params);
}
__finally
{
Control->OnChange = PrevOnChange;
}
if (Control->OnExit != NULL)
{
Control->OnExit(Control);
}
}
}
Dictionary_Entry_Value* Dictionary_Entry_Value_FromStringTo( char* string, char type ) {
Dictionary_Entry_Value* retValue = Memory_Alloc( Dictionary_Entry_Value, "Return Value" );
/* need to create the value temporarily so it can be converted if necessary */
retValue->type = Dictionary_Entry_Value_Type_String;
if ( string ) {
retValue->as.typeString = ExpandEnvironmentVariables( string );
}
else {
retValue->as.typeString = string;
}
switch (type) {
case Dictionary_Entry_Value_Type_String:
Dictionary_Entry_Value_InitFromString( retValue, retValue->as.typeString );
break;
case Dictionary_Entry_Value_Type_Double:
Dictionary_Entry_Value_InitFromDouble( retValue, Dictionary_Entry_Value_AsDouble( retValue ) );
break;
case Dictionary_Entry_Value_Type_UnsignedInt:
Dictionary_Entry_Value_InitFromUnsignedInt( retValue, Dictionary_Entry_Value_AsUnsignedInt( retValue ) );
break;
case Dictionary_Entry_Value_Type_Int:
Dictionary_Entry_Value_InitFromInt( retValue, Dictionary_Entry_Value_AsInt( retValue ) );
break;
case Dictionary_Entry_Value_Type_UnsignedLong:
Dictionary_Entry_Value_InitFromUnsignedLong( retValue, Dictionary_Entry_Value_AsUnsignedLong( retValue ) );
break;
case Dictionary_Entry_Value_Type_Bool:
Dictionary_Entry_Value_InitFromBool( retValue, Dictionary_Entry_Value_AsBool( retValue ) );
break;
case Dictionary_Entry_Value_Type_Struct:
Dictionary_Entry_Value_InitNewStruct( retValue );
break;
case Dictionary_Entry_Value_Type_List:
Dictionary_Entry_Value_InitNewList( retValue );
break;
default: {
Stream* errorStream = Journal_Register( Error_Type, "Dictionary_Entry_Value" );
Journal_Firewall( False, errorStream, "In func %s: type '%d' is invalid.\n", __func__, type );
}
}
return retValue;
}
//---------------------------------------------------------------------------
void __fastcall OpenSessionInPutty(const UnicodeString PuttyPath,
TSessionData * SessionData)
{
UnicodeString Program, AParams, Dir;
SplitCommand(PuttyPath, Program, AParams, Dir);
Program = ExpandEnvironmentVariables(Program);
if (FindFile(Program))
{
AParams = ExpandEnvironmentVariables(AParams);
UnicodeString Password = GUIConfiguration->PuttyPassword ? SessionData->Password : UnicodeString();
TCustomCommandData Data(SessionData, SessionData->UserName, Password);
TRemoteCustomCommand RemoteCustomCommand(Data, SessionData->RemoteDirectory);
TWinInteractiveCustomCommand InteractiveCustomCommand(
&RemoteCustomCommand, L"PuTTY");
UnicodeString Params =
RemoteCustomCommand.Complete(InteractiveCustomCommand.Complete(AParams, false), true);
if (!RemoteCustomCommand.IsSiteCommand(AParams))
{
UnicodeString SessionName;
TRegistryStorage * Storage = NULL;
TSessionData * ExportData = NULL;
TRegistryStorage * SourceStorage = NULL;
try
{
Storage = new TRegistryStorage(Configuration->PuttySessionsKey);
Storage->AccessMode = smReadWrite;
// make it compatible with putty
Storage->MungeStringValues = false;
Storage->ForceAnsi = true;
if (Storage->OpenRootKey(true))
{
if (Storage->KeyExists(SessionData->StorageKey))
{
SessionName = SessionData->SessionName;
}
else
{
SourceStorage = new TRegistryStorage(Configuration->PuttySessionsKey);
SourceStorage->MungeStringValues = false;
SourceStorage->ForceAnsi = true;
if (SourceStorage->OpenSubKey(StoredSessions->DefaultSettings->Name, false) &&
Storage->OpenSubKey(GUIConfiguration->PuttySession, true))
{
Storage->Copy(SourceStorage);
Storage->CloseSubKey();
}
ExportData = new TSessionData(L"");
ExportData->Assign(SessionData);
ExportData->Modified = true;
ExportData->Name = GUIConfiguration->PuttySession;
ExportData->Password = L"";
if (SessionData->FSProtocol == fsFTP)
{
if (GUIConfiguration->TelnetForFtpInPutty)
{
ExportData->PuttyProtocol = PuttyTelnetProtocol;
ExportData->PortNumber = TelnetPortNumber;
// PuTTY does not allow -pw for telnet
Password = L"";
}
else
{
ExportData->PuttyProtocol = PuttySshProtocol;
ExportData->PortNumber = SshPortNumber;
}
}
ExportData->Save(Storage, true);
SessionName = GUIConfiguration->PuttySession;
}
}
}
__finally
{
delete Storage;
delete ExportData;
delete SourceStorage;
}
AddToList(Params, FORMAT(L"-load %s", (EscapePuttyCommandParam(SessionName))), L" ");
}
if (!Password.IsEmpty() && !RemoteCustomCommand.IsPasswordCommand(AParams))
{
AddToList(Params, FORMAT(L"-pw %s", (EscapePuttyCommandParam(Password))), L" ");
}
if (!ExecuteShell(Program, Params))
{
throw Exception(FMTLOAD(EXECUTE_APP_ERROR, (Program)));
}
}
//---------------------------------------------------------------------
UnicodeString TConfiguration::GetRandomSeedFileName() const
{
return StripPathQuotes(ExpandEnvironmentVariables(FRandomSeedFile)).Trim();
}
void OpenSessionInPutty(const UnicodeString & PuttyPath,
TSessionData * SessionData)
{
UnicodeString Program, Params, Dir;
SplitCommand(PuttyPath, Program, Params, Dir);
Program = ExpandEnvironmentVariables(Program);
if (FindFile(Program))
{
Params = ExpandEnvironmentVariables(Params);
UnicodeString Password = GetGUIConfiguration()->GetPuttyPassword() ? SessionData->GetPassword() : UnicodeString();
UnicodeString Psw = Password;
UnicodeString SessionName;
std::unique_ptr<TRegistryStorage> Storage(new TRegistryStorage(GetConfiguration()->GetPuttySessionsKey()));
Storage->SetAccessMode(smReadWrite);
// make it compatible with putty
Storage->SetMungeStringValues(false);
Storage->SetForceAnsi(true);
if (Storage->OpenRootKey(true))
{
if (Storage->KeyExists(SessionData->GetStorageKey()))
{
SessionName = SessionData->GetSessionName();
}
else
{
std::unique_ptr<TRegistryStorage> SourceStorage(new TRegistryStorage(GetConfiguration()->GetPuttySessionsKey()));
SourceStorage->SetMungeStringValues(false);
SourceStorage->SetForceAnsi(true);
if (SourceStorage->OpenSubKey(StoredSessions->GetDefaultSettings()->GetName(), false) &&
Storage->OpenSubKey(GetGUIConfiguration()->GetPuttySession(), true))
{
Storage->Copy(SourceStorage.get());
Storage->CloseSubKey();
}
std::unique_ptr<TSessionData> ExportData(new TSessionData(L""));
ExportData->Assign(SessionData);
ExportData->SetModified(true);
ExportData->SetName(GetGUIConfiguration()->GetPuttySession());
ExportData->SetPassword(L"");
if (SessionData->GetFSProtocol() == fsFTP)
{
if (GetGUIConfiguration()->GetTelnetForFtpInPutty())
{
ExportData->SetPuttyProtocol(PuttyTelnetProtocol);
ExportData->SetPortNumber(TelnetPortNumber);
// PuTTY does not allow -pw for telnet
Psw.Clear();
}
else
{
ExportData->SetPuttyProtocol(PuttySshProtocol);
ExportData->SetPortNumber(SshPortNumber);
}
}
ExportData->Save(Storage.get(), true);
SessionName = GetGUIConfiguration()->GetPuttySession();
}
}
if (!Params.IsEmpty())
{
Params += L" ";
}
if (!Psw.IsEmpty())
{
Params += FORMAT(L"-pw %s ", EscapePuttyCommandParam(Psw).c_str());
}
//Params += FORMAT(L"-load %s", EscapePuttyCommandParam(SessionName).c_str());
Params += FORMAT(L"-l %s ", EscapePuttyCommandParam(SessionData->GetUserNameExpanded()).c_str());
Params += FORMAT(L"-P %d ", SessionData->GetPortNumber());
Params += FORMAT(L"%s ", EscapePuttyCommandParam(SessionData->GetHostNameExpanded()).c_str());
if (!ExecuteShell(Program, Params))
{
throw Exception(FMTLOAD(EXECUTE_APP_ERROR, Program.c_str()));
}
}
else
{
throw Exception(FMTLOAD(FILE_NOT_FOUND, Program.c_str()));
}
}
