public GoogleDrive(string url, Dictionary <string, string> options)
{
var uri = new Utility.Uri(url);
m_path = uri.HostAndPath;
if (!m_path.EndsWith("/", StringComparison.Ordinal))
{
m_path += "/";
}
string authid = null;
if (options.ContainsKey(AUTHID_OPTION))
{
authid = options[AUTHID_OPTION];
}
if (options.ContainsKey(DISABLE_TEAMDRIVE_OPTION))
{
m_useTeamDrive = !Library.Utility.Utility.ParseBoolOption(options, DISABLE_TEAMDRIVE_OPTION);
}
m_oauth = new OAuthHelper(authid, this.ProtocolKey)
{
AutoAuthHeader = true
};
m_filecache = new Dictionary <string, GoogleDriveFolderItem[]>();
}
public AmzCD(string url, Dictionary<string, string> options)
{
var uri = new Utility.Uri(url);
m_path = uri.HostAndPath;
if (!m_path.EndsWith("/"))
m_path += "/";
string authid = null;
if (options.ContainsKey(AUTHID_OPTION))
authid = options[AUTHID_OPTION];
string labels = DEFAULT_LABELS;
if (options.ContainsKey(LABELS_OPTION))
labels = options[LABELS_OPTION];
string delay = DEFAULT_DELAY;
if (options.ContainsKey(DELAY_OPTION))
delay = options[DELAY_OPTION];
if (!string.IsNullOrWhiteSpace(labels))
m_labels = labels.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
if (string.IsNullOrWhiteSpace(delay))
m_delayTimeSpan = new TimeSpan(0);
else
m_delayTimeSpan = Library.Utility.Timeparser.ParseTimeSpan(delay);
m_oauth = new OAuthHelper(authid, this.ProtocolKey) { AutoAuthHeader = true };
m_userid = authid.Split(new string[] {":"}, StringSplitOptions.RemoveEmptyEntries).First();
}
/// <summary>
/// Gets the supported commands for a certain url
/// </summary>
/// <param name="url">The url to find commands for</param>
/// <returns>The supported commands or null if the url scheme was not supported</returns>
public IList <ICommandLineArgument> GetSupportedCommands(string url)
{
var uri = new Utility.Uri(url);
LoadInterfaces();
lock (m_lock)
{
IBackend b;
if (m_interfaces.TryGetValue(uri.Scheme, out b) && b != null)
{
return(b.SupportedCommands);
}
else if (uri.Scheme.EndsWith("s"))
{
var tmpscheme = uri.Scheme.Substring(0, uri.Scheme.Length - 1);
if (m_interfaces.ContainsKey(tmpscheme))
{
return(m_interfaces[tmpscheme].SupportedCommands);
}
}
return(null);
}
}
public AzureBlobBackend(string url, Dictionary<string, string> options)
{
var uri = new Utility.Uri(url);
uri.RequireHost();
string storageAccountName = null;
string accessKey = null;
string containerName = uri.Host.ToLowerInvariant();
if (options.ContainsKey("auth-username"))
storageAccountName = options["auth-username"];
if (options.ContainsKey("auth-password"))
accessKey = options["auth-password"];
if (options.ContainsKey("azure_account_name"))
storageAccountName = options["azure_account_name"];
if (options.ContainsKey("azure_access_key"))
accessKey = options["azure_access_key"];
if (!string.IsNullOrEmpty(uri.Username))
storageAccountName = uri.Username;
if (!string.IsNullOrEmpty(uri.Password))
accessKey = uri.Password;
if (string.IsNullOrWhiteSpace(storageAccountName))
{
throw new Exception(Strings.AzureBlobBackend.NoStorageAccountName);
}
if (string.IsNullOrWhiteSpace(accessKey))
{
throw new Exception(Strings.AzureBlobBackend.NoAccessKey);
}
_azureBlob = new AzureBlobWrapper(storageAccountName, accessKey, containerName);
}
public SSHv2(string url, Dictionary<string, string> options)
: this()
{
m_options = options;
var uri = new Utility.Uri(url);
uri.RequireHost();
if (options.ContainsKey("auth-username"))
m_username = options["auth-username"];
if (options.ContainsKey("auth-password"))
m_password = options["auth-password"];
if (!string.IsNullOrEmpty(uri .Username))
m_username = uri.Username;
if (!string.IsNullOrEmpty(uri .Password))
m_password = uri.Password;
m_path = uri.Path;
if (!string.IsNullOrWhiteSpace(m_path) && !m_path.EndsWith("/"))
m_path += "/";
m_server = uri.Host;
if (uri.Port > 0)
m_port = uri.Port;
}
public GoogleCloudStorage(string url, Dictionary <string, string> options)
{
var uri = new Utility.Uri(url);
m_bucket = uri.Host;
m_prefix = Duplicati.Library.Utility.Utility.AppendDirSeparator("/" + uri.Path, "/");
// For GCS we do not use a leading slash
if (m_prefix.StartsWith("/", StringComparison.Ordinal))
{
m_prefix = m_prefix.Substring(1);
}
string authid;
options.TryGetValue(AUTHID_OPTION, out authid);
options.TryGetValue(PROJECT_OPTION, out m_project);
options.TryGetValue(LOCATION_OPTION, out m_location);
options.TryGetValue(STORAGECLASS_OPTION, out m_storage_class);
if (string.IsNullOrEmpty(authid))
{
throw new UserInformationException(Strings.GoogleCloudStorage.MissingAuthID(AUTHID_OPTION), "GoogleCloudStorageMissingAuthID");
}
m_oauth = new OAuthHelper(authid, this.ProtocolKey);
m_oauth.AutoAuthHeader = true;
}
public AmzCD(string url, Dictionary <string, string> options)
{
var uri = new Utility.Uri(url);
m_path = uri.HostAndPath;
if (!m_path.EndsWith("/"))
{
m_path += "/";
}
string authid = null;
if (options.ContainsKey(AUTHID_OPTION))
{
authid = options[AUTHID_OPTION];
}
string labels = DEFAULT_LABELS;
if (options.ContainsKey(LABELS_OPTION))
{
labels = options[LABELS_OPTION];
}
if (!string.IsNullOrWhiteSpace(labels))
{
m_labels = labels.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
}
m_oauth = new OAuthHelper(authid, this.ProtocolKey)
{
AutoAuthHeader = true
};
m_userid = authid.Split(new string[] { ":" }, StringSplitOptions.RemoveEmptyEntries).First();
}
public MegaBackend(string url, Dictionary <string, string> options)
{
var uri = new Utility.Uri(url);
if (options.ContainsKey("auth-username"))
{
m_username = options["auth-username"];
}
if (options.ContainsKey("auth-password"))
{
m_password = options["auth-password"];
}
if (!string.IsNullOrEmpty(uri.Username))
{
m_username = uri.Username;
}
if (!string.IsNullOrEmpty(uri.Password))
{
m_password = uri.Password;
}
if (string.IsNullOrEmpty(m_username))
{
throw new UserInformationException(Strings.MegaBackend.NoUsernameError, "MegaNoUsername");
}
if (string.IsNullOrEmpty(m_password))
{
throw new UserInformationException(Strings.MegaBackend.NoPasswordError, "MegaNoPassword");
}
m_prefix = uri.HostAndPath ?? "";
}
public GoogleCloudStorage(string url, Dictionary<string, string> options)
{
var uri = new Utility.Uri(url);
m_bucket = uri.Host;
m_prefix = "/" + uri.Path;
if (!m_prefix.EndsWith("/"))
m_prefix += "/";
// For GCS we do not use a leading slash
if (m_prefix.StartsWith("/"))
m_prefix = m_prefix.Substring(1);
string authid;
options.TryGetValue(AUTHID_OPTION, out authid);
options.TryGetValue(PROJECT_OPTION, out m_project);
options.TryGetValue(LOCATION_OPTION, out m_location);
options.TryGetValue(STORAGECLASS_OPTION, out m_storage_class);
if (string.IsNullOrEmpty(authid))
throw new Exception(Strings.GoogleCloudStorage.MissingAuthID(AUTHID_OPTION));
m_oauth = new OAuthHelper(authid, this.ProtocolKey);
m_oauth.AutoAuthHeader = true;
}
public GoogleCloudStorage(string url, Dictionary <string, string> options)
{
var uri = new Utility.Uri(url);
m_bucket = uri.Host;
m_prefix = "/" + uri.Path;
if (!m_prefix.EndsWith("/"))
{
m_prefix += "/";
}
// For GCS we do not use a leading slash
if (m_prefix.StartsWith("/"))
{
m_prefix = m_prefix.Substring(1);
}
string authid;
options.TryGetValue(AUTHID_OPTION, out authid);
options.TryGetValue(PROJECT_OPTION, out m_project);
options.TryGetValue(LOCATION_OPTION, out m_location);
options.TryGetValue(STORAGECLASS_OPTION, out m_storage_class);
if (string.IsNullOrEmpty(authid))
{
throw new Exception(Strings.GoogleCloudStorage.MissingAuthID(AUTHID_OPTION));
}
m_oauth = new OAuthHelper(authid, this.ProtocolKey);
m_oauth.AutoAuthHeader = true;
}
protected virtual string GetRootPathFromUrl(string url)
{
// Extract out the path to the backup root folder from the given URI
var uri = new Utility.Uri(url);
return(Utility.Uri.UrlDecode(uri.HostAndPath));
}
public FTP(string url, Dictionary<string, string> options)
{
//This can be made better by keeping a single ftp stream open,
//unfortunately the .Net model does not allow this as the request is
//bound to a single url (path+file).
//
//To fix this, a thirdparty FTP library is required,
//this would also allow a fix for the FTP servers
//that only support SSL during authentication, not during transfers
//
//If you have experience with a stable open source .Net FTP library,
//please let the Duplicati authors know
var u = new Utility.Uri(url);
u.RequireHost();
if (!string.IsNullOrEmpty(u.Username))
{
m_userInfo = new System.Net.NetworkCredential();
m_userInfo.UserName = u.Username;
if (!string.IsNullOrEmpty(u.Password))
m_userInfo.Password = u.Password;
else if (options.ContainsKey("auth-password"))
m_userInfo.Password = options["auth-password"];
}
else
{
if (options.ContainsKey("auth-username"))
{
m_userInfo = new System.Net.NetworkCredential();
m_userInfo.UserName = options["auth-username"];
if (options.ContainsKey("auth-password"))
m_userInfo.Password = options["auth-password"];
}
}
//Bugfix, see http://connect.microsoft.com/VisualStudio/feedback/details/695227/networkcredential-default-constructor-leaves-domain-null-leading-to-null-object-reference-exceptions-in-framework-code
if (m_userInfo != null)
m_userInfo.Domain = "";
m_url = u.SetScheme("ftp").SetQuery(null).SetCredentials(null, null).ToString();
if (!m_url.EndsWith("/"))
m_url += "/";
m_useSSL = Utility.Utility.ParseBoolOption(options, "use-ssl");
m_listVerify = !Utility.Utility.ParseBoolOption(options, "disable-upload-verify");
if (Utility.Utility.ParseBoolOption(options, "ftp-passive"))
{
m_defaultPassive = false;
m_passive = true;
}
if (Utility.Utility.ParseBoolOption(options, "ftp-regular"))
{
m_defaultPassive = false;
m_passive = false;
}
}
public WEBDAV(string url, Dictionary<string, string> options)
{
var u = new Utility.Uri(url);
u.RequireHost();
if (!string.IsNullOrEmpty(u.Username))
{
m_userInfo = new System.Net.NetworkCredential();
m_userInfo.UserName = u.Username;
if (!string.IsNullOrEmpty(u.Password))
m_userInfo.Password = u.Password;
else if (options.ContainsKey("auth-password"))
m_userInfo.Password = options["auth-password"];
}
else
{
if (options.ContainsKey("auth-username"))
{
m_userInfo = new System.Net.NetworkCredential();
m_userInfo.UserName = options["auth-username"];
if (options.ContainsKey("auth-password"))
m_userInfo.Password = options["auth-password"];
}
}
//Bugfix, see http://connect.microsoft.com/VisualStudio/feedback/details/695227/networkcredential-default-constructor-leaves-domain-null-leading-to-null-object-reference-exceptions-in-framework-code
if (m_userInfo != null)
m_userInfo.Domain = "";
m_useIntegratedAuthentication = Utility.Utility.ParseBoolOption(options, "integrated-authentication");
m_forceDigestAuthentication = Utility.Utility.ParseBoolOption(options, "force-digest-authentication");
m_useSSL = Utility.Utility.ParseBoolOption(options, "use-ssl");
m_url = u.SetScheme(m_useSSL ? "https" : "http").SetCredentials(null, null).SetQuery(null).ToString();
if (!m_url.EndsWith("/"))
m_url += "/";
m_path = u.Path;
if (!m_path.StartsWith("/"))
m_path = "/" + m_path;
if (!m_path.EndsWith("/"))
m_path += "/";
m_path = System.Web.HttpUtility.UrlDecode(m_path);
m_rawurl = new Utility.Uri(m_useSSL ? "https" : "http", u.Host, m_path).ToString();
int port = u.Port;
if (port <= 0)
port = m_useSSL ? 443 : 80;
m_rawurlPort = new Utility.Uri(m_useSSL ? "https" : "http", u.Host, m_path, null, null, null, port).ToString();
m_sanitizedUrl = new Utility.Uri(m_useSSL ? "https" : "http", u.Host, m_path).ToString();
m_reverseProtocolUrl = new Utility.Uri(m_useSSL ? "http" : "https", u.Host, m_path).ToString();
options.TryGetValue("debug-propfind-file", out m_debugPropfindFile);
}
public SSHv2(string url, Dictionary <string, string> options)
: this()
{
m_options = options;
var uri = new Utility.Uri(url);
uri.RequireHost();
if (options.ContainsKey("auth-username"))
{
m_username = options["auth-username"];
}
if (options.ContainsKey("auth-password"))
{
m_password = options["auth-password"];
}
if (options.ContainsKey(SSH_FINGERPRINT_OPTION))
{
m_fingerprint = options[SSH_FINGERPRINT_OPTION];
}
if (!string.IsNullOrEmpty(uri.Username))
{
m_username = uri.Username;
}
if (!string.IsNullOrEmpty(uri.Password))
{
m_password = uri.Password;
}
if (uri.QueryParameters != null && uri.QueryParameters[SSH_FINGERPRINT_OPTION] != null)
{
m_fingerprint = uri.QueryParameters[SSH_FINGERPRINT_OPTION];
}
m_fingerprintallowall = Utility.Utility.ParseBoolOption(options, SSH_FINGERPRINT_ACCEPT_ANY_OPTION);
m_path = uri.Path;
if (!string.IsNullOrWhiteSpace(m_path) && !m_path.EndsWith("/"))
{
m_path += "/";
}
if (!m_path.StartsWith("/"))
{
m_path = "/" + m_path;
}
m_server = uri.Host;
if (uri.Port > 0)
{
m_port = uri.Port;
}
}
/// <summary>
/// Instanciates a specific backend, given the url and options
/// </summary>
/// <param name="url">The url to create the instance for</param>
/// <param name="options">The options to pass to the instance constructor</param>
/// <returns>The instanciated backend or null if the url is not supported</returns>
public IBackend GetBackend(string url, Dictionary <string, string> options)
{
var uri = new Utility.Uri(url);
LoadInterfaces();
var newOpts = new Dictionary <string, string>(options);
foreach (var key in uri.QueryParameters.AllKeys)
{
newOpts[key] = uri.QueryParameters[key];
}
lock (m_lock)
{
try
{
if (m_interfaces.ContainsKey(uri.Scheme))
{
return((IBackend)Activator.CreateInstance(m_interfaces[uri.Scheme].GetType(), url, newOpts));
}
else if (uri.Scheme.EndsWith("s", StringComparison.Ordinal))
{
var tmpscheme = uri.Scheme.Substring(0, uri.Scheme.Length - 1);
if (m_interfaces.ContainsKey(tmpscheme))
{
var commands = m_interfaces[tmpscheme].SupportedCommands;
if (commands != null && (commands.Any(x =>
x.Name.Equals("use-ssl", StringComparison.OrdinalIgnoreCase) ||
(x.Aliases != null && x.Aliases.Any(y => y.Equals("use-ssl", StringComparison.OrdinalIgnoreCase)))
)))
{
newOpts["use-ssl"] = "true";
return((IBackend)Activator.CreateInstance(m_interfaces[tmpscheme].GetType(), url, newOpts));
}
}
}
}
catch (System.Reflection.TargetInvocationException tex)
{
if (tex.InnerException != null)
{
// Unwrap exceptions for nicer display. The ExceptionDispatchInfo class allows us to
// rethrow an exception without changing the stack trace.
ExceptionDispatchInfo.Capture(tex.InnerException).Throw();
}
throw;
}
return(null);
}
}
// ReSharper disable once UnusedMember.Global
// This constructor is needed by the BackendLoader.
public AzureBlobBackend(string url, Dictionary <string, string> options)
{
var uri = new Utility.Uri(url);
uri.RequireHost();
string storageAccountName = null;
string accessKey = null;
string containerName = uri.Host.ToLowerInvariant();
if (options.ContainsKey("auth-username"))
{
storageAccountName = options["auth-username"];
}
if (options.ContainsKey("auth-password"))
{
accessKey = options["auth-password"];
}
if (options.ContainsKey("azure_account_name"))
{
storageAccountName = options["azure_account_name"];
}
if (options.ContainsKey("azure_access_key"))
{
accessKey = options["azure_access_key"];
}
if (!string.IsNullOrEmpty(uri.Username))
{
storageAccountName = uri.Username;
}
if (!string.IsNullOrEmpty(uri.Password))
{
accessKey = uri.Password;
}
if (storageAccountName == null && accessKey == null)
{
_azureBlob = new AzureBlobWrapper(url);
return;
}
if (string.IsNullOrWhiteSpace(storageAccountName))
{
throw new UserInformationException(Strings.AzureBlobBackend.NoStorageAccountName, "AzureNoAccountName");
}
if (string.IsNullOrWhiteSpace(accessKey))
{
throw new UserInformationException(Strings.AzureBlobBackend.NoAccessKey, "AzureNoAccessKey");
}
_azureBlob = new AzureBlobWrapper(storageAccountName, accessKey, containerName);
}
/// <summary>
/// SharePoint has nested subwebs but sometimes different webs
/// are hooked into a sub path.
/// For finding files SharePoint is picky to use the correct
/// path to the web, so we will trial and error here.
/// The user can give us a hint by supplying an URI with a double
/// slash to separate web.
/// Otherwise it's a good guess to look for "/documents", as we expect
/// that the default document library is used in the path.
/// If that won't help, we will try all possible pathes from longest
/// to shortest...
/// </summary>
private static string findCorrectWebPath(Utility.Uri orgUrl, System.Net.ICredentials userInfo, out SP.ClientContext retCtx)
{
retCtx = null;
string path = orgUrl.Path;
int webIndicatorPos = path.IndexOf("//", StringComparison.Ordinal);
// if a hint is supplied, we will of course use this first.
if (webIndicatorPos >= 0)
{
string testUrl = new Utility.Uri(orgUrl.Scheme, orgUrl.Host, path.Substring(0, webIndicatorPos), null, null, null, orgUrl.Port).ToString();
if (testUrlForWeb(testUrl, userInfo, false, out retCtx) >= 0)
{
return(testUrl);
}
}
// Now go through path and see where we land a success.
string[] pathParts = path.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
// first we look for the doc library
int docLibrary = Array.FindIndex(pathParts, p => StringComparer.OrdinalIgnoreCase.Equals(p, "documents"));
if (docLibrary >= 0)
{
string testUrl = new Utility.Uri(orgUrl.Scheme, orgUrl.Host,
string.Join("/", pathParts, 0, docLibrary),
null, null, null, orgUrl.Port).ToString();
if (testUrlForWeb(testUrl, userInfo, false, out retCtx) >= 0)
{
return(testUrl);
}
}
// last but not least: try one after the other.
for (int pi = pathParts.Length - 1; pi >= 0; pi--)
{
if (pi == docLibrary)
{
continue; // already tested
}
string testUrl = new Utility.Uri(orgUrl.Scheme, orgUrl.Host,
string.Join("/", pathParts, 0, pi),
null, null, null, orgUrl.Port).ToString();
if (testUrlForWeb(testUrl, userInfo, false, out retCtx) >= 0)
{
return(testUrl);
}
}
// nothing worked :(
return(null);
}
public AmzCD(string url, Dictionary <string, string> options)
{
var uri = new Utility.Uri(url);
m_path = uri.HostAndPath;
if (!m_path.EndsWith("/", StringComparison.Ordinal))
{
m_path += "/";
}
string authid = null;
if (options.ContainsKey(AUTHID_OPTION))
{
authid = options[AUTHID_OPTION];
}
string labels = DEFAULT_LABELS;
if (options.ContainsKey(LABELS_OPTION))
{
labels = options[LABELS_OPTION];
}
string delay = DEFAULT_DELAY;
if (options.ContainsKey(DELAY_OPTION))
{
delay = options[DELAY_OPTION];
}
if (!string.IsNullOrWhiteSpace(labels))
{
m_labels = labels.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
}
if (string.IsNullOrWhiteSpace(delay))
{
m_delayTimeSpan = new TimeSpan(0);
}
else
{
m_delayTimeSpan = Library.Utility.Timeparser.ParseTimeSpan(delay);
}
m_waitUntil = DateTime.Now + m_delayTimeSpan;
m_oauth = new OAuthHelper(authid, this.ProtocolKey)
{
AutoAuthHeader = true
};
m_userid = authid.Split(new string[] { ":" }, StringSplitOptions.RemoveEmptyEntries).First();
}
public GoogleDrive(string url, Dictionary<string, string> options)
{
var uri = new Utility.Uri(url);
m_path = uri.HostAndPath;
if (!m_path.EndsWith("/"))
m_path += "/";
string authid = null;
if (options.ContainsKey(AUTHID_OPTION))
authid = options[AUTHID_OPTION];
m_oauth = new OAuthHelper(authid, this.ProtocolKey) { AutoAuthHeader = true };
m_filecache = new Dictionary<string, GoogleDriveFolderItem[]>();
}
public OneDrive(string url, Dictionary<string, string> options)
{
var uri = new Utility.Uri(url);
m_rootfolder = uri.Host;
m_prefix = "/" + uri.Path;
if (!m_prefix.EndsWith("/"))
m_prefix += "/";
string authid = null;
if (options.ContainsKey(AUTHID_OPTION))
authid = options[AUTHID_OPTION];
m_oauth = new OAuthHelper(authid, this.ProtocolKey);
}
public TahoeBackend(string url, Dictionary<string, string> options)
{
//Validate URL
var u = new Utility.Uri(url);
u.RequireHost();
if (!u.Path.StartsWith("uri/URI:DIR2:") && !u.Path.StartsWith("uri/URI%3ADIR2%3A"))
throw new Exception(Strings.TahoeBackend.UnrecognizedUriError);
m_useSSL = Utility.Utility.ParseBoolOption(options, "use-ssl");
m_url = u.SetScheme(m_useSSL ? "https" : "http").SetQuery(null).SetCredentials(null, null).ToString();
if (!m_url.EndsWith("/"))
m_url += "/";
}
public OneDrive(string url, Dictionary <string, string> options)
{
var uri = new Utility.Uri(url);
m_rootfolder = uri.Host;
m_prefix = Duplicati.Library.Utility.Utility.AppendDirSeparator("/" + uri.Path, "/");
string authid = null;
if (options.ContainsKey(AUTHID_OPTION))
{
authid = options[AUTHID_OPTION];
}
m_oauth = new OAuthHelper(authid, this.ProtocolKey);
}
public Dropbox(string url, Dictionary<string, string> options)
{
var uri = new Utility.Uri(url);
m_path = Library.Utility.Uri.UrlDecode(uri.HostAndPath);
if (m_path.Length != 0 && !m_path.StartsWith("/"))
m_path = "/" + m_path;
if (m_path.EndsWith("/"))
m_path = m_path.Substring(0, m_path.Length - 1);
if (options.ContainsKey(AUTHID_OPTION))
m_accesToken = options[AUTHID_OPTION];
dbx = new DropboxHelper(m_accesToken);
}
public Sia(string url, Dictionary <string, string> options)
{
var uri = new Utility.Uri(url);
m_apihost = uri.Host;
m_apiport = uri.Port;
m_targetpath = uri.Path;
m_redundancy = 1.5F;
if (options.ContainsKey(SIA_REDUNDANCY))
{
m_redundancy = float.Parse(options[SIA_REDUNDANCY]);
}
if (m_apiport <= 0)
{
m_apiport = 9980;
}
if (options.ContainsKey(SIA_TARGETPATH))
{
m_targetpath = options[SIA_TARGETPATH];
}
while (m_targetpath.Contains("//"))
{
m_targetpath = m_targetpath.Replace("//", "/");
}
while (m_targetpath.StartsWith("/", StringComparison.Ordinal))
{
m_targetpath = m_targetpath.Substring(1);
}
while (m_targetpath.EndsWith("/", StringComparison.Ordinal))
{
m_targetpath = m_targetpath.Remove(m_targetpath.Length - 1);
}
if (m_targetpath.Length == 0)
{
m_targetpath = "backup";
}
m_user = new System.Net.NetworkCredential();
if (options.ContainsKey(SIA_PASSWORD))
{
m_user.Password = options[SIA_PASSWORD];
}
}
public OpenStackStorage(string url, Dictionary <string, string> options)
{
var uri = new Utility.Uri(url);
m_container = uri.Host;
m_prefix = "/" + uri.Path;
if (!m_prefix.EndsWith("/", StringComparison.Ordinal))
{
m_prefix += "/";
}
// For OpenStack we do not use a leading slash
if (m_prefix.StartsWith("/", StringComparison.Ordinal))
{
m_prefix = m_prefix.Substring(1);
}
options.TryGetValue(USERNAME_OPTION, out m_username);
options.TryGetValue(PASSWORD_OPTION, out m_password);
options.TryGetValue(TENANTNAME_OPTION, out m_tenantName);
options.TryGetValue(AUTHURI_OPTION, out m_authUri);
options.TryGetValue(APIKEY_OPTION, out m_apikey);
options.TryGetValue(REGION_OPTION, out m_region);
if (string.IsNullOrWhiteSpace(m_username))
{
throw new UserInformationException(Strings.OpenStack.MissingOptionError(USERNAME_OPTION), "OpenStackMissingUsername");
}
if (string.IsNullOrWhiteSpace(m_authUri))
{
throw new UserInformationException(Strings.OpenStack.MissingOptionError(AUTHURI_OPTION), "OpenStackMissingAuthUri");
}
if (string.IsNullOrWhiteSpace(m_apikey))
{
if (string.IsNullOrWhiteSpace(m_password))
{
throw new UserInformationException(Strings.OpenStack.MissingOptionError(PASSWORD_OPTION), "OpenStackMissingPassword");
}
if (string.IsNullOrWhiteSpace(m_tenantName))
{
throw new UserInformationException(Strings.OpenStack.MissingOptionError(TENANTNAME_OPTION), "OpenStackMissingTenantName");
}
}
m_helper = new WebHelper(this);
}
public TahoeBackend(string url, Dictionary <string, string> options)
{
//Validate URL
var u = new Utility.Uri(url);
u.RequireHost();
if (!u.Path.StartsWith("uri/URI:DIR2:", StringComparison.Ordinal) && !u.Path.StartsWith("uri/URI%3ADIR2%3A", StringComparison.Ordinal))
{
throw new UserInformationException(Strings.TahoeBackend.UnrecognizedUriError, "TahoeInvalidUri");
}
m_useSSL = Utility.Utility.ParseBoolOption(options, "use-ssl");
m_url = u.SetScheme(m_useSSL ? "https" : "http").SetQuery(null).SetCredentials(null, null).ToString();
m_url = Util.AppendDirSeparator(m_url, "/");
}
public BoxBackend(string url, Dictionary <string, string> options)
{
var uri = new Utility.Uri(url);
m_path = Util.AppendDirSeparator(uri.HostAndPath, "/");
string authid = null;
if (options.ContainsKey(AUTHID_OPTION))
{
authid = options[AUTHID_OPTION];
}
m_deleteFromTrash = Library.Utility.Utility.ParseBoolOption(options, REALLY_DELETE_OPTION);
m_oauth = new BoxHelper(authid);
}
// ReSharper disable once UnusedMember.Global
// This constructor is needed by the BackendLoader.
public AmzCD(string url, Dictionary <string, string> options)
{
var uri = new Utility.Uri(url);
m_path = Util.AppendDirSeparator(uri.HostAndPath, "/");
if (options.ContainsKey(AUTHID_OPTION))
{
m_authid = options[AUTHID_OPTION];
}
string labels = DEFAULT_LABELS;
if (options.ContainsKey(LABELS_OPTION))
{
labels = options[LABELS_OPTION];
}
string delay = DEFAULT_DELAY;
if (options.ContainsKey(DELAY_OPTION))
{
delay = options[DELAY_OPTION];
}
if (!string.IsNullOrWhiteSpace(labels))
{
m_labels = labels.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
}
if (string.IsNullOrWhiteSpace(delay))
{
m_delayTimeSpan = new TimeSpan(0);
}
else
{
m_delayTimeSpan = Library.Utility.Timeparser.ParseTimeSpan(delay);
}
m_oauth = new OAuthHelper(m_authid, this.ProtocolKey)
{
AutoAuthHeader = true
};
m_userid = m_authid.Split(new [] { ":" }, StringSplitOptions.RemoveEmptyEntries).First();
}
public Idrivee2Backend(string url, Dictionary <string, string> options)
{
var uri = new Utility.Uri(url);
m_bucket = uri.Host;
m_prefix = uri.Path;
m_prefix = m_prefix.Trim();
if (m_prefix.Length != 0)
{
m_prefix = Util.AppendDirSeparator(m_prefix, "/");
}
string accessKeyId = null;
string accessKeySecret = null;
if (options.ContainsKey("auth-username"))
{
accessKeyId = options["auth-username"];
}
if (options.ContainsKey("auth-password"))
{
accessKeySecret = options["auth-password"];
}
if (options.ContainsKey("access_key_id"))
{
accessKeyId = options["access_key_id"];
}
if (options.ContainsKey("secret_access_key"))
{
accessKeySecret = options["secret_access_key"];
}
if (string.IsNullOrEmpty(accessKeyId))
{
throw new UserInformationException(Strings.Idrivee2Backend.NoKeyIdError, "Idrivee2NoKeyId");
}
if (string.IsNullOrEmpty(accessKeySecret))
{
throw new UserInformationException(Strings.Idrivee2Backend.NoKeySecretError, "Idrivee2NoKeySecret");
}
string host = GetRegionEndpoint("https://api.idrivee2.com/api/service/get_region_end_point/" + accessKeyId);
m_s3Client = new S3AwsClient(accessKeyId, accessKeySecret, null, host, null, true, options);
}
public Sia(string url, Dictionary <string, string> options)
{
var uri = new Utility.Uri(url);
m_apihost = uri.Host;
m_apiport = uri.Port;
m_targetpath = uri.Path;
m_redundancy = 1.5F;
if (options.ContainsKey(SIA_REDUNDANCY))
{
m_redundancy = float.Parse(options[SIA_REDUNDANCY]);
}
if (m_apiport <= 0)
{
m_apiport = 9980;
}
if (options.ContainsKey(SIA_TARGETPATH))
{
m_targetpath = options[SIA_TARGETPATH];
}
while (m_targetpath.Contains("//"))
{
m_targetpath = m_targetpath.Replace("//", "/");
}
while (m_targetpath.StartsWith("/", StringComparison.Ordinal))
{
m_targetpath = m_targetpath.Substring(1);
}
while (m_targetpath.EndsWith("/", StringComparison.Ordinal))
{
m_targetpath = m_targetpath.Remove(m_targetpath.Length - 1);
}
if (m_targetpath.Length == 0)
{
m_targetpath = "backup";
}
m_authorization = options.ContainsKey(SIA_PASSWORD) && !string.IsNullOrEmpty(options[SIA_PASSWORD])
? "Basic " + System.Convert.ToBase64String(System.Text.Encoding.GetEncoding("ISO-8859-1").GetBytes(":" + options[SIA_PASSWORD]))
: null;
}
public SSHv2(string url, Dictionary <string, string> options)
: this()
{
m_options = options;
var uri = new Utility.Uri(url);
uri.RequireHost();
if (options.ContainsKey("auth-username"))
{
m_username = options["auth-username"];
}
if (options.ContainsKey("auth-password"))
{
m_password = options["auth-password"];
}
if (!string.IsNullOrEmpty(uri.Username))
{
m_username = uri.Username;
}
if (!string.IsNullOrEmpty(uri.Password))
{
m_password = uri.Password;
}
m_path = uri.Path;
if (!string.IsNullOrWhiteSpace(m_path) && !m_path.EndsWith("/"))
{
m_path += "/";
}
if (!m_path.StartsWith("/"))
{
m_path = "/" + m_path;
}
m_server = uri.Host;
if (uri.Port > 0)
{
m_port = uri.Port;
}
}
public B2(string url, Dictionary<string, string> options)
{
var uri = new Utility.Uri(url);
m_bucketname = uri.Host;
m_prefix = "/" + uri.Path;
if (!m_prefix.EndsWith("/"))
m_prefix += "/";
// For B2 we do not use a leading slash
while(m_prefix.StartsWith("/"))
m_prefix = m_prefix.Substring(1);
m_urlencodedprefix = string.Join("/", m_prefix.Split(new [] { '/' }).Select(x => Library.Utility.Uri.UrlPathEncode(x)));
m_bucketType = DEFAULT_BUCKET_TYPE;
if (options.ContainsKey(B2_CREATE_BUCKET_TYPE_OPTION))
m_bucketType = options[B2_CREATE_BUCKET_TYPE_OPTION];
string accountId = null;
string accountKey = null;
if (options.ContainsKey("auth-username"))
accountId = options["auth-username"];
if (options.ContainsKey("auth-password"))
accountKey = options["auth-password"];
if (options.ContainsKey(B2_ID_OPTION))
accountId = options[B2_ID_OPTION];
if (options.ContainsKey(B2_KEY_OPTION))
accountKey = options[B2_KEY_OPTION];
if (!string.IsNullOrEmpty(uri.Username))
accountId = uri.Username;
if (!string.IsNullOrEmpty(uri.Password))
accountKey = uri.Password;
if (string.IsNullOrEmpty(accountId))
throw new Exception(Strings.B2.NoB2UserIDError);
if (string.IsNullOrEmpty(accountKey))
throw new Exception(Strings.B2.NoB2KeyError);
m_helper = new B2AuthHelper(accountId, accountKey);
}
public B2(string url, Dictionary<string, string> options)
{
var uri = new Utility.Uri(url);
m_bucketname = uri.Host;
m_prefix = "/" + uri.Path;
if (!m_prefix.EndsWith("/"))
m_prefix += "/";
// For B2 we do not use a leading slash
while(m_prefix.StartsWith("/"))
m_prefix = m_prefix.Substring(1);
m_urlencodedprefix = string.Join("/", m_prefix.Split(new [] { '/' }).Select(x => Library.Utility.Uri.UrlPathEncode(x)));
m_bucketType = DEFAULT_BUCKET_TYPE;
if (options.ContainsKey(B2_CREATE_BUCKET_TYPE_OPTION))
m_bucketType = options[B2_CREATE_BUCKET_TYPE_OPTION];
string accountId = null;
string accountKey = null;
if (options.ContainsKey("auth-username"))
accountId = options["auth-username"];
if (options.ContainsKey("auth-password"))
accountKey = options["auth-password"];
if (options.ContainsKey(B2_ID_OPTION))
accountId = options[B2_ID_OPTION];
if (options.ContainsKey(B2_KEY_OPTION))
accountKey = options[B2_KEY_OPTION];
if (!string.IsNullOrEmpty(uri.Username))
accountId = uri.Username;
if (!string.IsNullOrEmpty(uri.Password))
accountKey = uri.Password;
if (string.IsNullOrEmpty(accountId))
throw new UserInformationException(Strings.B2.NoB2UserIDError);
if (string.IsNullOrEmpty(accountKey))
throw new UserInformationException(Strings.B2.NoB2KeyError);
m_helper = new B2AuthHelper(accountId, accountKey);
}
public COS(string url, Dictionary <string, string> options)
{
_cosOptions = new CosOptions();
var uri = new Utility.Uri(url?.Trim());
var prefix = uri.HostAndPath?.Trim()?.Trim('/')?.Trim('\\');
if (!string.IsNullOrEmpty(prefix))
{
_cosOptions.Path = prefix + "/";
}
if (options.ContainsKey(COS_APP_ID))
{
_cosOptions.Appid = options[COS_APP_ID];
}
if (options.ContainsKey(COS_REGION))
{
_cosOptions.Region = options[COS_REGION];
}
if (options.ContainsKey(COS_SECRET_ID))
{
_cosOptions.SecretId = options[COS_SECRET_ID];
}
if (options.ContainsKey(COS_SECRET_KEY))
{
_cosOptions.SecretKey = options[COS_SECRET_KEY];
}
if (options.ContainsKey(COS_BUCKET))
{
_cosOptions.Bucket = options[COS_BUCKET];
}
if (options.ContainsKey(COS_STORAGE_CLASS))
{
_cosOptions.StorageClass = options[COS_STORAGE_CLASS];
}
}
public OneDrive(string url, Dictionary <string, string> options)
{
var uri = new Utility.Uri(url);
m_rootfolder = uri.Host;
m_prefix = "/" + uri.Path;
if (!m_prefix.EndsWith("/"))
{
m_prefix += "/";
}
string authid = null;
if (options.ContainsKey(AUTHID_OPTION))
{
authid = options[AUTHID_OPTION];
}
m_oauth = new OAuthHelper(authid, this.ProtocolKey);
}
public TahoeBackend(string url, Dictionary <string, string> options)
{
//Validate URL
var u = new Utility.Uri(url);
u.RequireHost();
if (!u.Path.StartsWith("uri/URI:DIR2:") && !u.Path.StartsWith("uri/URI%3ADIR2%3A"))
{
throw new UserInformationException(Strings.TahoeBackend.UnrecognizedUriError);
}
m_useSSL = Utility.Utility.ParseBoolOption(options, "use-ssl");
m_url = u.SetScheme(m_useSSL ? "https" : "http").SetQuery(null).SetCredentials(null, null).ToString();
if (!m_url.EndsWith("/"))
{
m_url += "/";
}
}
public BoxBackend(string url, Dictionary <string, string> options)
{
var uri = new Utility.Uri(url);
m_path = uri.HostAndPath;
if (!m_path.EndsWith("/"))
{
m_path += "/";
}
string authid = null;
if (options.ContainsKey(AUTHID_OPTION))
{
authid = options[AUTHID_OPTION];
}
m_deleteFromTrash = Library.Utility.Utility.ParseBoolOption(options, REALLY_DELETE_OPTION);
m_oauth = new BoxHelper(authid);
}
public MegaBackend(string url, Dictionary<string, string> options)
{
var uri = new Utility.Uri(url);
if (options.ContainsKey("auth-username"))
m_username = options["auth-username"];
if (options.ContainsKey("auth-password"))
m_password = options["auth-password"];
if (!string.IsNullOrEmpty(uri.Username))
m_username = uri.Username;
if (!string.IsNullOrEmpty(uri.Password))
m_password = uri.Password;
if (string.IsNullOrEmpty(m_username))
throw new Exception(Strings.MegaBackend.NoUsernameError);
if (string.IsNullOrEmpty(m_password))
throw new Exception(Strings.MegaBackend.NoPasswordError);
m_prefix = uri.HostAndPath ?? "";
}
public SkyDrive(string url, Dictionary <string, string> options)
{
var uri = new Utility.Uri(url);
m_rootfolder = uri.Host;
m_prefix = "/" + uri.Path;
if (!m_prefix.EndsWith("/"))
{
m_prefix += "/";
}
if (options.ContainsKey(AUTHID_OPTION))
{
m_authid = options[AUTHID_OPTION];
}
if (string.IsNullOrEmpty(m_authid))
{
throw new Exception(string.Format(LC.L("You need an AuthID, you can get it from: {0}"), WLID_LOGIN));
}
}
public SkyDrive(string url, Dictionary <string, string> options)
{
var uri = new Utility.Uri(url);
m_rootfolder = uri.Host;
m_prefix = "/" + uri.Path;
if (!m_prefix.EndsWith("/"))
{
m_prefix += "/";
}
if (options.ContainsKey(AUTHID_OPTION))
{
m_authid = options[AUTHID_OPTION];
}
if (string.IsNullOrEmpty(m_authid))
{
throw new Exception(Strings.OneDrive.MissingAuthID(WLID_LOGIN));
}
}
public Dropbox(string url, Dictionary <string, string> options)
{
var uri = new Utility.Uri(url);
m_path = Library.Utility.Uri.UrlDecode(uri.HostAndPath);
if (m_path.Length != 0 && !m_path.StartsWith("/"))
{
m_path = "/" + m_path;
}
if (m_path.EndsWith("/"))
{
m_path = m_path.Substring(0, m_path.Length - 1);
}
if (options.ContainsKey(AUTHID_OPTION))
{
m_accesToken = options[AUTHID_OPTION];
}
dbx = new DropboxHelper(m_accesToken);
}
public GoogleDocs(string url, Dictionary<string, string> options)
{
var uri = new Utility.Uri(url);
m_folder = uri.HostAndPath;
if (m_folder.EndsWith("/"))
m_folder = m_folder.Substring(0, m_folder.Length - 1);
string username = null;
string password = null;
if (options.ContainsKey("auth-username"))
username = options["auth-username"];
if (options.ContainsKey("auth-password"))
password = options["auth-password"];
if (options.ContainsKey(USERNAME_OPTION))
username = options[USERNAME_OPTION];
if (options.ContainsKey(PASSWORD_OPTION))
password = options[PASSWORD_OPTION];
if (!string.IsNullOrEmpty(uri.Username))
username = uri.Username;
if (!string.IsNullOrEmpty(uri.Password))
password = uri.Password;
string labels;
if (!options.TryGetValue(ATTRIBUTES_OPTION, out labels))
labels = DEFAULT_LABELS;
m_labels = (labels ?? "").Split(new string[] {","}, StringSplitOptions.RemoveEmptyEntries);
if (string.IsNullOrEmpty(username))
throw new Exception(Strings.GoogleDocs.MissingUsernameError);
if (string.IsNullOrEmpty(password))
throw new Exception(Strings.GoogleDocs.MissingPasswordError);
m_cla = new Google.GData.Client.ClientLoginAuthenticator(USER_AGENT, Google.GData.Client.ServiceNames.Documents, username, password);
m_settings = new Google.GData.Client.RequestSettings(USER_AGENT, username, password);
m_settings.AutoPaging = true;
}
public GoogleDrive(string url, Dictionary <string, string> options)
{
var uri = new Utility.Uri(url);
m_path = uri.HostAndPath;
if (!m_path.EndsWith("/"))
{
m_path += "/";
}
string authid = null;
if (options.ContainsKey(AUTHID_OPTION))
{
authid = options[AUTHID_OPTION];
}
m_oauth = new OAuthHelper(authid, this.ProtocolKey)
{
AutoAuthHeader = true
};
m_filecache = new Dictionary <string, string>();
}
public S3(string url, Dictionary<string, string> options)
{
var uri = new Utility.Uri(url);
uri.RequireHost();
string host = uri.Host;
m_prefix = uri.Path;
string awsID = null;
string awsKey = null;
if (options.ContainsKey("auth-username"))
awsID = options["auth-username"];
if (options.ContainsKey("auth-password"))
awsKey = options["auth-password"];
if (options.ContainsKey("aws_access_key_id"))
awsID = options["aws_access_key_id"];
if (options.ContainsKey("aws_secret_access_key"))
awsKey = options["aws_secret_access_key"];
if (!string.IsNullOrEmpty(uri.Username))
awsID = uri.Username;
if (!string.IsNullOrEmpty(uri.Password))
awsKey = uri.Password;
if (string.IsNullOrEmpty(awsID))
throw new Exception(Strings.S3Backend.NoAMZUserIDError);
if (string.IsNullOrEmpty(awsKey))
throw new Exception(Strings.S3Backend.NoAMZKeyError);
bool euBuckets = Utility.Utility.ParseBoolOption(options, EU_BUCKETS_OPTION);
bool useRRS = Utility.Utility.ParseBoolOption(options, RRS_OPTION);
bool useSSL = Utility.Utility.ParseBoolOption(options, SSL_OPTION);
string locationConstraint;
options.TryGetValue(LOCATION_OPTION, out locationConstraint);
if (!string.IsNullOrEmpty(locationConstraint) && euBuckets)
throw new Exception(string.Format(Strings.S3Backend.OptionsAreMutuallyExclusiveError, LOCATION_OPTION, EU_BUCKETS_OPTION));
if (euBuckets)
locationConstraint = S3_EU_REGION_NAME;
string s3host;
options.TryGetValue(SERVER_NAME, out s3host);
if (string.IsNullOrEmpty(s3host))
{
s3host = DEFAULT_S3_HOST;
//Change in S3, now requires that you use location specific endpoint
if (!string.IsNullOrEmpty(locationConstraint))
foreach(KeyValuePair<string, string> kvp in DEFAULT_S3_LOCATION_BASED_HOSTS)
if (kvp.Key.Equals(locationConstraint, StringComparison.InvariantCultureIgnoreCase))
{
s3host = kvp.Value;
break;
}
}
//Fallback to previous formats
if (host.Contains(DEFAULT_S3_HOST))
{
Uri u = new Uri(url);
host = u.Host;
m_prefix = "";
if (host.ToLower() == s3host)
{
m_bucket = System.Web.HttpUtility.UrlDecode(u.PathAndQuery);
if (m_bucket.StartsWith("/"))
m_bucket = m_bucket.Substring(1);
if (m_bucket.Contains("/"))
{
m_prefix = m_bucket.Substring(m_bucket.IndexOf("/") + 1);
m_bucket = m_bucket.Substring(0, m_bucket.IndexOf("/"));
}
}
else
{
//Subdomain type lookup
if (host.ToLower().EndsWith("." + s3host))
{
m_bucket = host.Substring(0, host.Length - ("." + s3host).Length);
host = s3host;
m_prefix = System.Web.HttpUtility.UrlDecode(u.PathAndQuery);
if (m_prefix.StartsWith("/"))
m_prefix = m_prefix.Substring(1);
}
else
throw new Exception(string.Format(Strings.S3Backend.UnableToDecodeBucketnameError, url));
}
try { Console.Error.WriteLine(string.Format(Strings.S3Backend.DeprecatedUrlFormat, "s3://" + m_bucket + "/" + m_prefix)); }
catch { }
}
else
{
//The new simplified url style s3://bucket/prefix
m_bucket = host;
host = s3host;
}
m_options = options;
m_prefix = m_prefix.Trim();
if (m_prefix.Length != 0 && !m_prefix.EndsWith("/"))
m_prefix += "/";
m_wrapper = new S3Wrapper(awsID, awsKey, locationConstraint, host, useRRS, useSSL);
}
/// <summary>
/// SharePoint has nested subwebs but sometimes different webs
/// are hooked into a sub path.
/// For finding files SharePoint is picky to use the correct
/// path to the web, so we will trial and error here.
/// The user can give us a hint by supplying an URI with a double
/// slash to separate web.
/// Otherwise it's a good guess to look for "/documents", as we expect
/// that the default document library is used in the path.
/// If that won't help, we will try all possible pathes from longest
/// to shortest...
/// </summary>
private static string findCorrectWebPath(Utility.Uri orgUrl, System.Net.ICredentials userInfo, out SP.ClientContext retCtx)
{
retCtx = null;
string path = orgUrl.Path;
int webIndicatorPos = path.IndexOf("//");
// if a hint is supplied, we will of course use this first.
if (webIndicatorPos >= 0)
{
string testUrl = new Utility.Uri(orgUrl.Scheme, orgUrl.Host, path.Substring(0, webIndicatorPos), null, null, null, orgUrl.Port).ToString();
if (testUrlForWeb(testUrl, userInfo, false, out retCtx) >= 0)
return testUrl;
}
// Now go through path and see where we land a success.
string[] pathParts = path.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
// first we look for the doc library
int docLibrary = Array.FindIndex(pathParts, p => StringComparer.InvariantCultureIgnoreCase.Equals(p, "documents"));
if (docLibrary >= 0)
{
string testUrl = new Utility.Uri(orgUrl.Scheme, orgUrl.Host,
string.Join("/", pathParts, 0, docLibrary),
null, null, null, orgUrl.Port).ToString();
if (testUrlForWeb(testUrl, userInfo, false, out retCtx) >= 0)
return testUrl;
}
// last but not least: try one after the other.
for (int pi = pathParts.Length - 1; pi >= 0; pi--)
{
if (pi == docLibrary) continue; // already tested
string testUrl = new Utility.Uri(orgUrl.Scheme, orgUrl.Host,
string.Join("/", pathParts, 0, pi),
null, null, null, orgUrl.Port).ToString();
if (testUrlForWeb(testUrl, userInfo, false, out retCtx) >= 0)
return testUrl;
}
// nothing worked :(
return null;
}
using Duplicati.Library.Backend.GoogleServices;
public OpenStackStorage(string url, Dictionary<string, string> options)
{
var uri = new Utility.Uri(url);
m_container = uri.Host;
m_prefix = "/" + uri.Path;
if (!m_prefix.EndsWith("/"))
m_prefix += "/";
// For OpenStack we do not use a leading slash
if (m_prefix.StartsWith("/"))
m_prefix = m_prefix.Substring(1);
options.TryGetValue(USERNAME_OPTION, out m_username);
options.TryGetValue(PASSWORD_OPTION, out m_password);
options.TryGetValue(TENANTNAME_OPTION, out m_tenantName);
options.TryGetValue(AUTHURI_OPTION, out m_authUri);
options.TryGetValue(APIKEY_OPTION, out m_apikey);
options.TryGetValue(REGION_OPTION, out m_region);
if (string.IsNullOrWhiteSpace(m_username))
throw new Exception(Strings.OpenStack.MissingOptionError(USERNAME_OPTION));
if (string.IsNullOrWhiteSpace(m_authUri))
throw new Exception(Strings.OpenStack.MissingOptionError(AUTHURI_OPTION));
if (string.IsNullOrWhiteSpace(m_apikey))
{
if (string.IsNullOrWhiteSpace(m_password))
throw new Exception(Strings.OpenStack.MissingOptionError(PASSWORD_OPTION));
if (string.IsNullOrWhiteSpace(m_tenantName))
throw new Exception(Strings.OpenStack.MissingOptionError(TENANTNAME_OPTION));
}
m_helper = new WebHelper(this);
}
using Newtonsoft.Json; using Duplicati.Library.Backend.GoogleServices;
public File(string url, Dictionary<string, string> options)
{
var uri = new Utility.Uri(url);
m_path = uri.HostAndPath;
if (options.ContainsKey("auth-username"))
m_username = options["auth-username"];
if (options.ContainsKey("auth-password"))
m_password = options["auth-password"];
if (!string.IsNullOrEmpty(uri.Username))
m_username = uri.Username;
if (!string.IsNullOrEmpty(uri.Password))
m_password = uri.Password;
if (!System.IO.Path.IsPathRooted(m_path))
m_path = System.IO.Path.GetFullPath(m_path);
if (options.ContainsKey(OPTION_ALTERNATE_PATHS))
{
List<string> paths = new List<string>();
paths.Add(m_path);
paths.AddRange(options[OPTION_ALTERNATE_PATHS].Split(new string[] { System.IO.Path.PathSeparator.ToString() }, StringSplitOptions.RemoveEmptyEntries));
//On windows we expand the drive letter * to all drives
if (!Utility.Utility.IsClientLinux)
{
System.IO.DriveInfo[] drives = System.IO.DriveInfo.GetDrives();
for (int i = 0; i < paths.Count; i++)
{
if (paths[i].StartsWith("*:"))
{
string rpl_path = paths[i].Substring(1);
paths.RemoveAt(i);
i--;
foreach (System.IO.DriveInfo di in drives)
paths.Insert(++i, di.Name[0] + rpl_path);
}
}
}
string markerfile = null;
//If there is a marker file, we do not allow the primary target path
// to be accepted, unless it contains the marker file
if (options.ContainsKey(OPTION_DESTINATION_MARKER))
{
markerfile = options[OPTION_DESTINATION_MARKER];
m_path = null;
}
foreach (string p in paths)
{
try
{
if (System.IO.Directory.Exists(p) && (markerfile == null || System.IO.File.Exists(System.IO.Path.Combine(p, markerfile))))
{
m_path = p;
break;
}
}
catch
{
}
}
if (m_path == null)
throw new Exception(Strings.FileBackend.NoDestinationWithMarkerFileError(markerfile, paths.ToArray()));
}
m_moveFile = Utility.Utility.ParseBoolOption(options, OPTION_MOVE_FILE);
m_forceReauth = Utility.Utility.ParseBoolOption(options, OPTION_FORCE_REAUTH);
m_hasAutenticated = false;
}
private void doCreateFolder(bool useNewContext)
{
SP.ClientContext ctx = getSpClientContext(useNewContext);
try
{
int pathLengthToWeb = new Utility.Uri(m_spWebUrl).Path.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries).Length;
string[] folderNames = m_serverRelPath.Substring(0, m_serverRelPath.Length - 1).Split('/');
folderNames = Array.ConvertAll(folderNames, fold => System.Net.WebUtility.UrlDecode(fold));
var spfolders = new SP.Folder[folderNames.Length];
string folderRelPath = "";
int fi = 0;
for (; fi < folderNames.Length; fi++)
{
folderRelPath += System.Web.HttpUtility.UrlPathEncode(folderNames[fi]) + "/";
if (fi < pathLengthToWeb) continue;
var folder = ctx.Web.GetFolderByServerRelativeUrl(folderRelPath);
spfolders[fi] = folder;
ctx.Load(folder, f => f.Exists);
try { wrappedExecuteQueryOnConext(ctx, folderRelPath, true); }
catch (FolderMissingException)
{ break; }
if (!folder.Exists) break;
}
for (; fi < folderNames.Length; fi++)
spfolders[fi] = spfolders[fi - 1].Folders.Add(folderNames[fi]);
ctx.Load(spfolders[folderNames.Length - 1], f => f.Exists);
wrappedExecuteQueryOnConext(ctx, m_serverRelPath, true);
if (!spfolders[folderNames.Length - 1].Exists)
throw new Interface.FolderMissingException(Strings.SharePoint.MissingElementError(m_serverRelPath, m_spWebUrl));
}
catch (ServerException) { throw; /* rethrow if Server answered */ }
catch (Interface.FileMissingException) { throw; }
catch (Interface.FolderMissingException) { throw; }
catch { if (!useNewContext) /* retry */ doCreateFolder(true); else throw; }
finally { }
}
public BoxBackend(string url, Dictionary<string, string> options)
{
var uri = new Utility.Uri(url);
m_path = uri.HostAndPath;
if (!m_path.EndsWith("/"))
m_path += "/";
string authid = null;
if (options.ContainsKey(AUTHID_OPTION))
authid = options[AUTHID_OPTION];
m_deleteFromTrash = Library.Utility.Utility.ParseBoolOption(options, REALLY_DELETE_OPTION);
m_oauth = new BoxHelper(authid);
}
public CloudFiles(string url, Dictionary<string, string> options)
{
var uri = new Utility.Uri(url);
if (options.ContainsKey("auth-username"))
m_username = options["auth-username"];
if (options.ContainsKey("auth-password"))
m_password = options["auth-password"];
if (options.ContainsKey("cloudfiles-username"))
m_username = options["cloudfiles-username"];
if (options.ContainsKey("cloudfiles-accesskey"))
m_password = options["cloudfiles-accesskey"];
if (!string.IsNullOrEmpty(uri.Username))
m_username = uri.Username;
if (!string.IsNullOrEmpty(uri.Password))
m_password = uri.Password;
if (string.IsNullOrEmpty(m_username))
throw new Exception(Strings.CloudFiles.NoUserIDError);
if (string.IsNullOrEmpty(m_password))
throw new Exception(Strings.CloudFiles.NoAPIKeyError);
//Fallback to the previous format
if (url.Contains(DUMMY_HOSTNAME))
{
Uri u = new Uri(url);
if (!string.IsNullOrEmpty(u.UserInfo))
{
if (u.UserInfo.IndexOf(":") >= 0)
{
m_username = u.UserInfo.Substring(0, u.UserInfo.IndexOf(":"));
m_password = u.UserInfo.Substring(u.UserInfo.IndexOf(":") + 1);
}
else
{
m_username = u.UserInfo;
}
}
//We use the api.mosso.com hostname.
//This allows the use of containers that have names that are not valid hostnames,
// such as container names with spaces in them
if (u.Host.Equals(DUMMY_HOSTNAME))
m_path = System.Web.HttpUtility.UrlDecode(u.PathAndQuery);
else
m_path = u.Host + System.Web.HttpUtility.UrlDecode(u.PathAndQuery);
}
else
{
m_path = uri.HostAndPath;
}
if (m_path.EndsWith("/"))
m_path = m_path.Substring(0, m_path.Length - 1);
if (!m_path.StartsWith("/"))
m_path = "/" + m_path;
if (!options.TryGetValue("cloudfiles-authentication-url", out m_authUrl))
m_authUrl = Utility.Utility.ParseBoolOption(options, "cloudfiles-uk-account") ? AUTH_URL_UK : AUTH_URL_US;
}
public IDictionary<string, string> Execute(IDictionary<string, string> options)
{
var res = new Dictionary<string, string>();
string url;
string pubkey_s;
options.TryGetValue(OPTION_URL, out url);
options.TryGetValue(OPTION_KEY, out pubkey_s);
if (string.IsNullOrWhiteSpace(url))
throw new ArgumentException(OPTION_URL);
if (string.IsNullOrWhiteSpace(pubkey_s))
throw new ArgumentException(OPTION_KEY);
var uri = new Utility.Uri(url);
foreach(var key in uri.QueryParameters.AllKeys)
options[key] = uri.QueryParameters[key];
pubkey_s = pubkey_s.Trim();
var pubkey = pubkey_s.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Select(x => x.Trim()).Where(x => x.Length > 0).ToArray();
if (pubkey.Length != 3)
throw new ArgumentException(OPTION_KEY);
using(var connection = new SSHv2(url, (Dictionary<string, string>)options))
{
var client = connection.Client;
try
{
client.ChangeDirectory(SSH_FOLDER);
}
catch
{
client.CreateDirectory(SSH_FOLDER);
client.ChangePermissions(SSH_FOLDER, SSH_FOLDER_PERMISSIONS);
client.ChangeDirectory(SSH_FOLDER);
}
var sshfolder = client.ListDirectory(".").Where(x => x.Name == ".").First();
client.ChangeDirectory("..");
if (!sshfolder.OwnerCanRead || !sshfolder.OwnerCanWrite)
client.ChangePermissions(SSH_FOLDER, SSH_FOLDER_PERMISSIONS);
string authorized_keys = "";
byte[] authorized_keys_bytes = null;
var existing_authorized_keys = client.ListDirectory(SSH_FOLDER).Where(x => x.Name == AUTHORIZED_KEYS_FILE).Any();
if (existing_authorized_keys)
{
using(var ms = new System.IO.MemoryStream())
{
client.DownloadFile(AUTHORIZED_KEYS_PATH, ms);
authorized_keys_bytes = ms.ToArray();
authorized_keys = System.Text.Encoding.ASCII.GetString(authorized_keys_bytes);
}
}
var keys = authorized_keys == null ? new string[0] : authorized_keys.Split(new char[] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
var cleaned_keys = keys.Select(x => x.Trim()).Where(x => x.Length > 0 && !x.StartsWith("#"));
// Does the key already exist?
if (cleaned_keys.Where(x =>
{
var els = x.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Select(y => y.Trim()).Where(y => y.Length > 0).ToArray();
return els.Length == 3 && els[0] == pubkey[0] && els[1] == pubkey[1];
}).Any())
{
res["status"] = "Key already existed";
}
else
{
var new_file = authorized_keys;
if (new_file.Trim().Length > 0)
new_file = authorized_keys.Trim() + "\n";
new_file += string.Join(" ", pubkey) + "\n";
if (existing_authorized_keys)
{
var filename = AUTHORIZED_KEYS_PATH + ".backup-" + DateTime.UtcNow.ToString("yyyyMMddThhmmss");
using(var ms = new System.IO.MemoryStream(authorized_keys_bytes))
client.UploadFile(ms, filename);
client.ChangePermissions(filename, AUTHORIZED_KEYS_BACKUP_PERMISSIONS);
}
using(var ms = new System.IO.MemoryStream(System.Text.Encoding.ASCII.GetBytes(new_file)))
client.UploadFile(ms, AUTHORIZED_KEYS_PATH);
if (!existing_authorized_keys)
client.ChangePermissions(AUTHORIZED_KEYS_PATH, AUTHORIZED_KEYS_PERMISSIONS);
res["status"] = "Key updated";
}
}
return res;
}
public SharePointBackend(string url, Dictionary<string, string> options)
{
m_deleteToRecycler = Utility.Utility.ParseBoolOption(options, "delete-to-recycler");
m_useBinaryDirectMode = Utility.Utility.ParseBoolOption(options, "binary-direct-mode");
try
{
string strSpan;
if (options.TryGetValue("web-timeout", out strSpan))
{
TimeSpan ts = Timeparser.ParseTimeSpan(strSpan);
if (ts.TotalMilliseconds > 30000 && ts.TotalMilliseconds < int.MaxValue)
this.m_useContextTimeoutMs = (int)ts.TotalMilliseconds;
}
}
catch { }
try
{
string strChunkSize;
if (options.TryGetValue("chunk-size", out strChunkSize))
{
long pSize = Utility.Sizeparser.ParseSize(strChunkSize, "MB");
if (pSize >= (1 << 14) && pSize <= (1 << 30)) // [16kb .. 1GB]
this.m_fileChunkSize = (int)pSize;
}
}
catch { }
var u = new Utility.Uri(url);
u.RequireHost();
// Create sanitized plain https-URI (note: still has double slashes for processing web)
m_orgUrl = new Utility.Uri("https", u.Host, u.Path, null, null, null, u.Port);
// Actual path to Web will be searched for on first use. Ctor should not throw.
m_spWebUrl = null;
m_serverRelPath = u.Path;
if (!m_serverRelPath.StartsWith("/"))
m_serverRelPath = "/" + m_serverRelPath;
if (!m_serverRelPath.EndsWith("/"))
m_serverRelPath += "/";
// remove marker for SP-Web
m_serverRelPath = m_serverRelPath.Replace("//", "/");
// Authentication settings processing:
// Default: try integrated auth (will normally not work for Office365, but maybe with on-prem SharePoint...).
// Otherwise: Use settings from URL(precedence) or from command line options.
bool useIntegratedAuthentication = Utility.Utility.ParseBoolOption(options, "integrated-authentication");
string useUsername = null;
string usePassword = null;
if (!useIntegratedAuthentication)
{
if (!string.IsNullOrEmpty(u.Username))
{
useUsername = u.Username;
if (!string.IsNullOrEmpty(u.Password))
usePassword = u.Password;
else if (options.ContainsKey("auth-password"))
usePassword = options["auth-password"];
}
else
{
if (options.ContainsKey("auth-username"))
{
useUsername = options["auth-username"];
if (options.ContainsKey("auth-password"))
usePassword = options["auth-password"];
}
}
}
if (useIntegratedAuthentication || (useUsername == null || usePassword == null))
{
// This might or might not work for on-premises SP. Maybe support if someone complains...
m_userInfo = System.Net.CredentialCache.DefaultNetworkCredentials;
}
else
{
System.Security.SecureString securePwd = new System.Security.SecureString();
usePassword.ToList().ForEach(c => securePwd.AppendChar(c));
m_userInfo = new Microsoft.SharePoint.Client.SharePointOnlineCredentials(useUsername, securePwd);
// Other options (also ADAL, see class remarks) might be supported on request.
// Maybe go in deep then and also look at:
// - Microsoft.SharePoint.Client.AppPrincipalCredential.CreateFromKeyGroup()
// - ctx.AuthenticationMode = SP.ClientAuthenticationMode.FormsAuthentication;
// - ctx.FormsAuthenticationLoginInfo = new SP.FormsAuthenticationLoginInfo(user, pwd);
}
}
