// Copyright © 2014 The CefSharp Authors. All rights reserved.
|
//
|
// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
|
|
using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using CefSharp.Enums;
|
using CefSharp.Internals;
|
|
namespace CefSharp
|
{
|
/// <summary>
|
/// Used in conjunction with CefSettings.RegisterScheme to register a scheme.
|
/// You can register your own custom scheme e.g. custom:// if you are using a build in scheme
|
/// (http/https) then you should directly register your <see cref="ISchemeHandlerFactory"/> using
|
/// Cef.GetGlobalRequestContext().RegisterSchemeHandlerFactory - make sure the Global RequestContext has
|
/// been initialized before doing so, you can use <see cref="IBrowserProcessHandler.OnContextInitialized"/>
|
/// for notification of RequestContext initialization (Pass an IBrowserProcessHandler instance to Cef.Initialize)
|
/// </summary>
|
public sealed class CefCustomScheme
|
{
|
private SchemeOptions schemeOptions;
|
|
/// <summary>
|
/// Schema Name e.g. custom
|
/// </summary>
|
public string SchemeName { get; set; }
|
|
/// <summary>
|
/// Optional Domain Name. An empty value for a standard scheme
|
/// will cause the factory to match all domain names. The |domain_name| value
|
/// will be ignored for non-standard schemes.
|
/// </summary>
|
public string DomainName { get; set; }
|
|
/// <summary>
|
/// If true the scheme will be treated as a standard scheme.
|
/// Standard schemes are subject to URL canonicalization and parsing rules as
|
/// defined in the Common Internet Scheme Syntax RFC 1738 Section 3.1 available
|
/// at http://www.ietf.org/rfc/rfc1738.txt
|
///
|
/// In particular, the syntax for standard scheme URLs must be of the form:
|
/// <pre>
|
/// [scheme]://[username]:[password]@[host]:[port]/[url-path]
|
/// </pre>
|
/// Standard scheme URLs must have a host component that is a fully qualified
|
/// domain name as defined in Section 3.5 of RFC 1034 [13] and Section 2.1 of
|
/// RFC 1123. These URLs will be canonicalized to "scheme://host/path" in the
|
/// simplest case and "scheme://username:password@host:port/path" in the most
|
/// explicit case. For example, "scheme:host/path" and "scheme:///host/path"
|
/// will both be canonicalized to "scheme://host/path". The origin of a
|
/// standard scheme URL is the combination of scheme, host and port (i.e.,
|
/// "scheme://host:port" in the most explicit case).
|
///
|
/// For non-standard scheme URLs only the "scheme:" component is parsed and
|
/// canonicalized. The remainder of the URL will be passed to the handler
|
/// as-is. For example, "scheme:///some%20text" will remain the same.
|
/// Non-standard scheme URLs cannot be used as a target for form submission.
|
/// </summary>
|
public bool IsStandard
|
{
|
get { return schemeOptions.HasFlag(SchemeOptions.Standard); }
|
set
|
{
|
if (value)
|
{
|
schemeOptions |= SchemeOptions.Standard;
|
}
|
else
|
{
|
schemeOptions &= ~SchemeOptions.Standard;
|
}
|
}
|
}
|
|
/// <summary>
|
/// If true the scheme will be treated as local (i.e. with the
|
/// same security rules as those applied to "file" URLs). Normal pages cannot
|
/// link to or access local URLs. Also, by default, local URLs can only perform
|
/// XMLHttpRequest calls to the same URL (origin + path) that originated the
|
/// request. To allow XMLHttpRequest calls from a local URL to other URLs with
|
/// the same origin set the CefSettings.file_access_from_file_urls_allowed
|
/// value to true. To allow XMLHttpRequest calls from a local URL to all
|
/// origins set the CefSettings.universal_access_from_file_urls_allowed value
|
/// to true.
|
/// </summary>
|
public bool IsLocal
|
{
|
get { return schemeOptions.HasFlag(SchemeOptions.Local); }
|
set
|
{
|
if (value)
|
{
|
schemeOptions |= SchemeOptions.Local;
|
}
|
else
|
{
|
schemeOptions &= ~SchemeOptions.Local;
|
}
|
}
|
}
|
|
/// <summary>
|
/// If true the scheme will be treated as display-isolated.
|
/// This means that pages cannot display these URLs unless they are
|
/// from the same scheme. For example, pages in another origin cannot create
|
/// iframes or hyperlinks to URLs with this scheme.
|
/// </summary>
|
public bool IsDisplayIsolated
|
{
|
get { return schemeOptions.HasFlag(SchemeOptions.DisplayIsolated); }
|
set
|
{
|
if (value)
|
{
|
schemeOptions |= SchemeOptions.DisplayIsolated;
|
}
|
else
|
{
|
schemeOptions &= ~SchemeOptions.DisplayIsolated;
|
}
|
}
|
}
|
|
/// <summary>
|
/// If true the scheme will be treated with the same security
|
/// rules as those applied to "https" URLs. For example, loading this scheme
|
/// from other secure schemes will not trigger mixed content warnings.
|
/// </summary>
|
public bool IsSecure
|
{
|
get { return schemeOptions.HasFlag(SchemeOptions.Secure); }
|
set
|
{
|
if (value)
|
{
|
schemeOptions |= SchemeOptions.Secure;
|
}
|
else
|
{
|
schemeOptions &= ~SchemeOptions.Secure;
|
}
|
}
|
}
|
|
/// <summary>
|
/// If true the scheme can be sent CORS requests.
|
/// This value should be true in most cases where IsStandard is true.
|
/// </summary>
|
public bool IsCorsEnabled
|
{
|
get { return schemeOptions.HasFlag(SchemeOptions.CorsEnabled); }
|
set
|
{
|
if (value)
|
{
|
schemeOptions |= SchemeOptions.CorsEnabled;
|
}
|
else
|
{
|
schemeOptions &= ~SchemeOptions.CorsEnabled;
|
}
|
}
|
}
|
|
/// <summary>
|
/// If true the scheme can bypass Content-Security-Policy(CSP) checks.
|
/// This value should be false in most cases where IsStandard is true.
|
/// </summary>
|
public bool IsCSPBypassing
|
{
|
get { return schemeOptions.HasFlag(SchemeOptions.CspBypassing); }
|
set
|
{
|
if (value)
|
{
|
schemeOptions |= SchemeOptions.CspBypassing;
|
}
|
else
|
{
|
schemeOptions &= ~SchemeOptions.CspBypassing;
|
}
|
}
|
}
|
|
/// <summary>
|
/// If true the scheme can perform Fetch API requests.
|
/// </summary>
|
public bool IsFetchEnabled
|
{
|
get { return schemeOptions.HasFlag(SchemeOptions.FetchEnabled); }
|
set
|
{
|
if (value)
|
{
|
schemeOptions |= SchemeOptions.FetchEnabled;
|
}
|
else
|
{
|
schemeOptions &= ~SchemeOptions.FetchEnabled;
|
}
|
}
|
}
|
|
/// <summary>
|
/// Factory Class that creates <see cref="IResourceHandler"/> instances
|
/// for handling scheme requests. Leave this null if you wish to manually register the
|
/// scheme handler with the relevant RequestContext.
|
/// </summary>
|
public ISchemeHandlerFactory SchemeHandlerFactory { get; set; }
|
|
/// <summary>
|
/// Gets the underlying scheme options that represents
|
/// </summary>
|
public SchemeOptions Options
|
{
|
get { return schemeOptions; }
|
}
|
|
/// <summary>
|
/// Creates a new CefCustomScheme.
|
/// </summary>
|
public CefCustomScheme()
|
{
|
schemeOptions = SchemeOptions.Standard | SchemeOptions.Secure | SchemeOptions.CorsEnabled;
|
}
|
|
/// <summary>
|
/// Creates a new CefCustomScheme.
|
/// </summary>
|
/// <param name="schemeName">scheme name</param>
|
/// <param name="options">scheme options</param>
|
public CefCustomScheme(string schemeName, SchemeOptions options)
|
{
|
SchemeName = schemeName;
|
schemeOptions = options;
|
}
|
|
/// <summary>
|
/// Method used internally
|
/// </summary>
|
/// <param name="args">command line arguments</param>
|
/// <returns>list of scheme objects</returns>
|
public static List<CefCustomScheme> ParseCommandLineArguments(IEnumerable<string> args)
|
{
|
var schemes = args.GetArgumentValue(CefSharpArguments.CustomSchemeArgument);
|
var customSchemes = new List<CefCustomScheme>();
|
|
if (!string.IsNullOrEmpty(schemes))
|
{
|
schemes.Split(';').ToList().ForEach(x =>
|
{
|
var tokens = x.Split('|');
|
var schemeName = tokens[0];
|
var schemeOptions = SchemeOptions.None;
|
|
Enum.TryParse(tokens[1], out schemeOptions);
|
|
var customScheme = new CefCustomScheme(schemeName, schemeOptions);
|
|
customSchemes.Add(customScheme);
|
});
|
}
|
|
return customSchemes;
|
}
|
}
|
}
|
