public static Stream OpenRead(IOConnectionInfo ioc)
{
return(OpenReadLocal(ioc));
}
private static Stream OpenReadLocal(IOConnectionInfo ioc)
{
return(new FileStream(ioc.Path, FileMode.Open, FileAccess.Read,
FileShare.Read));
}
public void ChangeDatabase(string fileName, bool closeCurrent)
{
if (closeCurrent && host.MainWindow.DocumentManager.ActiveDatabase != null && host.MainWindow.DocumentManager.ActiveDatabase.IsOpen)
{
host.MainWindow.DocumentManager.CloseDatabase(host.MainWindow.DocumentManager.ActiveDatabase);
}
KeePassLib.Serialization.IOConnectionInfo ioci = null;
if (fileName != null && fileName.Length > 0)
{
ioci = new KeePassLib.Serialization.IOConnectionInfo();
ioci.Path = fileName;
ioci = CompleteConnectionInfoUsingMru(ioci);
}
// Set the current document / database to be the one we've been asked to display (may already be the case)
// This is because the minimise/restore trick utilised a few frames later prompts KeePass into raising an
// "enter key" dialog for the currently active database. This little check makes sure that the user sees
// the database they've asked for first (assuming the database they want is already open but locked)
// We can't stop an unneccessary prompt being seen if the user has asked for a new database to be opened
// and the current workspace is locked
//
// We do this regardless of whether the DB is already open or locked
//
//TODO: Need to verify this works OK with unusual circumstances like one DB open but others locked
if (ioci != null)
foreach (PwDocument doc in host.MainWindow.DocumentManager.Documents)
if (doc.LockedIoc.Path == fileName ||
(doc.Database.IsOpen && doc.Database.IOConnectionInfo.Path == fileName))
host.MainWindow.DocumentManager.ActiveDocument = doc;
// Going to take a new approach for a bit to see how it works out...
//
// before explicitly asking user to log into the correct DB we'll set up a "fake" document in KeePass
// in the hope that the minimise/restore trick will get KeePass to prompt the user on our behalf
// (regardless of state of existing documents and newly requested document)
if (ioci != null
&& !(host.MainWindow.DocumentManager.ActiveDocument.Database.IsOpen && host.MainWindow.DocumentManager.ActiveDocument.Database.IOConnectionInfo.Path == fileName)
&& !(!host.MainWindow.DocumentManager.ActiveDocument.Database.IsOpen && host.MainWindow.DocumentManager.ActiveDocument.LockedIoc.Path == fileName))
{
PwDocument doc = host.MainWindow.DocumentManager.CreateNewDocument(true);
//IOConnectionInfo ioci = new IOConnectionInfo();
//ioci.Path = fileName;
doc.LockedIoc = ioci;
}
// NB: going to modify implementation of the following function call so that only KeePass initiates the prompt (need to verify cross-platform, etc. even if it seems to work on win7x64)
// if it works on some platforms, I will make it work on all platforms that support it and fall back to the old clunky method for others.
host.MainWindow.BeginInvoke((MethodInvoker)delegate { promptUserToOpenDB(ioci); });
return;
}
private static IOWebClient CreateWebClient(IOConnectionInfo ioc, bool digestAuth)
{
PrepareWebAccess();
IOWebClient wc = new IOWebClient();
ConfigureWebClient(wc);
if ((ioc.UserName.Length > 0) || (ioc.Password.Length > 0))
{
//set the credentials without a cache (in case the cache below fails:
//check for backslash to determine whether we need to specify the domain:
int backslashPos = ioc.UserName.IndexOf("\\", StringComparison.Ordinal);
if (backslashPos > 0)
{
string domain = ioc.UserName.Substring(0, backslashPos);
string user = ioc.UserName.Substring(backslashPos + 1);
wc.Credentials = new NetworkCredential(user, ioc.Password, domain);
}
else
{
wc.Credentials = new NetworkCredential(ioc.UserName, ioc.Password);
}
if (digestAuth)
{
//try to use the credential cache to access with Digest support:
try
{
var credentialCache = new CredentialCache();
credentialCache.Add(
new Uri(new Uri(ioc.Path).GetLeftPart(UriPartial.Authority)),
"Digest",
new NetworkCredential(ioc.UserName, ioc.Password)
);
credentialCache.Add(
new Uri(new Uri(ioc.Path).GetLeftPart(UriPartial.Authority)),
"NTLM",
new NetworkCredential(ioc.UserName, ioc.Password)
);
wc.Credentials = credentialCache;
} catch (NotImplementedException e)
{
Kp2aLog.Log(e.ToString());
} catch (Exception e)
{
Kp2aLog.LogUnexpectedError(e);
Debug.Assert(false);
}
}
}
else if (NativeLib.IsUnix()) // Mono requires credentials
{
wc.Credentials = new NetworkCredential("anonymous", string.Empty);
}
return(wc);
}
public FileTransactionEx(IOConnectionInfo iocBaseFile) :
this(iocBaseFile, true)
{
}
public FileTransactionEx(IOConnectionInfo iocBaseFile)
{
Initialize(iocBaseFile, true);
}
public IOWebClient(IOConnectionInfo ioc) : base()
{
m_ioc = ioc;
}
private void Initialize(IOConnectionInfo iocBaseFile, bool bTransacted)
{
if (iocBaseFile == null)
{
throw new ArgumentNullException("iocBaseFile");
}
m_bTransacted = bTransacted;
m_iocBase = iocBaseFile.CloneDeep();
string strPath = m_iocBase.Path;
if (m_iocBase.IsLocalFile())
{
try
{
if (File.Exists(strPath))
{
// Symbolic links are realized via reparse points;
// https://msdn.microsoft.com/en-us/library/windows/desktop/aa365503.aspx
// https://msdn.microsoft.com/en-us/library/windows/desktop/aa365680.aspx
// https://msdn.microsoft.com/en-us/library/windows/desktop/aa365006.aspx
// Performing a file transaction on a symbolic link
// would delete/replace the symbolic link instead of
// writing to its target
FileAttributes fa = File.GetAttributes(strPath);
if ((long)(fa & FileAttributes.ReparsePoint) != 0)
{
m_bTransacted = false;
}
}
}
catch (Exception) { Debug.Assert(false); }
}
#if !KeePassUAP
// Prevent transactions for FTP URLs under .NET 4.0 in order to
// avoid/workaround .NET bug 621450:
// https://connect.microsoft.com/VisualStudio/feedback/details/621450/problem-renaming-file-on-ftp-server-using-ftpwebrequest-in-net-framework-4-0-vs2010-only
if (strPath.StartsWith("ftp:", StrUtil.CaseIgnoreCmp) &&
(Environment.Version.Major >= 4) && !NativeLib.IsUnix())
{
m_bTransacted = false;
}
#endif
foreach (KeyValuePair <string, bool> kvp in g_dEnabled)
{
if (strPath.StartsWith(kvp.Key, StrUtil.CaseIgnoreCmp))
{
m_bTransacted = kvp.Value;
break;
}
}
if (m_bTransacted)
{
m_iocTemp = m_iocBase.CloneDeep();
m_iocTemp.Path += StrTempSuffix;
}
else
{
m_iocTemp = m_iocBase;
}
}
private static void RaiseIOAccessPreEvent(IOConnectionInfo ioc, IOAccessType t)
{
RaiseIOAccessPreEvent(ioc, null, t);
}
internal static void ConfigureWebRequest(WebRequest request,
IOConnectionInfo ioc)
{
if (request == null)
{
Debug.Assert(false); return;
} // No throw
IocProperties p = ((ioc != null) ? ioc.Properties : null);
if (p == null)
{
Debug.Assert(false); p = new IocProperties();
}
IHasIocProperties ihpReq = (request as IHasIocProperties);
if (ihpReq != null)
{
IocProperties pEx = ihpReq.IOConnectionProperties;
if (pEx != null)
{
p.CopyTo(pEx);
}
else
{
ihpReq.IOConnectionProperties = p.CloneDeep();
}
}
if (IsHttpWebRequest(request))
{
// WebDAV support
#if !KeePassUAP
request.PreAuthenticate = true; // Also auth GET
#endif
if (string.Equals(request.Method, WebRequestMethods.Http.Post,
StrUtil.CaseIgnoreCmp))
{
request.Method = WebRequestMethods.Http.Put;
}
#if !KeePassUAP
HttpWebRequest hwr = (request as HttpWebRequest);
if (hwr != null)
{
string strUA = p.Get(IocKnownProperties.UserAgent);
if (!string.IsNullOrEmpty(strUA))
{
hwr.UserAgent = strUA;
}
}
else
{
Debug.Assert(false);
}
#endif
}
#if !KeePassUAP
else if (IsFtpWebRequest(request))
{
FtpWebRequest fwr = (request as FtpWebRequest);
if (fwr != null)
{
bool?obPassive = p.GetBool(IocKnownProperties.Passive);
if (obPassive.HasValue)
{
fwr.UsePassive = obPassive.Value;
}
}
else
{
Debug.Assert(false);
}
}
#endif
#if !KeePassUAP
// Not implemented and ignored in Mono < 2.10
try
{
request.CachePolicy = new RequestCachePolicy(RequestCacheLevel.NoCacheNoStore);
}
catch (NotImplementedException) { }
catch (Exception) { Debug.Assert(false); }
#endif
try
{
IWebProxy prx;
if (GetWebProxy(out prx))
{
request.Proxy = prx;
}
}
catch (Exception) { Debug.Assert(false); }
#if !KeePassUAP
long?olTimeout = p.GetLong(IocKnownProperties.Timeout);
if (olTimeout.HasValue && (olTimeout.Value >= 0))
{
request.Timeout = (int)Math.Min(olTimeout.Value, (long)int.MaxValue);
}
bool?ob = p.GetBool(IocKnownProperties.PreAuth);
if (ob.HasValue)
{
request.PreAuthenticate = ob.Value;
}
#endif
if (IOConnection.IOWebRequestPre != null)
{
IOWebRequestEventArgs e = new IOWebRequestEventArgs(request,
((ioc != null) ? ioc.CloneDeep() : null));
IOConnection.IOWebRequestPre(null, e);
}
}
/// <summary>
/// Determines whether the database pointed to by the specified ioc should be (de)serialised in default (xml) or protocol buffers format.
/// </summary>
public static KdbxFormat GetFormatToUse(IOConnectionInfo ioc)
{
// If the filename ends in .kdbp, use ProtocolBuffers format.
return(UrlUtil.GetExtension(UrlUtil.GetFileName(ioc.Path)).Equals(KdbpFile.FileNameExtension, StringComparison.OrdinalIgnoreCase) ? KdbxFormat.ProtocolBuffers : KdbxFormat.Default);
}
public UploadOnCloseMemoryStream(IOConnectionInfo _ioc, Uri _destinationFilePath)
{
this.ioc = _ioc;
this.method = null;
this.destinationFilePath = _destinationFilePath;
}
public UploadOnCloseMemoryStream(IOConnectionInfo _ioc, string _method, Uri _destinationFilePath)
{
ioc = _ioc;
this.method = _method;
this.destinationFilePath = _destinationFilePath;
}
public static Stream OpenWrite(IOConnectionInfo ioc)
{
return(OpenWriteLocal(ioc));
}
private static void PrepareWebAccess(IOConnectionInfo ioc)
{
#if !KeePassUAP && !NETSTANDARD2_0
IocProperties p = ((ioc != null) ? ioc.Properties : null);
if (p == null)
{
Debug.Assert(false); p = new IocProperties();
}
try
{
if (m_bSslCertsAcceptInvalid)
{
ServicePointManager.ServerCertificateValidationCallback =
IOConnection.AcceptCertificate;
}
else
{
ServicePointManager.ServerCertificateValidationCallback = null;
}
}
catch (Exception) { Debug.Assert(false); }
try
{
SecurityProtocolType spt = (SecurityProtocolType.Ssl3 |
SecurityProtocolType.Tls);
// The flags Tls11 and Tls12 in SecurityProtocolType have been
// introduced in .NET 4.5 and must not be set when running under
// older .NET versions (otherwise an exception is thrown)
Type tSpt = typeof(SecurityProtocolType);
string[] vSpt = Enum.GetNames(tSpt);
foreach (string strSpt in vSpt)
{
if (strSpt.Equals("Tls11", StrUtil.CaseIgnoreCmp) ||
strSpt.Equals("Tls12", StrUtil.CaseIgnoreCmp) ||
strSpt.Equals("Tls13", StrUtil.CaseIgnoreCmp))
{
spt |= (SecurityProtocolType)Enum.Parse(tSpt, strSpt, true);
}
}
ServicePointManager.SecurityProtocol = spt;
}
catch (Exception) { Debug.Assert(false); }
try
{
bool bCurCont = ServicePointManager.Expect100Continue;
if (!m_obDefaultExpect100Continue.HasValue)
{
Debug.Assert(bCurCont); // Default should be true
m_obDefaultExpect100Continue = bCurCont;
}
bool bNewCont = m_obDefaultExpect100Continue.Value;
bool?ob = p.GetBool(IocKnownProperties.Expect100Continue);
if (ob.HasValue)
{
bNewCont = ob.Value;
}
if (bNewCont != bCurCont)
{
ServicePointManager.Expect100Continue = bNewCont;
}
}
catch (Exception) { Debug.Assert(false); }
#endif
}
private static Stream OpenWriteLocal(IOConnectionInfo ioc)
{
return(new FileStream(ioc.Path, FileMode.Create, FileAccess.Write,
FileShare.None));
}
public static Stream OpenRead(IOConnectionInfo ioc)
{
RaiseIOAccessPreEvent(ioc, IOAccessType.Read);
return(OpenReadLocal(ioc));
}
/// <summary>
/// Load a KDB file from a file.
/// </summary>
/// <param name="strFilePath">File to load.</param>
/// <param name="kdbFormat">Format specifier.</param>
/// <param name="slLogger">Status logger (optional).</param>
public void Load(string strFilePath, KdbxFormat kdbFormat, IStatusLogger slLogger)
{
IOConnectionInfo ioc = IOConnectionInfo.FromPath(strFilePath);
Load(IOConnection.OpenRead(ioc), kdbFormat, slLogger);
}
public static Stream OpenWrite(IOConnectionInfo ioc)
{
RaiseIOAccessPreEvent(ioc, IOAccessType.Write);
return(OpenWriteLocal(ioc));
}
public FileTransactionEx(IOConnectionInfo iocBaseFile, bool bTransacted)
{
if (iocBaseFile == null)
{
throw new ArgumentNullException("iocBaseFile");
}
m_bTransacted = bTransacted;
m_iocBase = iocBaseFile.CloneDeep();
if (m_iocBase.IsLocalFile())
{
m_iocBase.Path = UrlUtil.GetShortestAbsolutePath(m_iocBase.Path);
}
string strPath = m_iocBase.Path;
if (m_iocBase.IsLocalFile())
{
try
{
if (File.Exists(strPath))
{
// Symbolic links are realized via reparse points;
// https://msdn.microsoft.com/en-us/library/windows/desktop/aa365503.aspx
// https://msdn.microsoft.com/en-us/library/windows/desktop/aa365680.aspx
// https://msdn.microsoft.com/en-us/library/windows/desktop/aa365006.aspx
// Performing a file transaction on a symbolic link
// would delete/replace the symbolic link instead of
// writing to its target
FileAttributes fa = File.GetAttributes(strPath);
if ((long)(fa & FileAttributes.ReparsePoint) != 0)
{
m_bTransacted = false;
}
}
else
{
// If the base and the temporary file are in different
// folders and the base file doesn't exist (i.e. we can't
// backup the ACL), a transaction would cause the new file
// to have the default ACL of the temporary folder instead
// of the one of the base folder; therefore, we don't use
// a transaction when the base file doesn't exist (this
// also results in other applications monitoring the folder
// to see one file creation only)
m_bTransacted = false;
}
}
catch (Exception) { Debug.Assert(false); }
}
#if !KeePassUAP && !KeePassUWP
// Prevent transactions for FTP URLs under .NET 4.0 in order to
// avoid/workaround .NET bug 621450:
// https://connect.microsoft.com/VisualStudio/feedback/details/621450/problem-renaming-file-on-ftp-server-using-ftpwebrequest-in-net-framework-4-0-vs2010-only
if (strPath.StartsWith("ftp:", StrUtil.CaseIgnoreCmp) &&
(Environment.Version.Major >= 4) && !NativeLib.IsUnix())
{
m_bTransacted = false;
}
#endif
foreach (KeyValuePair <string, bool> kvp in g_dEnabled)
{
if (strPath.StartsWith(kvp.Key, StrUtil.CaseIgnoreCmp))
{
m_bTransacted = kvp.Value;
break;
}
}
if (m_bTransacted)
{
m_iocTemp = m_iocBase.CloneDeep();
m_iocTemp.Path += StrTempSuffix;
TxfPrepare(); // Adjusts m_iocTemp
}
else
{
m_iocTemp = m_iocBase;
}
}
public static bool FileExists(IOConnectionInfo ioc)
{
return(FileExists(ioc, false));
}
public FileTransactionEx(IOConnectionInfo iocBaseFile, bool bTransacted)
{
Initialize(iocBaseFile, bTransacted);
}
/// <summary>
/// Rename/move a file. For local file system and WebDAV, the
/// specified file is moved, i.e. the file destination can be
/// in a different directory/path. In contrast, for FTP the
/// file is renamed, i.e. its destination must be in the same
/// directory/path.
/// </summary>
/// <param name="iocFrom">Source file path.</param>
/// <param name="iocTo">Target file path.</param>
public static void RenameFile(IOConnectionInfo iocFrom, IOConnectionInfo iocTo)
{
RaiseIOAccessPreEvent(iocFrom, iocTo, IOAccessType.Move);
#if NETSTANDARD2_0
if (iocFrom.IsLocalFile())
{
m_FilesProvider.MoveFile(iocFrom.Path, iocTo.Path); return;
}
#else
if (iocFrom.IsLocalFile())
{
File.Move(iocFrom.Path, iocTo.Path); return;
}
#endif
#if !KeePassLibSD && !NETSTANDARD2_0
WebRequest req = CreateWebRequest(iocFrom);
if (req != null)
{
string strToCnc = UrlUtil.GetCanonicalUri(iocTo.Path);
if (IsHttpWebRequest(req))
{
#if KeePassUAP
throw new NotSupportedException();
#else
req.Method = "MOVE";
req.Headers.Set("Destination", strToCnc); // Full URL supported
#endif
}
else if (IsFtpWebRequest(req))
{
#if KeePassUAP
throw new NotSupportedException();
#else
req.Method = WebRequestMethods.Ftp.Rename;
string strToName = UrlUtil.GetFileName(strToCnc);
// We're affected by .NET bug 621450:
// https://connect.microsoft.com/VisualStudio/feedback/details/621450/problem-renaming-file-on-ftp-server-using-ftpwebrequest-in-net-framework-4-0-vs2010-only
// Prepending "./", "%2E/" or "Dummy/../" doesn't work.
((FtpWebRequest)req).RenameTo = strToName;
#endif
}
else if (IsFileWebRequest(req))
{
File.Move(UrlUtil.FileUrlToPath(iocFrom.Path),
UrlUtil.FileUrlToPath(iocTo.Path));
return;
}
else
{
#if KeePassUAP
throw new NotSupportedException();
#else
req.Method = WrmMoveFile;
req.Headers.Set(WrhMoveFileTo, strToCnc);
#endif
}
#if !KeePassUAP // Unreachable code
DisposeResponse(req.GetResponse(), true);
#endif
}
#endif
// using(Stream sIn = IOConnection.OpenRead(iocFrom))
// {
// using(Stream sOut = IOConnection.OpenWrite(iocTo))
// {
// MemUtil.CopyStream(sIn, sOut);
// sOut.Close();
// }
//
// sIn.Close();
// }
// DeleteFile(iocFrom);
}
public void ChangeDatabase(string fileName, bool closeCurrent)
{
if (closeCurrent && host.MainWindow.DocumentManager.ActiveDatabase != null && host.MainWindow.DocumentManager.ActiveDatabase.IsOpen)
{
host.MainWindow.DocumentManager.CloseDatabase(host.MainWindow.DocumentManager.ActiveDatabase);
}
KeePassLib.Serialization.IOConnectionInfo ioci = null;
if (fileName != null && fileName.Length > 0)
{
ioci = new KeePassLib.Serialization.IOConnectionInfo();
ioci.Path = fileName;
}
host.MainWindow.BeginInvoke((MethodInvoker)delegate { promptUserToOpenDB(ioci); });
return;
}
private static Stream OpenWriteLocal(IOConnectionInfo ioc)
{
return(m_FilesProvider.OpenWriteLocal(ioc.Path));
}