//---------------------------------------------------------------------------
void __fastcall ::TTrayIcon::PopupBalloon(UnicodeString Title,
const UnicodeString & Str, TQueryType QueryType, unsigned int Timeout,
TNotifyEvent OnBalloonClick, TObject * BalloonUserData)
{
if (Timeout > 30000)
{
// this is probably system limit, do not try more, especially for
// the timeout-driven hiding of the tray icon (for Win2k)
Timeout = 30000;
}
FTrayIcon->uFlags |= NIF_INFO;
Title = FORMAT(L"%s - %s", (Title, AppNameString()));
StrPLCopy(FTrayIcon->szInfoTitle, Title, LENOF(FTrayIcon->szInfoTitle) - 1);
UnicodeString Info = Str;
// When szInfo is empty, balloon is not shown
// (or actually it means the balloon should be deleted, if any)
if (Info.IsEmpty())
{
Info = L" ";
}
StrPLCopy(FTrayIcon->szInfo, Info, LENOF(FTrayIcon->szInfo) - 1);
FTrayIcon->uTimeout = Timeout;
switch (QueryType)
{
case qtError:
FTrayIcon->dwInfoFlags = NIIF_ERROR;
break;
case qtInformation:
case qtConfirmation:
FTrayIcon->dwInfoFlags = NIIF_INFO;
break;
case qtWarning:
default:
FTrayIcon->dwInfoFlags = NIIF_WARNING;
break;
}
KillTimer(FTrayIcon->hWnd, 1);
if (Visible)
{
Update();
}
else
{
Notify(NIM_ADD);
}
FOnBalloonClick = OnBalloonClick;
delete FBalloonUserData;
FBalloonUserData = BalloonUserData;
// Clearing the flag ensures that subsequent updates does not hide the baloon
// unless CancelBalloon is called explicitly
FTrayIcon->uFlags = FTrayIcon->uFlags & ~NIF_INFO;
}
//---------------------------------------------------------------------------
static void SSHFatalError(const char * Format, va_list Param)
{
char Buf[200];
vsnprintf(Buf, LENOF(Buf), Format, Param);
Buf[LENOF(Buf) - 1] = '\0';
// Only few calls from putty\winnet.c might be connected with specific
// TSecureShell. Otherwise called only for really fatal errors
// like 'out of memory' from putty\ssh.c.
throw ESshFatal(NULL, Buf);
}
//---------------------------------------------------------------------------
void connection_fatal(void * frontend, char * fmt, ...)
{
va_list Param;
char Buf[200];
va_start(Param, fmt);
vsnprintf(Buf, LENOF(Buf), fmt, Param); \
Buf[LENOF(Buf) - 1] = '\0'; \
va_end(Param);
assert(frontend != NULL);
((TSecureShell *)frontend)->PuttyFatalError(Buf);
}
//---------------------------------------------------------------------------
void __fastcall TScpExplorerForm::FixControlsPlacement()
{
TCustomScpExplorerForm::FixControlsPlacement();
TControl * ControlsOrder[] =
{ RemoteDirView, QueueSplitter, QueuePanel, BottomDock, RemoteStatusBar };
SetVerticalControlsOrder(ControlsOrder, LENOF(ControlsOrder));
TControl * RemoteControlsOrder[] =
{ RemoteDriveView, RemotePanelSplitter, RemoteDirView };
SetHorizontalControlsOrder(RemoteControlsOrder, LENOF(RemoteControlsOrder));
}
//---------------------------------------------------------------------------
unsigned int __fastcall FatalExceptionMessageDialog(Exception * E, TQueryType Type,
int SessionReopenTimeout, const UnicodeString MessageFormat, unsigned int Answers,
UnicodeString HelpKeyword, const TMessageParams * Params)
{
assert(FLAGCLEAR(Answers, qaRetry));
Answers |= qaRetry;
TQueryButtonAlias Aliases[1];
Aliases[0].Button = qaRetry;
Aliases[0].Alias = LoadStr(RECONNECT_BUTTON);
TMessageParams AParams;
if (Params != NULL)
{
AParams = *Params;
}
assert(AParams.Timeout == 0);
// the condition is de facto excess
if (SessionReopenTimeout > 0)
{
AParams.Timeout = SessionReopenTimeout;
AParams.TimeoutAnswer = qaRetry;
}
assert(AParams.Aliases == NULL);
AParams.Aliases = Aliases;
AParams.AliasesCount = LENOF(Aliases);
return ExceptionMessageDialog(E, Type, MessageFormat, Answers, HelpKeyword, &AParams);
}
//---------------------------------------------------------------------------
__fastcall TConfiguration::TConfiguration()
{
FCriticalSection = new TCriticalSection();
FUpdating = 0;
FStorage = stDetect;
FDontSave = false;
FApplicationInfo = NULL;
FUsage = new TUsage(this);
FDefaultCollectUsage = false;
wchar_t Buf[10];
UnicodeString RandomSeedPath;
if (GetEnvironmentVariable(L"APPDATA", Buf, LENOF(Buf)) > 0)
{
RandomSeedPath = L"%APPDATA%";
}
else
{
RandomSeedPath = GetShellFolderPath(CSIDL_LOCAL_APPDATA);
if (RandomSeedPath.IsEmpty())
{
RandomSeedPath = GetShellFolderPath(CSIDL_APPDATA);
}
}
FDefaultRandomSeedFile = IncludeTrailingBackslash(RandomSeedPath) + L"winscp.rnd";
}
//---------------------------------------------------------------------------
// Returns the next available word, ignoring whitespace
static const wchar_t *
NextWord(const wchar_t * Input)
{
static wchar_t buffer[1024];
static const wchar_t * text = nullptr;
wchar_t * endOfBuffer = buffer + LENOF(buffer) - 1;
wchar_t * pBuffer = buffer;
if (Input)
{
text = Input;
}
if (text)
{
/* add leading spaces */
while (iswspace(*text))
{
*(pBuffer++) = *(text++);
}
/* copy the word to our static buffer */
while (*text && !iswspace(*text) && pBuffer < endOfBuffer)
{
*(pBuffer++) = *(text++);
}
}
*pBuffer = 0;
return buffer;
}
//---------------------------------------------------------------------------
TConfiguration::TConfiguration() :
FCriticalSection(nullptr),
FDontSave(false),
FChanged(false),
FUpdating(0),
FApplicationInfo(nullptr),
FLogging(false),
FPermanentLogging(false),
FLogWindowLines(0),
FLogFileAppend(false),
FLogProtocol(0),
FActualLogProtocol(0),
FLogActions(false),
FPermanentLogActions(false),
FConfirmOverwriting(false),
FConfirmResume(false),
FAutoReadDirectoryAfterOp(false),
FSessionReopenAuto(0),
FSessionReopenBackground(0),
FSessionReopenTimeout(0),
FSessionReopenAutoStall(0),
FProgramIniPathWrittable(0),
FTunnelLocalPortNumberLow(0),
FTunnelLocalPortNumberHigh(0),
FCacheDirectoryChangesMaxSize(0),
FShowFtpWelcomeMessage(false),
FTryFtpWhenSshFails(false),
FDisablePasswordStoring(false),
FForceBanners(false),
FDisableAcceptingHostKeys(false),
FDefaultCollectUsage(false),
FSessionReopenAutoMaximumNumberOfRetries(0)
{
FCriticalSection = new TCriticalSection();
FUpdating = 0;
FStorage = stRegistry;
FDontSave = false;
FApplicationInfo = nullptr;
// FUsage = new TUsage(this);
// FDefaultCollectUsage = false;
wchar_t Buf[10];
UnicodeString RandomSeedPath;
if (GetEnvironmentVariable(L"APPDATA", Buf, LENOF(Buf)) > 0)
{
RandomSeedPath = L"%APPDATA%";
}
else
{
RandomSeedPath = GetShellFolderPath(CSIDL_LOCAL_APPDATA);
if (RandomSeedPath.IsEmpty())
{
RandomSeedPath = GetShellFolderPath(CSIDL_APPDATA);
}
}
FDefaultRandomSeedFile = IncludeTrailingBackslash(RandomSeedPath) + L"winscp.rnd";
}
//---------------------------------------------------------------------------
void __fastcall PuttyInitialize()
{
SaveRandomSeed = true;
InitializeCriticalSection(&putty_section);
// make sure random generator is initialised, so random_save_seed()
// in destructor can proceed
random_ref();
flags = FLAG_VERBOSE | FLAG_SYNCAGENT; // verbose log
sk_init();
AnsiString VersionString = SshVersionString();
assert(!VersionString.IsEmpty() && (static_cast<size_t>(VersionString.Length()) < LENOF(sshver)));
strcpy(sshver, VersionString.c_str());
AnsiString AppName = AppNameString();
assert(!AppName.IsEmpty() && (static_cast<size_t>(AppName.Length()) < LENOF(appname_)));
strcpy(appname_, AppName.c_str());
}
//---------------------------------------------------------------------------
void TSessionLog::DoAddStartupInfo(TSessionData * Data)
{
TGuard Guard(FCriticalSection);
BeginUpdate();
auto cleanup = finally([&]()
{
DeleteUnnecessary();
EndUpdate();
});
{
#define ADF(S, ...) DoAdd(llMessage, FORMAT(S, ##__VA_ARGS__), MAKE_CALLBACK(TSessionLog::DoAddToSelf, this));
if (Data == nullptr)
{
AddSeparator();
ADF(L"NetBox %s (OS %s)", FConfiguration->GetVersionStr().c_str(), FConfiguration->GetOSVersionStr().c_str());
std::auto_ptr<THierarchicalStorage> Storage(FConfiguration->CreateStorage(false));
assert(Storage.get());
ADF(L"Configuration: %s", Storage->GetSource().c_str());
if (0)
{
typedef BOOL (WINAPI * TGetUserNameEx)(EXTENDED_NAME_FORMAT NameFormat, LPWSTR lpNameBuffer, PULONG nSize);
HINSTANCE Secur32 = LoadLibrary(L"secur32.dll");
TGetUserNameEx GetUserNameEx =
(Secur32 != nullptr) ? reinterpret_cast<TGetUserNameEx>(GetProcAddress(Secur32, "GetUserNameExW")) : nullptr;
wchar_t UserName[UNLEN + 1];
unsigned long UserNameSize = LENOF(UserName);
if ((GetUserNameEx == nullptr) || !GetUserNameEx(NameSamCompatible, (LPWSTR)UserName, &UserNameSize))
{
wcscpy(UserName, L"<Failed to retrieve username>");
}
ADF(L"Local account: %s", UserName);
}
unsigned short Y, M, D, H, N, S, MS;
TDateTime DateTime = Now();
DateTime.DecodeDate(Y, M, D);
DateTime.DecodeTime(H, N, S, MS);
UnicodeString dt = FORMAT(L"%02d.%02d.%04d %02d:%02d:%02d", D, M, Y, H, N, S);
// ADF(L"Login time: %s", FormatDateTime(L"dddddd tt", Now()).c_str());
ADF(L"Working directory: %s", GetCurrentDir().c_str());
// ADF(L"Command-line: %s", CmdLine.c_str());
// ADF(L"Time zone: %s", GetTimeZoneLogString().c_str());
ADF(L"Login time: %s", dt.c_str());
AddSeparator();
}
else
{
if (0)
{
ADF(L"Session name: %s (%s)", Data->GetSessionName().c_str(), Data->GetSource().c_str());
}
ADF(L"Host name: %s (Port: %d)", Data->GetHostNameExpanded().c_str(), Data->GetPortNumber());
if (0)
{
ADF(L"User name: %s (Password: %s, Key file: %s)",
Data->GetUserNameExpanded().c_str(), BooleanToEngStr(!Data->GetPassword().IsEmpty()).c_str(),
BooleanToEngStr(!Data->GetPublicKeyFile().IsEmpty()).c_str())
}
ADF(L"Tunnel: %s", BooleanToEngStr(Data->GetTunnel()).c_str());
if (Data->GetTunnel())
{
ADF(L"Tunnel: Host name: %s (Port: %d)", Data->GetTunnelHostName().c_str(), Data->GetTunnelPortNumber());
if (0)
{
ADF(L"Tunnel: User name: %s (Password: %s, Key file: %s)",
Data->GetTunnelUserName().c_str(), BooleanToEngStr(!Data->GetTunnelPassword().IsEmpty()).c_str(),
BooleanToEngStr(!Data->GetTunnelPublicKeyFile().IsEmpty()).c_str());
ADF(L"Tunnel: Local port number: %d", Data->GetTunnelLocalPortNumber());
}
}
ADF(L"Transfer Protocol: %s", Data->GetFSProtocolStr().c_str());
ADF(L"Code Page: %d", Data->GetCodePageAsNumber());
wchar_t * PingTypes = L"-NC";
TPingType PingType;
intptr_t PingInterval;
if (Data->GetFSProtocol() == fsFTP)
{
PingType = Data->GetFtpPingType();
PingInterval = Data->GetFtpPingInterval();
}
else
{
PingType = Data->GetPingType();
PingInterval = Data->GetPingInterval();
}
ADF(L"Ping type: %s, Ping interval: %d sec; Timeout: %d sec",
UnicodeString(PingTypes[PingType]).c_str(), PingInterval, Data->GetTimeout());
ADF(L"Proxy: %s%s", ProxyMethodList[Data->GetProxyMethod()],
Data->GetProxyMethod() == pmSystem ?
::Format(L" (%s)", ProxyMethodList[Data->GetActualProxyMethod()]).c_str() :
L"")
if (Data->GetProxyMethod() != ::pmNone)
{
ADF(L"HostName: %s (Port: %d); Username: %s; Passwd: %s",
Data->GetProxyHost().c_str(), Data->GetProxyPort(),
Data->GetProxyUsername().c_str(), BooleanToEngStr(!Data->GetProxyPassword().IsEmpty()).c_str());
if (Data->GetProxyMethod() == pmTelnet)
{
ADF(L"Telnet command: %s", Data->GetProxyTelnetCommand().c_str());
}
if (Data->GetProxyMethod() == pmCmd)
{
ADF(L"Local command: %s", Data->GetProxyLocalCommand().c_str());
}
}
wchar_t const * BugFlags = L"+-A";
if (Data->GetUsesSsh())
{
ADF(L"SSH protocol version: %s; Compression: %s",
Data->GetSshProtStr().c_str(), BooleanToEngStr(Data->GetCompression()).c_str());
ADF(L"Bypass authentication: %s",
BooleanToEngStr(Data->GetSshNoUserAuth()).c_str());
ADF(L"Try agent: %s; Agent forwarding: %s; TIS/CryptoCard: %s; KI: %s; GSSAPI: %s",
BooleanToEngStr(Data->GetTryAgent()).c_str(), BooleanToEngStr(Data->GetAgentFwd()).c_str(), BooleanToEngStr(Data->GetAuthTIS()).c_str(),
BooleanToEngStr(Data->GetAuthKI()).c_str(), BooleanToEngStr(Data->GetAuthGSSAPI()).c_str());
if (Data->GetAuthGSSAPI())
{
ADF(L"GSSAPI: Forwarding: %s; Server realm: %s",
BooleanToEngStr(Data->GetGSSAPIFwdTGT()).c_str(), Data->GetGSSAPIServerRealm().c_str());
}
ADF(L"Ciphers: %s; Ssh2DES: %s",
Data->GetCipherList().c_str(), BooleanToEngStr(Data->GetSsh2DES()).c_str());
UnicodeString Bugs;
for (intptr_t Index = 0; Index < BUG_COUNT; ++Index)
{
Bugs += UnicodeString(BugFlags[Data->GetBug(static_cast<TSshBug>(Index))])+(Index<BUG_COUNT-1?L",":L"");
}
ADF(L"SSH Bugs: %s", Bugs.c_str());
ADF(L"Return code variable: %s; Lookup user groups: %c",
Data->GetDetectReturnVar() ? UnicodeString(L"Autodetect").c_str() : Data->GetReturnVar().c_str(),
BugFlags[Data->GetLookupUserGroups()]);
ADF(L"Shell: %s", Data->GetShell().IsEmpty() ? UnicodeString(L"default").c_str() : Data->GetShell().c_str());
ADF(L"EOL: %d, UTF: %d", Data->GetEOLType(), Data->GetNotUtf());
ADF(L"Clear aliases: %s, Unset nat.vars: %s, Resolve symlinks: %s",
BooleanToEngStr(Data->GetClearAliases()).c_str(), BooleanToEngStr(Data->GetUnsetNationalVars()).c_str(),
BooleanToEngStr(Data->GetResolveSymlinks()).c_str());
ADF(L"LS: %s, Ign LS warn: %s, Scp1 Comp: %s",
Data->GetListingCommand().c_str(),
BooleanToEngStr(Data->GetIgnoreLsWarnings()).c_str(),
BooleanToEngStr(Data->GetScp1Compatibility()).c_str());
}
if (Data->GetFSProtocol() == fsSFTP)
{
UnicodeString Bugs;
for (int Index = 0; Index < SFTP_BUG_COUNT; Index++)
{
Bugs += UnicodeString(BugFlags[Data->GetSFTPBug(static_cast<TSftpBug>(Index))])+(Index<SFTP_BUG_COUNT-1 ? L"," : L"");
}
ADF(L"SFTP Bugs: %s", Bugs.c_str());
ADF(L"SFTP Server: %s", Data->GetSftpServer().IsEmpty()? UnicodeString(L"default").c_str() : Data->GetSftpServer().c_str());
}
if (Data->GetFSProtocol() == fsFTP)
{
UnicodeString Ftps;
switch (Data->GetFtps())
{
case ftpsImplicit:
Ftps = L"Implicit TLS/SSL";
break;
case ftpsExplicitSsl:
Ftps = L"Explicit SSL";
break;
case ftpsExplicitTls:
Ftps = L"Explicit TLS";
break;
default:
assert(Data->GetFtps() == ftpsNone);
Ftps = L"None";
break;
}
ADF(L"FTP: FTPS: %s; Passive: %s [Force IP: %c]; MLSD: %c [List all: %c]",
Ftps.c_str(), BooleanToEngStr(Data->GetFtpPasvMode()).c_str(),
BugFlags[Data->GetFtpForcePasvIp()],
BugFlags[Data->GetFtpUseMlsd()],
BugFlags[Data->GetFtpListAll()]);
if (Data->GetFtps() != ftpsNone)
{
ADF(L"Session reuse: %s", BooleanToEngStr(Data->GetSslSessionReuse()).c_str());
ADF(L"TLS/SSL versions: %s-%s", GetTlsVersionName(Data->GetMinTlsVersion()).c_str(), GetTlsVersionName(Data->GetMaxTlsVersion()).c_str());
}
}
ADF(L"Local directory: %s, Remote directory: %s, Update: %s, Cache: %s",
(Data->GetLocalDirectory().IsEmpty() ? UnicodeString(L"default").c_str() : Data->GetLocalDirectory().c_str()),
(Data->GetRemoteDirectory().IsEmpty() ? UnicodeString(L"home").c_str() : Data->GetRemoteDirectory().c_str()),
BooleanToEngStr(Data->GetUpdateDirectories()).c_str(),
BooleanToEngStr(Data->GetCacheDirectories()).c_str());
ADF(L"Cache directory changes: %s, Permanent: %s",
BooleanToEngStr(Data->GetCacheDirectoryChanges()).c_str(),
BooleanToEngStr(Data->GetPreserveDirectoryChanges()).c_str());
intptr_t TimeDifferenceMin = TimeToMinutes(Data->GetTimeDifference());
ADF(L"DST mode: %d; Timezone offset: %dh %dm", static_cast<int>(Data->GetDSTMode()), (TimeDifferenceMin / MinsPerHour), (TimeDifferenceMin % MinsPerHour));
if (Data->GetFSProtocol() == fsWebDAV)
{
ADF(L"Compression: %s",
BooleanToEngStr(Data->GetCompression()).c_str());
}
AddSeparator();
}
#undef ADF
}
}
/**
* Node: if you add any extra headers here, make sure they don't overflow
* XMLRPC_IOVEC_MAX_SIZE
*/
static void xmlrpc_init_send_buf(void)
{
/*First Line: POST /... HTTP... */
xmlrpc_first_line_index = xmlrpc_iov_len++;
/* host */
xmlrpc_host_index = xmlrpc_iov_len++;
xmlrpc_iov[xmlrpc_iov_len].iov_base = XMLRPC_HTTP_HEADER;
xmlrpc_iov[xmlrpc_iov_len].iov_len = LENOF(XMLRPC_HTTP_HEADER);
xmlrpc_iov_len++;
/* content length */
xmlrpc_ct_len_index = xmlrpc_iov_len++;
/* delimiter */
xmlrpc_iov[xmlrpc_iov_len].iov_base = "\r\n\r\n";
xmlrpc_iov[xmlrpc_iov_len].iov_len = 4;
xmlrpc_iov_len++;
/* here goes xml payload */
/* XML version */
xmlrpc_iov[xmlrpc_iov_len].iov_base = XMLRPC_BODY_CONST;
xmlrpc_iov[xmlrpc_iov_len].iov_len = LENOF(XMLRPC_BODY_CONST);
xmlrpc_xmlbody_index = xmlrpc_iov_len++;
/* <methodCall> */
xmlrpc_iov[xmlrpc_iov_len].iov_base = START_TAG(XMLRPC_METHOD_CALL);
xmlrpc_iov[xmlrpc_iov_len].iov_len = LENOF(START_TAG(XMLRPC_METHOD_CALL));
xmlrpc_iov_len++;
/* <methodName> */
xmlrpc_iov[xmlrpc_iov_len].iov_base = START_TAG(XMLRPC_METHOD_NAME);
xmlrpc_iov[xmlrpc_iov_len].iov_len = LENOF(START_TAG(XMLRPC_METHOD_NAME))-1;
xmlrpc_iov_len++;
/* method name */
xmlrpc_met_name_index = xmlrpc_iov_len++;
/* </methodName> */
xmlrpc_iov[xmlrpc_iov_len].iov_base = END_TAG(XMLRPC_METHOD_NAME);
xmlrpc_iov[xmlrpc_iov_len].iov_len = LENOF(END_TAG(XMLRPC_METHOD_NAME));
xmlrpc_iov_len++;
/* <params> */
xmlrpc_iov[xmlrpc_iov_len].iov_base = START_TAG(XMLRPC_PARAMS);
xmlrpc_iov[xmlrpc_iov_len].iov_len = LENOF(START_TAG(XMLRPC_PARAMS));
xmlrpc_iov_len++;
/* event name parameter */
/* <param> */
xmlrpc_iov[xmlrpc_iov_len].iov_base = START_TAG(XMLRPC_PARAM);
xmlrpc_iov[xmlrpc_iov_len].iov_len = LENOF(START_TAG(XMLRPC_PARAM));
xmlrpc_iov_len++;
/* <value> */
xmlrpc_iov[xmlrpc_iov_len].iov_base = START_TAG(XMLRPC_VALUE);
xmlrpc_iov[xmlrpc_iov_len].iov_len = LENOF(START_TAG(XMLRPC_VALUE))-1;
xmlrpc_iov_len++;
/* <string> */
xmlrpc_iov[xmlrpc_iov_len].iov_base = START_TAG(XMLRPC_STRING);
xmlrpc_iov[xmlrpc_iov_len].iov_len = LENOF(START_TAG(XMLRPC_STRING))-1;
xmlrpc_iov_len++;
/* events name */
xmlrpc_ev_name_index = xmlrpc_iov_len++;
/* </string> */
xmlrpc_iov[xmlrpc_iov_len].iov_base = END_TAG(XMLRPC_STRING);
xmlrpc_iov[xmlrpc_iov_len].iov_len = LENOF(END_TAG(XMLRPC_STRING))-1;
xmlrpc_iov_len++;
/* </value> */
xmlrpc_iov[xmlrpc_iov_len].iov_base = END_TAG(XMLRPC_VALUE);
xmlrpc_iov[xmlrpc_iov_len].iov_len = LENOF(END_TAG(XMLRPC_VALUE));
xmlrpc_iov_len++;
/* </param> */
xmlrpc_iov[xmlrpc_iov_len].iov_base = END_TAG(XMLRPC_PARAM);
xmlrpc_iov[xmlrpc_iov_len].iov_len = LENOF(END_TAG(XMLRPC_PARAM));
xmlrpc_iov_len++;
/* parameters */
xmlrpc_params_index = xmlrpc_iov_len++;
/* </params> */
xmlrpc_iov[xmlrpc_iov_len].iov_base = END_TAG(XMLRPC_PARAMS);
xmlrpc_iov[xmlrpc_iov_len].iov_len = LENOF(END_TAG(XMLRPC_PARAMS));
xmlrpc_iov_len++;
/* </methodCall> */
xmlrpc_iov[xmlrpc_iov_len].iov_base = END_TAG(XMLRPC_METHOD_CALL);
xmlrpc_iov[xmlrpc_iov_len].iov_len = LENOF(END_TAG(XMLRPC_METHOD_CALL))-1;
xmlrpc_iov_len++;
}
/* function to build XMLRPC buffer */
int xmlrpc_build_buffer(str *event_name, evi_reply_sock *sock,
evi_params_t *params, xmlrpc_send_t ** msg)
{
int len, b_len;
char *b, *p;
evi_param_p param;
if (params && (params->flags & XMLRPC_FLAG)) {
LM_DBG("buffer already built\n");
return 0;
}
b_len = XMLRPC_DEFAULT_BUFFER_SIZE;
b = xmlrpc_body_buf;
#define COPY_STR(_s, _l) \
do { \
if ( (_l) > b_len ) { \
LM_ERR("buffer too small...\n");\
return -1; \
} \
memcpy( b, (_s), (_l) ); \
b_len -= (_l); \
b += (_l); \
} while (0)
if (params) {
for (param = params->first; param; param = param->next) {
/* '<param>' */
COPY_STR(START_TAG(XMLRPC_PARAM), LENOF(START_TAG(XMLRPC_PARAM)));
if (param->name.len && param->name.s) {
if (xmlrpc_struct_on) {
COPY_STR(START_TAG(XMLRPC_VALUE),
LENOF(START_TAG(XMLRPC_VALUE)) - 1);
COPY_STR(START_TAG(XMLRPC_STRUCT),
LENOF(START_TAG(XMLRPC_STRUCT)) - 1);
COPY_STR(START_TAG(XMLRPC_MEMBER),
LENOF(START_TAG(XMLRPC_MEMBER)));
}
LM_DBG("adding parameter %.*s\n",
param->name.len, param->name.s);
/* <name> */
COPY_STR(START_TAG(XMLRPC_ATTR),
LENOF(START_TAG(XMLRPC_ATTR)) - 1);
/* parameter name */
COPY_STR(param->name.s, param->name.len);
/* </name> */
COPY_STR(END_TAG(XMLRPC_ATTR),
LENOF(END_TAG(XMLRPC_ATTR)));
}
/* <value> */
COPY_STR(START_TAG(XMLRPC_VALUE),
LENOF(START_TAG(XMLRPC_VALUE)) - 1);
if (param->flags & EVI_INT_VAL) {
/* <int> */
COPY_STR(START_TAG(XMLRPC_INT),
LENOF(START_TAG(XMLRPC_INT)) - 1);
/* convert int */
p = int2str(param->val.n, &len);
if (!p) {
LM_ERR("cannot convert int parameter\n");
return -1;
}
/* integer parameter */
COPY_STR(p, len);
/* </int> */
COPY_STR(END_TAG(XMLRPC_INT),
LENOF(END_TAG(XMLRPC_INT)) - 1);
} else {
/* <string> */
COPY_STR(START_TAG(XMLRPC_STRING),
LENOF(START_TAG(XMLRPC_STRING)) - 1);
/* string parameter */
COPY_STR(param->val.s.s, param->val.s.len);
/* </string> */
COPY_STR(END_TAG(XMLRPC_STRING),
LENOF(END_TAG(XMLRPC_STRING)) - 1);
}
COPY_STR(END_TAG(XMLRPC_VALUE),
LENOF(END_TAG(XMLRPC_VALUE)));
if (param->name.len && param->name.s &&
xmlrpc_struct_on) {
COPY_STR(END_TAG(XMLRPC_MEMBER),
LENOF(END_TAG(XMLRPC_MEMBER)) - 1);
COPY_STR(END_TAG(XMLRPC_STRUCT),
LENOF(END_TAG(XMLRPC_STRUCT)) - 1);
COPY_STR(END_TAG(XMLRPC_VALUE),
LENOF(END_TAG(XMLRPC_VALUE)));
}
COPY_STR(END_TAG(XMLRPC_PARAM),
LENOF(END_TAG(XMLRPC_PARAM)));
}
}
#undef COPY_STR
len = XMLRPC_DEFAULT_BUFFER_SIZE - b_len;
*msg = xmlrpc_build_send_t(sock, xmlrpc_body_buf, len, event_name);
if (!*msg) {
LM_ERR("cannot build send msg\n");
return -1;
}
if (params)
params->flags |= XMLRPC_FLAG;
return 0;
}
//---------------------------------------------------------------------------
TStrings * __fastcall TGUIConfiguration::GetLocales()
{
UnicodeString LocalesExts;
TStringList * Exts = new TStringList();
try
{
Exts->Sorted = true;
Exts->CaseSensitive = false;
int FindAttrs = faReadOnly | faArchive;
TSearchRec SearchRec;
bool Found;
Found = (bool)(FindFirst(ChangeFileExt(ModuleFileName(), L".*"),
FindAttrs, SearchRec) == 0);
try
{
UnicodeString Ext;
while (Found)
{
Ext = ExtractFileExt(SearchRec.Name).UpperCase();
if ((Ext.Length() >= 3) && (Ext != L".EXE") && (Ext != L".COM") &&
(Ext != L".DLL") && (Ext != L".INI"))
{
Ext = Ext.SubString(2, Ext.Length() - 1);
LocalesExts += Ext;
Exts->Add(Ext);
}
Found = (FindNextChecked(SearchRec) == 0);
}
}
__finally
{
FindClose(SearchRec);
}
if (FLastLocalesExts != LocalesExts)
{
FLastLocalesExts = LocalesExts;
FLocales->Clear();
TLanguages * Langs = Languages();
int Ext, Index, Count;
wchar_t LocaleStr[255];
LCID Locale;
Count = Langs->Count;
Index = -1;
while (Index < Count)
{
if (Index >= 0)
{
Locale = Langs->LocaleID[Index];
Ext = Exts->IndexOf(Langs->Ext[Index]);
if (Ext < 0)
{
Ext = Exts->IndexOf(Langs->Ext[Index].SubString(1, 2));
if (Ext >= 0)
{
Locale = MAKELANGID(PRIMARYLANGID(Locale), SUBLANG_DEFAULT);
}
}
if (Ext >= 0)
{
Exts->Objects[Ext] = reinterpret_cast<TObject*>(Locale);
}
else
{
Locale = 0;
}
}
else
{
Locale = InternalLocale();
}
if (Locale)
{
UnicodeString Name;
GetLocaleInfo(Locale, LOCALE_SENGLANGUAGE,
LocaleStr, LENOF(LocaleStr));
Name = LocaleStr;
Name += L" - ";
// LOCALE_SNATIVELANGNAME
GetLocaleInfo(Locale, LOCALE_SLANGUAGE,
LocaleStr, LENOF(LocaleStr));
Name += LocaleStr;
FLocales->AddObject(Name, reinterpret_cast<TObject*>(Locale));
}
Index++;
}
for (int Index = 0; Index < Exts->Count; Index++)
{
if ((Exts->Objects[Index] == NULL) &&
(Exts->Strings[Index].Length() == 3) &&
SameText(Exts->Strings[Index].SubString(1, 2), AdditionaLanguagePrefix))
{
UnicodeString LangName = GetFileFileInfoString(L"LangName",
ChangeFileExt(ModuleFileName(), UnicodeString(L".") + Exts->Strings[Index]));
if (!LangName.IsEmpty())
{
FLocales->AddObject(LangName, reinterpret_cast<TObject*>(
AdditionaLanguageMask + Exts->Strings[Index][3]));
}
}
}
}
}
__finally
{
delete Exts;
}
return FLocales;
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
HINSTANCE __fastcall TGUIConfiguration::LoadNewResourceModule(LCID ALocale,
UnicodeString * FileName)
{
UnicodeString LibraryFileName;
HINSTANCE NewInstance = 0;
bool Internal = (ALocale == InternalLocale());
if (!Internal)
{
UnicodeString Module;
UnicodeString LocaleName;
Module = ModuleFileName();
if ((ALocale & AdditionaLanguageMask) != AdditionaLanguageMask)
{
wchar_t LocaleStr[4];
GetLocaleInfo(ALocale, LOCALE_SABBREVLANGNAME, LocaleStr, LENOF(LocaleStr));
LocaleName = LocaleStr;
assert(!LocaleName.IsEmpty());
}
else
{
LocaleName = AdditionaLanguagePrefix +
char(ALocale & ~AdditionaLanguageMask);
}
Module = ChangeFileExt(Module, UnicodeString(L".") + LocaleName);
// Look for a potential language/country translation
NewInstance = LoadLibraryEx(Module.c_str(), 0, LOAD_LIBRARY_AS_DATAFILE);
if (!NewInstance)
{
// Finally look for a language only translation
Module.SetLength(Module.Length() - 1);
NewInstance = LoadLibraryEx(Module.c_str(), 0, LOAD_LIBRARY_AS_DATAFILE);
if (NewInstance)
{
LibraryFileName = Module;
}
}
else
{
LibraryFileName = Module;
}
}
if (!NewInstance && !Internal)
{
throw Exception(FMTLOAD(LOCALE_LOAD_ERROR, (int(ALocale))));
}
else
{
if (Internal)
{
NewInstance = HInstance;
}
}
if (FileName != NULL)
{
*FileName = LibraryFileName;
}
return NewInstance;
}
//---------------------------------------------------------------------------
void __fastcall TQueueController::FillQueueViewItem(TListItem * Item,
TQueueItemProxy * QueueItem, bool Detail)
{
DebugAssert(!Detail || (QueueItem->Status != TQueueItem::qsPending));
DebugAssert((Item->Data == NULL) || (Item->Data == QueueItem));
Item->Data = QueueItem;
UnicodeString ProgressStr;
int Image = -1;
switch (QueueItem->Status)
{
case TQueueItem::qsDone:
ProgressStr = LoadStr(QUEUE_DONE);
break;
case TQueueItem::qsPending:
ProgressStr = LoadStr(QUEUE_PENDING);
break;
case TQueueItem::qsConnecting:
ProgressStr = LoadStr(QUEUE_CONNECTING);
break;
case TQueueItem::qsQuery:
ProgressStr = LoadStr(QUEUE_QUERY);
Image = 4;
break;
case TQueueItem::qsError:
ProgressStr = LoadStr(QUEUE_ERROR);
Image = 5;
break;
case TQueueItem::qsPrompt:
ProgressStr = LoadStr(QUEUE_PROMPT);
Image = 6;
break;
case TQueueItem::qsPaused:
ProgressStr = LoadStr(QUEUE_PAUSED);
Image = 7;
break;
}
bool BlinkHide = QueueItemNeedsFrequentRefresh(QueueItem) &&
!QueueItem->ProcessingUserAction &&
((GetTickCount() % MSecsPerSec) >= (MSecsPerSec/2));
int State = -1;
UnicodeString Values[6];
TFileOperationProgressType * ProgressData = QueueItem->ProgressData;
TQueueItem::TInfo * Info = QueueItem->Info;
if (!Detail)
{
switch (Info->Operation)
{
case foCopy:
State = ((Info->Side == osLocal) ? 2 : 0);
break;
case foMove:
State = ((Info->Side == osLocal) ? 3 : 1);
break;
}
// cannot use ProgressData->Temp as it is set only after the transfer actually starts
Values[0] = Info->Source.IsEmpty() ? LoadStr(PROGRESS_TEMP_DIR) : Info->Source;
Values[1] = Info->Destination.IsEmpty() ? LoadStr(PROGRESS_TEMP_DIR) : Info->Destination;
__int64 TotalTransferred = QueueItem->TotalTransferred;
if (TotalTransferred >= 0)
{
Values[2] =
FormatPanelBytes(TotalTransferred, WinConfiguration->FormatSizeBytes);
}
if (ProgressData != NULL)
{
if (ProgressData->Operation == Info->Operation)
{
if (QueueItem->Status != TQueueItem::qsDone)
{
if (ProgressData->TotalSizeSet)
{
Values[3] = FormatDateTimeSpan(Configuration->TimeFormat, ProgressData->TotalTimeLeft());
}
else
{
Values[3] = FormatDateTimeSpan(Configuration->TimeFormat, ProgressData->TimeElapsed());
}
Values[4] = FORMAT(L"%s/s", (FormatBytes(ProgressData->CPS())));
}
if (ProgressStr.IsEmpty())
{
ProgressStr = FORMAT(L"%d%%", (ProgressData->OverallProgress()));
}
}
else if (ProgressData->Operation == foCalculateSize)
{
ProgressStr = LoadStr(QUEUE_CALCULATING_SIZE);
}
}
Values[5] = ProgressStr;
}
else
{
Image = -1;
if (ProgressData != NULL)
{
if ((Info->Side == osRemote) || !ProgressData->Temp)
{
Values[0] = ProgressData->FileName;
}
else
{
Values[0] = ExtractFileName(ProgressData->FileName);
}
if (ProgressData->Operation == Info->Operation)
{
Values[2] =
FormatPanelBytes(ProgressData->TransferedSize, WinConfiguration->FormatSizeBytes);
Values[5] = FORMAT(L"%d%%", (ProgressData->TransferProgress()));
}
}
else
{
Values[0] = ProgressStr;
}
}
Item->StateIndex = (!BlinkHide ? State : -1);
Item->ImageIndex = (!BlinkHide ? Image : -1);
for (size_t Index = 0; Index < LENOF(Values); Index++)
{
if (Index < static_cast<size_t>(Item->SubItems->Count))
{
Item->SubItems->Strings[Index] = Values[Index];
}
else
{
Item->SubItems->Add(Values[Index]);
}
}
}
/*
* This is the parsing function
* The socket grammar should be:
* ip ':' port '/optional/path' ':' method
*/
static evi_reply_sock* xmlrpc_parse(str socket)
{
evi_reply_sock *sock = NULL;
unsigned short port = 0;
char *p = NULL;
str host, path=str_init(NULL);
struct hostent *hentity;
int len;
struct xmlrpc_sock_param *params;
int http_buf_len=0;
if (!socket.len || !socket.s) {
LM_ERR("no socket specified\n");
return NULL;
}
if (!(params=shm_malloc(sizeof(struct xmlrpc_sock_param)))) {
LM_ERR("no more pkg mem!\n");
return NULL;
}
memset(params, 0, sizeof(struct xmlrpc_sock_param));
/* extract host */
host.s = socket.s;
p = memchr(socket.s, COLON_C, socket.len);
if (!p || p == socket.s) {
LM_ERR("port not specified <%.*s>\n", socket.len, socket.s);
return NULL;
}
host.len = p - socket.s;
/* used to resolve host */
*p = '\0';
/* skip colon */
socket.s += host.len + 1;
socket.len -= host.len + 1;
LM_DBG("host is %.*s - remains <%.*s>[%d]\n", host.len, host.s,
socket.len, socket.s, socket.len);
if (!socket.len || *socket.s == '\0') {
LM_ERR("invalid port number\n");
return NULL;
}
p = memchr(socket.s, COLON_C, socket.len);
if (!p || p == socket.s) {
LM_ERR("method not specified <%.*s>\n", socket.len, socket.s);
return NULL;
}
port = str2s(socket.s, p - socket.s, 0);
if (port == 0) {
/* most probably we've got path */
if ((path.s=(q_memchr(socket.s, SLASH_C, p-socket.s)))==NULL) {
LM_ERR("malformed port: %.*s\n",(int)(p - socket.s), socket.s);
return NULL;
} else {
port=str2s(socket.s, path.s-socket.s, 0);
if (port == 0) {
LM_ERR("malformed port: %.*s\n",(int)(p - socket.s), socket.s);
return NULL;
}
path.len = p - path.s;
socket.len -= ((path.s+path.len)-socket.s);
socket.s = path.s+path.len;
}
/* will use this later for allocation */
http_buf_len=LENOF(XMLRPC_HTTP_METHOD) + path.len +
LENOF(XMLRPC_HTTP_PROTO_HOST);
}
/* jump over ':' */
socket.len = socket.len - (p - socket.s + 1);
socket.s = p + 1;
LM_DBG("port is %hu - remains <%.*s>[%d]\n",
port, socket.len, socket.s, socket.len);
if (socket.len <= 0 || *socket.s == '\0') {
LM_ERR("invalid method name\n");
return NULL;
}
len = sizeof(evi_reply_sock) + host.len
+ sizeof(struct xmlrpc_sock_param)
+ socket.len /* this is method */+ http_buf_len;
sock = shm_malloc(len);
if (!sock) {
LM_ERR("no more memory for socket\n");
return NULL;
}
memset(sock, 0, len);
/* only UDP has port */
sock->flags = EVI_PORT;
sock->port = port;
/* also build sockaddr */
hentity = resolvehost(host.s, 0);
if (!hentity) {
LM_ERR("cannot resolve host %s\n", host.s);
goto error;
}
if(hostent2su(&sock->src_addr.udp_addr, hentity, 0, port)){
LM_ERR("failed to resolve %s\n", host.s);
goto error;
}
sock->flags |= EVI_SOCKET;
/* address */
sock->address.s = (char*)(sock+1);
sock->address.len = host.len;
memcpy(sock->address.s, host.s, host.len);
sock->flags |= EVI_ADDRESS;
/* copy parameters: path and method */
params = (struct xmlrpc_sock_param*)(sock->address.s + host.len);
params->method.s = (char*)(params+1);
memcpy(params->method.s, socket.s, socket.len);
params->method.len = socket.len;
if (http_buf_len) {
/* build only once; not for every message */
params->first_line.s = (char*)(params->method.s+socket.len);
memcpy(params->method.s, socket.s, socket.len);
params->first_line.len = 0;
memcpy(params->first_line.s,
XMLRPC_HTTP_METHOD, LENOF(XMLRPC_HTTP_METHOD));
params->first_line.len = LENOF(XMLRPC_HTTP_METHOD);
memcpy(params->first_line.s+params->first_line.len, path.s, path.len);
params->first_line.len += path.len;
memcpy(params->first_line.s+params->first_line.len, XMLRPC_HTTP_PROTO_HOST,
LENOF(XMLRPC_HTTP_PROTO_HOST));
params->first_line.len += LENOF(XMLRPC_HTTP_PROTO_HOST);
} else {
params->first_line.s = XMLRPC_HTTP_CONST;
params->first_line.len = LENOF(XMLRPC_HTTP_CONST);
}
sock->flags |= EVI_PARAMS;
/* needs expire */
sock->flags |= EVI_EXPIRE|XMLRPC_FLAG;
sock->params= params;
return sock;
error:
if (sock)
shm_free(sock);
return NULL;
}
//---------------------------------------------------------------------------
bool __fastcall TFileZillaIntf::HandleMessage(WPARAM wParam, LPARAM lParam)
{
bool Result;
CString a;
unsigned int MessageID = FZ_MSG_ID(wParam);
switch (MessageID)
{
case FZ_MSG_STATUS:
{
DebugAssert(FZ_MSG_PARAM(wParam) == 0);
t_ffam_statusmessage * Status = (t_ffam_statusmessage *)lParam;
DebugAssert(Status->post);
Result = HandleStatus(Status->status, Status->type);
delete Status;
}
break;
case FZ_MSG_ASYNCREQUEST:
if (FZ_MSG_PARAM(wParam) == FZ_ASYNCREQUEST_OVERWRITE)
{
int RequestResult;
wchar_t FileName1[MAX_PATH];
COverwriteRequestData * Data = (COverwriteRequestData *)lParam;
try
{
DebugAssert(Data != NULL);
wcsncpy(FileName1, Data->FileName1, LENOF(FileName1));
FileName1[LENOF(FileName1) - 1] = L'\0';
TRemoteFileTime RemoteTime;
CopyFileTime(RemoteTime, Data->remotetime);
Result = HandleAsynchRequestOverwrite(
FileName1, LENOF(FileName1), Data->FileName2, Data->path1, Data->path2,
Data->size1, Data->size2,
(Data->localtime != NULL) ? Data->localtime->GetTime() : 0,
(Data->localtime != NULL) && ((Data->localtime->GetHour() != 0) || (Data->localtime->GetMinute() != 0)),
RemoteTime,
reinterpret_cast<void*>(Data->pTransferFile->nUserData), RequestResult);
}
catch(...)
{
FFileZillaApi->SetAsyncRequestResult(FILEEXISTS_SKIP, Data);
throw;
}
if (Result)
{
Data->FileName1 = FileName1;
Result = Check(FFileZillaApi->SetAsyncRequestResult(RequestResult, Data),
L"setasyncrequestresult");
}
}
else if (FZ_MSG_PARAM(wParam) == FZ_ASYNCREQUEST_VERIFYCERT)
{
int RequestResult;
CVerifyCertRequestData * AData = (CVerifyCertRequestData *)lParam;
try
{
DebugAssert(AData != NULL);
TFtpsCertificateData Data;
CopyContact(Data.Subject, AData->pCertData->subject);
CopyContact(Data.Issuer, AData->pCertData->issuer);
CopyValidityTime(Data.ValidFrom, AData->pCertData->validFrom);
CopyValidityTime(Data.ValidUntil, AData->pCertData->validUntil);
Data.SubjectAltName = AData->pCertData->subjectAltName;
Data.Hash = AData->pCertData->hash;
Data.Certificate = AData->pCertData->certificate;
Data.CertificateLen = AData->pCertData->certificateLen;
Data.VerificationResult = AData->pCertData->verificationResult;
Data.VerificationDepth = AData->pCertData->verificationDepth;
Result = HandleAsynchRequestVerifyCertificate(Data, RequestResult);
}
catch(...)
{
FFileZillaApi->SetAsyncRequestResult(0, AData);
throw;
}
if (Result)
{
Result = Check(FFileZillaApi->SetAsyncRequestResult(RequestResult, AData),
L"setasyncrequestresult");
}
}
else if (FZ_MSG_PARAM(wParam) == FZ_ASYNCREQUEST_NEEDPASS)
{
int RequestResult = 0;
CNeedPassRequestData * AData = (CNeedPassRequestData *)lParam;
try
{
TNeedPassRequestData Data;
Data.Password = AData->Password.GetBuffer(AData->Password.GetLength());
Result = HandleAsynchRequestNeedPass(Data, RequestResult);
AData->Password.ReleaseBuffer(AData->Password.GetLength());
if (Result && (RequestResult == TFileZillaIntf::REPLY_OK))
{
AData->Password = Data.Password;
free(Data.Password);
Data.Password = NULL;
}
}
catch(...)
{
FFileZillaApi->SetAsyncRequestResult(0, AData);
throw;
}
if (Result)
{
Result = Check(FFileZillaApi->SetAsyncRequestResult(RequestResult, AData),
L"setasyncrequestresult");
}
}
else
{
// FZ_ASYNCREQUEST_GSS_AUTHFAILED
// FZ_ASYNCREQUEST_GSS_NEEDUSER
// FZ_ASYNCREQUEST_GSS_NEEDPASS
DebugFail();
Result = false;
}
break;
case FZ_MSG_LISTDATA:
{
DebugAssert(FZ_MSG_PARAM(wParam) == 0);
t_directory * Directory = (t_directory *)lParam;
CString Path = Directory->path.GetPath();
std::vector<TListDataEntry> Entries(Directory->num);
for (int Index = 0; Index < Directory->num; Index++)
{
t_directory::t_direntry & Source = Directory->direntry[Index];
TListDataEntry & Dest = Entries[Index];
Dest.Name = Source.name;
Dest.Permissions = Source.permissionstr;
Dest.HumanPerm = Source.humanpermstr;
Dest.OwnerGroup = Source.ownergroup;
Dest.Size = Source.size;
Dest.Dir = Source.dir;
Dest.Link = Source.bLink;
CopyFileTime(Dest.Time, Source.date);
Dest.LinkTarget = Source.linkTarget;
}
int Num = Directory->num;
TListDataEntry * pEntries = Num > 0 ? &Entries[0] : NULL;
Result = HandleListData(Path, pEntries, Num);
delete Directory;
}
break;
case FZ_MSG_TRANSFERSTATUS:
{
DebugAssert(FZ_MSG_PARAM(wParam) == 0);
t_ffam_transferstatus * Status = (t_ffam_transferstatus *)lParam;
if (Status != NULL)
{
Result = HandleTransferStatus(
true, Status->transfersize, Status->bytes, Status->bFileTransfer);
delete Status;
}
else
{
Result = HandleTransferStatus(false, -1, -1, false);
}
}
break;
case FZ_MSG_REPLY:
Result = HandleReply(FZ_MSG_PARAM(wParam), lParam);
break;
case FZ_MSG_CAPABILITIES:
Result = HandleCapabilities((TFTPServerCapabilities *)lParam);
break;
default:
DebugFail();
Result = false;
break;
}
return Result;
}