diff --git a/cef.gyp b/cef.gyp index dddfd4340..6023b3dbc 100644 --- a/cef.gyp +++ b/cef.gyp @@ -994,6 +994,10 @@ 'libcef/browser/software_output_device_osr.h', 'libcef/browser/speech_recognition_manager_delegate.cc', 'libcef/browser/speech_recognition_manager_delegate.h', + 'libcef/browser/ssl_cert_principal_impl.cc', + 'libcef/browser/ssl_cert_principal_impl.h', + 'libcef/browser/ssl_info_impl.cc', + 'libcef/browser/ssl_info_impl.h', 'libcef/browser/stream_impl.cc', 'libcef/browser/stream_impl.h', 'libcef/browser/trace_impl.cc', diff --git a/cef_paths.gypi b/cef_paths.gypi index 62994f352..e3ba4f4a9 100644 --- a/cef_paths.gypi +++ b/cef_paths.gypi @@ -55,6 +55,7 @@ 'include/cef_resource_handler.h', 'include/cef_response.h', 'include/cef_scheme.h', + 'include/cef_ssl_info.h', 'include/cef_stream.h', 'include/cef_string_visitor.h', 'include/cef_task.h', @@ -111,6 +112,7 @@ 'include/capi/cef_resource_handler_capi.h', 'include/capi/cef_response_capi.h', 'include/capi/cef_scheme_capi.h', + 'include/capi/cef_ssl_info_capi.h', 'include/capi/cef_stream_capi.h', 'include/capi/cef_string_visitor_capi.h', 'include/capi/cef_task_capi.h', @@ -250,6 +252,10 @@ 'libcef_dll/cpptoc/response_cpptoc.h', 'libcef_dll/ctocpp/run_file_dialog_callback_ctocpp.cc', 'libcef_dll/ctocpp/run_file_dialog_callback_ctocpp.h', + 'libcef_dll/cpptoc/sslcert_principal_cpptoc.cc', + 'libcef_dll/cpptoc/sslcert_principal_cpptoc.h', + 'libcef_dll/cpptoc/sslinfo_cpptoc.cc', + 'libcef_dll/cpptoc/sslinfo_cpptoc.h', 'libcef_dll/ctocpp/scheme_handler_factory_ctocpp.cc', 'libcef_dll/ctocpp/scheme_handler_factory_ctocpp.h', 'libcef_dll/cpptoc/scheme_registrar_cpptoc.cc', @@ -422,6 +428,10 @@ 'libcef_dll/ctocpp/response_ctocpp.h', 'libcef_dll/cpptoc/run_file_dialog_callback_cpptoc.cc', 'libcef_dll/cpptoc/run_file_dialog_callback_cpptoc.h', + 'libcef_dll/ctocpp/sslcert_principal_ctocpp.cc', + 'libcef_dll/ctocpp/sslcert_principal_ctocpp.h', + 'libcef_dll/ctocpp/sslinfo_ctocpp.cc', + 'libcef_dll/ctocpp/sslinfo_ctocpp.h', 'libcef_dll/cpptoc/scheme_handler_factory_cpptoc.cc', 'libcef_dll/cpptoc/scheme_handler_factory_cpptoc.h', 'libcef_dll/ctocpp/scheme_registrar_ctocpp.cc', diff --git a/include/capi/cef_request_handler_capi.h b/include/capi/cef_request_handler_capi.h index cd0ed9369..72be00916 100644 --- a/include/capi/cef_request_handler_capi.h +++ b/include/capi/cef_request_handler_capi.h @@ -45,6 +45,7 @@ #include "include/capi/cef_request_capi.h" #include "include/capi/cef_resource_handler_capi.h" #include "include/capi/cef_response_capi.h" +#include "include/capi/cef_ssl_info_capi.h" #include "include/capi/cef_web_plugin_capi.h" #ifdef __cplusplus @@ -191,7 +192,8 @@ typedef struct _cef_request_handler_t { // be accepted without calling this function. /// int (CEF_CALLBACK *on_certificate_error)(struct _cef_request_handler_t* self, - cef_errorcode_t cert_error, const cef_string_t* request_url, + struct _cef_browser_t* browser, cef_errorcode_t cert_error, + const cef_string_t* request_url, struct _cef_sslinfo_t* ssl_info, struct _cef_allow_certificate_error_callback_t* callback); /// diff --git a/include/capi/cef_ssl_info_capi.h b/include/capi/cef_ssl_info_capi.h new file mode 100644 index 000000000..dd0e6a9ff --- /dev/null +++ b/include/capi/cef_ssl_info_capi.h @@ -0,0 +1,180 @@ +// Copyright (c) 2015 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_SSL_INFO_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_SSL_INFO_CAPI_H_ +#pragma once + +#include "include/capi/cef_base_capi.h" +#include "include/capi/cef_values_capi.h" + +#ifdef __cplusplus +extern "C" { +#endif + + +/// +// Structure representing the issuer or subject field of an X.509 certificate. +/// +typedef struct _cef_sslcert_principal_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Returns a name that can be used to represent the issuer. It tries in this + // order: CN, O and OU and returns the first non-NULL one found. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_display_name)( + struct _cef_sslcert_principal_t* self); + + /// + // Returns the common name. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_common_name)( + struct _cef_sslcert_principal_t* self); + + /// + // Returns the locality name. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_locality_name)( + struct _cef_sslcert_principal_t* self); + + /// + // Returns the state or province name. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_state_or_province_name)( + struct _cef_sslcert_principal_t* self); + + /// + // Returns the country name. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_country_name)( + struct _cef_sslcert_principal_t* self); + + /// + // Retrieve the list of street addresses. + /// + void (CEF_CALLBACK *get_street_addresses)( + struct _cef_sslcert_principal_t* self, cef_string_list_t addresses); + + /// + // Retrieve the list of organization names. + /// + void (CEF_CALLBACK *get_organization_names)( + struct _cef_sslcert_principal_t* self, cef_string_list_t names); + + /// + // Retrieve the list of organization unit names. + /// + void (CEF_CALLBACK *get_organization_unit_names)( + struct _cef_sslcert_principal_t* self, cef_string_list_t names); + + /// + // Retrieve the list of domain components. + /// + void (CEF_CALLBACK *get_domain_components)( + struct _cef_sslcert_principal_t* self, cef_string_list_t components); +} cef_sslcert_principal_t; + + +/// +// Structure representing SSL information. +/// +typedef struct _cef_sslinfo_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Returns the subject of the X.509 certificate. For HTTPS server certificates + // this represents the web server. The common name of the subject should + // match the host name of the web server. + /// + struct _cef_sslcert_principal_t* (CEF_CALLBACK *get_subject)( + struct _cef_sslinfo_t* self); + + /// + // Returns the issuer of the X.509 certificate. + /// + struct _cef_sslcert_principal_t* (CEF_CALLBACK *get_issuer)( + struct _cef_sslinfo_t* self); + + /// + // Returns the DER encoded serial number for the X.509 certificate. The value + // possibly includes a leading 00 byte. + /// + struct _cef_binary_value_t* (CEF_CALLBACK *get_serial_number)( + struct _cef_sslinfo_t* self); + + /// + // Returns the date before which the X.509 certificate is invalid. + // CefTime.GetTimeT() will return 0 if no date was specified. + /// + cef_time_t (CEF_CALLBACK *get_valid_start)(struct _cef_sslinfo_t* self); + + /// + // Returns the date after which the X.509 certificate is invalid. + // CefTime.GetTimeT() will return 0 if no date was specified. + /// + cef_time_t (CEF_CALLBACK *get_valid_expiry)(struct _cef_sslinfo_t* self); + + /// + // Returns the DER encoded data for the X.509 certificate. + /// + struct _cef_binary_value_t* (CEF_CALLBACK *get_derencoded)( + struct _cef_sslinfo_t* self); + + /// + // Returns the PEM encoded data for the X.509 certificate. + /// + struct _cef_binary_value_t* (CEF_CALLBACK *get_pemencoded)( + struct _cef_sslinfo_t* self); +} cef_sslinfo_t; + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_SSL_INFO_CAPI_H_ diff --git a/include/capi/cef_url_capi.h b/include/capi/cef_url_capi.h index a21896402..62a669d0b 100644 --- a/include/capi/cef_url_capi.h +++ b/include/capi/cef_url_capi.h @@ -75,6 +75,44 @@ CEF_EXPORT cef_string_userfree_t cef_get_mime_type( CEF_EXPORT void cef_get_extensions_for_mime_type(const cef_string_t* mime_type, cef_string_list_t extensions); +/// +// Encodes |data| as a base64 string. +/// +// The resulting string must be freed by calling cef_string_userfree_free(). +CEF_EXPORT cef_string_userfree_t cef_base64encode(const void* data, + size_t data_size); + +/// +// Decodes the base64 encoded string |data|. The returned value will be NULL if +// the decoding fails. +/// +CEF_EXPORT struct _cef_binary_value_t* cef_base64decode( + const cef_string_t* data); + +/// +// Escapes characters in |text| which are unsuitable for use as a query +// parameter value. Everything except alphanumerics and -_.!~*'() will be +// converted to "%XX". If |use_plus| is true (1) spaces will change to "+". The +// result is basically the same as encodeURIComponent in Javacript. +/// +// The resulting string must be freed by calling cef_string_userfree_free(). +CEF_EXPORT cef_string_userfree_t cef_uriencode(const cef_string_t* text, + int use_plus); + +/// +// Unescapes |text| and returns the result. Unescaping consists of looking for +// the exact pattern "%XX" where each X is a hex digit and converting to the +// character with the numerical value of those digits (e.g. "i%20=%203%3b" +// unescapes to "i = 3;"). If |convert_to_utf8| is true (1) this function will +// attempt to interpret the initial decoded result as UTF-8. If the result is +// convertable into UTF-8 it will be returned as converted. Otherwise the +// initial decoded result will be returned. The |unescape_rule| parameter +// supports further customization the decoding process. +/// +// The resulting string must be freed by calling cef_string_userfree_free(). +CEF_EXPORT cef_string_userfree_t cef_uridecode(const cef_string_t* text, + int convert_to_utf8, cef_uri_unescape_rule_t unescape_rule); + #ifdef __cplusplus } #endif diff --git a/include/cef_request_handler.h b/include/cef_request_handler.h index 0f434310b..12a99c8a8 100644 --- a/include/cef_request_handler.h +++ b/include/cef_request_handler.h @@ -45,6 +45,7 @@ #include "include/cef_resource_handler.h" #include "include/cef_response.h" #include "include/cef_request.h" +#include "include/cef_ssl_info.h" #include "include/cef_web_plugin.h" /// @@ -206,8 +207,10 @@ class CefRequestHandler : public virtual CefBase { /// /*--cef()--*/ virtual bool OnCertificateError( + CefRefPtr browser, cef_errorcode_t cert_error, const CefString& request_url, + CefRefPtr ssl_info, CefRefPtr callback) { return false; } diff --git a/include/cef_ssl_info.h b/include/cef_ssl_info.h new file mode 100644 index 000000000..213e1ee08 --- /dev/null +++ b/include/cef_ssl_info.h @@ -0,0 +1,162 @@ +// Copyright (c) 2015 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_SSL_INFO_H_ +#define CEF_INCLUDE_CEF_SSL_INFO_H_ +#pragma once + +#include + +#include "include/cef_base.h" +#include "include/cef_values.h" + +/// +// Class representing the issuer or subject field of an X.509 certificate. +/// +/*--cef(source=library)--*/ +class CefSSLCertPrincipal : public virtual CefBase { + public: + /// + // Returns a name that can be used to represent the issuer. It tries in this + // order: CN, O and OU and returns the first non-empty one found. + /// + /*--cef()--*/ + virtual CefString GetDisplayName() =0; + + /// + // Returns the common name. + /// + /*--cef()--*/ + virtual CefString GetCommonName() =0; + + /// + // Returns the locality name. + /// + /*--cef()--*/ + virtual CefString GetLocalityName() =0; + + /// + // Returns the state or province name. + /// + /*--cef()--*/ + virtual CefString GetStateOrProvinceName() =0; + + /// + // Returns the country name. + /// + /*--cef()--*/ + virtual CefString GetCountryName() =0; + + /// + // Retrieve the list of street addresses. + /// + /*--cef()--*/ + virtual void GetStreetAddresses(std::vector& addresses) =0; + + /// + // Retrieve the list of organization names. + /// + /*--cef()--*/ + virtual void GetOrganizationNames(std::vector& names) =0; + + /// + // Retrieve the list of organization unit names. + /// + /*--cef()--*/ + virtual void GetOrganizationUnitNames(std::vector& names) =0; + + /// + // Retrieve the list of domain components. + /// + /*--cef()--*/ + virtual void GetDomainComponents(std::vector& components) =0; +}; + +/// +// Class representing SSL information. +/// +/*--cef(source=library)--*/ +class CefSSLInfo : public virtual CefBase { + public: + /// + // Returns the subject of the X.509 certificate. For HTTPS server + // certificates this represents the web server. The common name of the + // subject should match the host name of the web server. + /// + /*--cef()--*/ + virtual CefRefPtr GetSubject() =0; + + /// + // Returns the issuer of the X.509 certificate. + /// + /*--cef()--*/ + virtual CefRefPtr GetIssuer() =0; + + /// + // Returns the DER encoded serial number for the X.509 certificate. The value + // possibly includes a leading 00 byte. + /// + /*--cef()--*/ + virtual CefRefPtr GetSerialNumber() =0; + + /// + // Returns the date before which the X.509 certificate is invalid. + // CefTime.GetTimeT() will return 0 if no date was specified. + /// + /*--cef()--*/ + virtual CefTime GetValidStart() =0; + + /// + // Returns the date after which the X.509 certificate is invalid. + // CefTime.GetTimeT() will return 0 if no date was specified. + /// + /*--cef()--*/ + virtual CefTime GetValidExpiry() =0; + + /// + // Returns the DER encoded data for the X.509 certificate. + /// + /*--cef()--*/ + virtual CefRefPtr GetDEREncoded() =0; + + /// + // Returns the PEM encoded data for the X.509 certificate. + /// + /*--cef()--*/ + virtual CefRefPtr GetPEMEncoded() =0; +}; + +#endif // CEF_INCLUDE_CEF_SSL_INFO_H_ diff --git a/include/cef_url.h b/include/cef_url.h index d2def08e9..023e5896f 100644 --- a/include/cef_url.h +++ b/include/cef_url.h @@ -41,6 +41,7 @@ #include #include "include/cef_base.h" +#include "include/cef_values.h" /// // Parse the specified |url| into its component parts. @@ -74,4 +75,41 @@ CefString CefGetMimeType(const CefString& extension); void CefGetExtensionsForMimeType(const CefString& mime_type, std::vector& extensions); +/// +// Encodes |data| as a base64 string. +/// +/*--cef()--*/ +CefString CefBase64Encode(const void* data, size_t data_size); + +/// +// Decodes the base64 encoded string |data|. The returned value will be NULL if +// the decoding fails. +/// +/*--cef()--*/ +CefRefPtr CefBase64Decode(const CefString& data); + +/// +// Escapes characters in |text| which are unsuitable for use as a query +// parameter value. Everything except alphanumerics and -_.!~*'() will be +// converted to "%XX". If |use_plus| is true spaces will change to "+". The +// result is basically the same as encodeURIComponent in Javacript. +/// +/*--cef()--*/ +CefString CefURIEncode(const CefString& text, bool use_plus); + +/// +// Unescapes |text| and returns the result. Unescaping consists of looking for +// the exact pattern "%XX" where each X is a hex digit and converting to the +// character with the numerical value of those digits (e.g. "i%20=%203%3b" +// unescapes to "i = 3;"). If |convert_to_utf8| is true this function will +// attempt to interpret the initial decoded result as UTF-8. If the result is +// convertable into UTF-8 it will be returned as converted. Otherwise the +// initial decoded result will be returned. The |unescape_rule| parameter +// supports further customization the decoding process. +/// +/*--cef()--*/ +CefString CefURIDecode(const CefString& text, + bool convert_to_utf8, + cef_uri_unescape_rule_t unescape_rule); + #endif // CEF_INCLUDE_CEF_URL_H_ diff --git a/include/internal/cef_types.h b/include/internal/cef_types.h index 376e38247..d16886bff 100644 --- a/include/internal/cef_types.h +++ b/include/internal/cef_types.h @@ -1927,6 +1927,57 @@ typedef struct _cef_cursor_info_t { cef_size_t size; } cef_cursor_info_t; +/// +// URI unescape rules passed to CefURIDecode(). +/// +typedef enum { + /// + // Don't unescape anything at all. + /// + UU_NONE = 0, + + /// + // Don't unescape anything special, but all normal unescaping will happen. + // This is a placeholder and can't be combined with other flags (since it's + // just the absence of them). All other unescape rules imply "normal" in + // addition to their special meaning. Things like escaped letters, digits, + // and most symbols will get unescaped with this mode. + /// + UU_NORMAL = 1, + + /// + // Convert %20 to spaces. In some places where we're showing URLs, we may + // want this. In places where the URL may be copied and pasted out, then + // you wouldn't want this since it might not be interpreted in one piece + // by other applications. + /// + UU_SPACES = 2, + + /// + // Unescapes various characters that will change the meaning of URLs, + // including '%', '+', '&', '/', '#'. If we unescaped these characters, the + // resulting URL won't be the same as the source one. This flag is used when + // generating final output like filenames for URLs where we won't be + // interpreting as a URL and want to do as much unescaping as possible. + /// + UU_URL_SPECIAL_CHARS = 4, + + /// + // Unescapes control characters such as %01. This INCLUDES NULLs. This is + // used for rare cases such as data: URL decoding where the result is binary + // data. This flag also unescapes BiDi control characters. + // + // DO NOT use CONTROL_CHARS if the URL is going to be displayed in the UI + // for security reasons. + /// + UU_CONTROL_CHARS = 8, + + /// + // URL queries use "+" for space. This flag controls that replacement. + /// + UU_REPLACE_PLUS_WITH_SPACE = 16, +} cef_uri_unescape_rule_t; + #ifdef __cplusplus } #endif diff --git a/libcef/browser/content_browser_client.cc b/libcef/browser/content_browser_client.cc index 356e49fbc..779df3981 100644 --- a/libcef/browser/content_browser_client.cc +++ b/libcef/browser/content_browser_client.cc @@ -20,6 +20,7 @@ #include "libcef/browser/printing/printing_message_filter.h" #include "libcef/browser/resource_dispatcher_host_delegate.h" #include "libcef/browser/speech_recognition_manager_delegate.h" +#include "libcef/browser/ssl_info_impl.h" #include "libcef/browser/thread_util.h" #include "libcef/browser/web_plugin_impl.h" #include "libcef/common/cef_switches.h" @@ -774,13 +775,15 @@ void CefContentBrowserClient::AllowCertificateError( if (!handler.get()) return; + CefRefPtr cef_ssl_info = new CefSSLInfoImpl(ssl_info); + CefRefPtr callbackImpl; if (overridable && !strict_enforcement) callbackImpl = new CefAllowCertificateErrorCallbackImpl(callback); bool proceed = handler->OnCertificateError( - static_cast(cert_error), request_url.spec(), - callbackImpl.get()); + browser.get(), static_cast(cert_error), + request_url.spec(), cef_ssl_info, callbackImpl.get()); if (!proceed && callbackImpl.get()) callbackImpl->Disconnect(); diff --git a/libcef/browser/ssl_cert_principal_impl.cc b/libcef/browser/ssl_cert_principal_impl.cc new file mode 100644 index 000000000..62befe29b --- /dev/null +++ b/libcef/browser/ssl_cert_principal_impl.cc @@ -0,0 +1,66 @@ +// Copyright (c) 2015 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. + +#include "libcef/browser/ssl_cert_principal_impl.h" + +namespace { + +void TransferVector(const std::vector& source, + std::vector& target) { + if (!target.empty()) + target.clear(); + + if (!source.empty()) { + std::vector::const_iterator it = source.begin(); + for (; it != source.end(); ++it) + target.push_back(*it); + } +} + +} // namespace + +CefSSLCertPrincipalImpl::CefSSLCertPrincipalImpl( + const net::CertPrincipal& value) + : value_(value) { +} + +CefString CefSSLCertPrincipalImpl::GetDisplayName() { + return value_.GetDisplayName(); +} + +CefString CefSSLCertPrincipalImpl::GetCommonName() { + return value_.common_name; +} + +CefString CefSSLCertPrincipalImpl::GetLocalityName() { + return value_.locality_name; +} + +CefString CefSSLCertPrincipalImpl::GetStateOrProvinceName() { + return value_.state_or_province_name; +} + +CefString CefSSLCertPrincipalImpl::GetCountryName() { + return value_.country_name; +} + +void CefSSLCertPrincipalImpl::GetStreetAddresses( + std::vector& addresses) { + TransferVector(value_.street_addresses, addresses); +} + +void CefSSLCertPrincipalImpl::GetOrganizationNames( + std::vector& names) { + TransferVector(value_.organization_names, names); +} + +void CefSSLCertPrincipalImpl::GetOrganizationUnitNames( + std::vector& names) { + TransferVector(value_.organization_unit_names, names); +} + +void CefSSLCertPrincipalImpl::GetDomainComponents( + std::vector& components) { + TransferVector(value_.domain_components, components); +} diff --git a/libcef/browser/ssl_cert_principal_impl.h b/libcef/browser/ssl_cert_principal_impl.h new file mode 100644 index 000000000..3d5b95b7a --- /dev/null +++ b/libcef/browser/ssl_cert_principal_impl.h @@ -0,0 +1,36 @@ +// Copyright (c) 2015 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. + +#ifndef CEF_LIBCEF_BROWSER_SSL_CERT_PRINCIPAL_IMPL_H_ +#define CEF_LIBCEF_BROWSER_SSL_CERT_PRINCIPAL_IMPL_H_ +#pragma once + +#include "include/cef_ssl_info.h" + +#include "net/cert/x509_cert_types.h" + +// CefSSLCertPrincipal implementation +class CefSSLCertPrincipalImpl : public CefSSLCertPrincipal { + public: + explicit CefSSLCertPrincipalImpl(const net::CertPrincipal& value); + + // CefSSLCertPrincipal methods. + CefString GetDisplayName() override; + CefString GetCommonName() override; + CefString GetLocalityName() override; + CefString GetStateOrProvinceName() override; + CefString GetCountryName() override; + void GetStreetAddresses(std::vector& addresses) override; + void GetOrganizationNames(std::vector& names) override; + void GetOrganizationUnitNames(std::vector& names) override; + void GetDomainComponents(std::vector& components) override; + + private: + net::CertPrincipal value_; + + IMPLEMENT_REFCOUNTING(CefSSLCertPrincipalImpl); + DISALLOW_COPY_AND_ASSIGN(CefSSLCertPrincipalImpl); +}; + +#endif // CEF_LIBCEF_BROWSER_SSL_CERT_PRINCIPAL_IMPL_H_ diff --git a/libcef/browser/ssl_info_impl.cc b/libcef/browser/ssl_info_impl.cc new file mode 100644 index 000000000..aa38caec0 --- /dev/null +++ b/libcef/browser/ssl_info_impl.cc @@ -0,0 +1,70 @@ +// Copyright (c) 2015 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. + +#include "libcef/browser/ssl_info_impl.h" +#include "libcef/browser/ssl_cert_principal_impl.h" +#include "libcef/common/time_util.h" + +#include "net/cert/x509_certificate.h" + +CefSSLInfoImpl::CefSSLInfoImpl(const net::SSLInfo& value) { + if (value.cert.get()) { + subject_ = new CefSSLCertPrincipalImpl(value.cert->subject()); + issuer_ = new CefSSLCertPrincipalImpl(value.cert->issuer()); + + const std::string& serial_number = value.cert->serial_number(); + serial_number_ = CefBinaryValue::Create(serial_number.c_str(), + serial_number.size()); + + const base::Time& valid_start = value.cert->valid_start(); + if (!valid_start.is_null()) + cef_time_from_basetime(valid_start, valid_start_); + + const base::Time& valid_expiry = value.cert->valid_expiry(); + if (!valid_expiry.is_null()) + cef_time_from_basetime(valid_expiry, valid_expiry_); + + net::X509Certificate::OSCertHandle os_handle = value.cert->os_cert_handle(); + if (os_handle) { + std::string encoded; + if (value.cert->GetDEREncoded(os_handle, &encoded)) { + der_encoded_ = CefBinaryValue::Create(encoded.c_str(), + encoded.size()); + } + encoded.clear(); + if (value.cert->GetPEMEncoded(os_handle, &encoded)) { + pem_encoded_ = CefBinaryValue::Create(encoded.c_str(), + encoded.size()); + } + } + } +} + +CefRefPtr CefSSLInfoImpl::GetSubject() { + return subject_; +} + +CefRefPtr CefSSLInfoImpl::GetIssuer() { + return issuer_; +} + +CefRefPtr CefSSLInfoImpl::GetSerialNumber() { + return serial_number_; +} + +CefTime CefSSLInfoImpl::GetValidStart() { + return valid_start_; +} + +CefTime CefSSLInfoImpl::GetValidExpiry() { + return valid_expiry_; +} + +CefRefPtr CefSSLInfoImpl::GetDEREncoded() { + return der_encoded_; +} + +CefRefPtr CefSSLInfoImpl::GetPEMEncoded() { + return pem_encoded_; +} diff --git a/libcef/browser/ssl_info_impl.h b/libcef/browser/ssl_info_impl.h new file mode 100644 index 000000000..a16ca5e22 --- /dev/null +++ b/libcef/browser/ssl_info_impl.h @@ -0,0 +1,40 @@ +// Copyright (c) 2015 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. + +#ifndef CEF_LIBCEF_BROWSER_SSL_INFO_IMPL_H_ +#define CEF_LIBCEF_BROWSER_SSL_INFO_IMPL_H_ +#pragma once + +#include "include/cef_ssl_info.h" + +#include "net/ssl/ssl_info.h" + +// CefSSLInfo implementation +class CefSSLInfoImpl : public CefSSLInfo { + public: + explicit CefSSLInfoImpl(const net::SSLInfo& value); + + // CefSSLInfo methods. + CefRefPtr GetSubject() override; + CefRefPtr GetIssuer() override; + CefRefPtr GetSerialNumber() override; + CefTime GetValidStart() override; + CefTime GetValidExpiry() override; + CefRefPtr GetDEREncoded() override; + CefRefPtr GetPEMEncoded() override; + + private: + CefRefPtr subject_; + CefRefPtr issuer_; + CefRefPtr serial_number_; + CefTime valid_start_; + CefTime valid_expiry_; + CefRefPtr der_encoded_; + CefRefPtr pem_encoded_; + + IMPLEMENT_REFCOUNTING(CefSSLInfoImpl); + DISALLOW_COPY_AND_ASSIGN(CefSSLInfoImpl); +}; + +#endif // CEF_LIBCEF_BROWSER_SSL_INFO_IMPL_H_ diff --git a/libcef/common/url_impl.cc b/libcef/common/url_impl.cc index d2660fcf2..c09052980 100644 --- a/libcef/common/url_impl.cc +++ b/libcef/common/url_impl.cc @@ -4,6 +4,9 @@ #include #include "include/cef_url.h" + +#include "base/base64.h" +#include "net/base/escape.h" #include "net/base/mime_util.h" #include "url/gurl.h" @@ -85,3 +88,39 @@ void CefGetExtensionsForMimeType(const CefString& mime_type, extensions.push_back(*it); } +CefString CefBase64Encode(const void* data, size_t data_size) { + if (data_size == 0) + return CefString(); + + base::StringPiece input; + input.set(static_cast(data), data_size); + std::string output; + base::Base64Encode(input, &output); + return output; +} + +CefRefPtr CefBase64Decode(const CefString& data) { + if (data.size() == 0) + return NULL; + + const std::string& input = data; + std::string output; + if (base::Base64Decode(input, &output)) + return CefBinaryValue::Create(output.data(), output.size()); + return NULL; +} + +CefString CefURIEncode(const CefString& text, bool use_plus) { + return net::EscapeQueryParamValue(text, use_plus); +} + +CefString CefURIDecode(const CefString& text, + bool convert_to_utf8, + cef_uri_unescape_rule_t unescape_rule) { + const net::UnescapeRule::Type type = + static_cast(unescape_rule); + if (convert_to_utf8) + return net::UnescapeAndDecodeUTF8URLComponent(text.ToString(), type); + else + return net::UnescapeURLComponent(text.ToString(), type); +} diff --git a/libcef_dll/cpptoc/request_handler_cpptoc.cc b/libcef_dll/cpptoc/request_handler_cpptoc.cc index 5d5364dbe..985dbf726 100644 --- a/libcef_dll/cpptoc/request_handler_cpptoc.cc +++ b/libcef_dll/cpptoc/request_handler_cpptoc.cc @@ -18,6 +18,7 @@ #include "libcef_dll/ctocpp/frame_ctocpp.h" #include "libcef_dll/ctocpp/quota_callback_ctocpp.h" #include "libcef_dll/ctocpp/request_ctocpp.h" +#include "libcef_dll/ctocpp/sslinfo_ctocpp.h" #include "libcef_dll/ctocpp/web_plugin_info_ctocpp.h" @@ -271,18 +272,27 @@ void CEF_CALLBACK request_handler_on_protocol_execution( } int CEF_CALLBACK request_handler_on_certificate_error( - struct _cef_request_handler_t* self, cef_errorcode_t cert_error, - const cef_string_t* request_url, + struct _cef_request_handler_t* self, cef_browser_t* browser, + cef_errorcode_t cert_error, const cef_string_t* request_url, + struct _cef_sslinfo_t* ssl_info, cef_allow_certificate_error_callback_t* callback) { // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING DCHECK(self); if (!self) return 0; + // Verify param: browser; type: refptr_diff + DCHECK(browser); + if (!browser) + return 0; // Verify param: request_url; type: string_byref_const DCHECK(request_url); if (!request_url) return 0; + // Verify param: ssl_info; type: refptr_diff + DCHECK(ssl_info); + if (!ssl_info) + return 0; // Verify param: callback; type: refptr_diff DCHECK(callback); if (!callback) @@ -290,8 +300,10 @@ int CEF_CALLBACK request_handler_on_certificate_error( // Execute bool _retval = CefRequestHandlerCppToC::Get(self)->OnCertificateError( + CefBrowserCToCpp::Wrap(browser), cert_error, CefString(request_url), + CefSSLInfoCToCpp::Wrap(ssl_info), CefAllowCertificateErrorCallbackCToCpp::Wrap(callback)); // Return type: bool diff --git a/libcef_dll/cpptoc/sslcert_principal_cpptoc.cc b/libcef_dll/cpptoc/sslcert_principal_cpptoc.cc new file mode 100644 index 000000000..339af9cb7 --- /dev/null +++ b/libcef_dll/cpptoc/sslcert_principal_cpptoc.cc @@ -0,0 +1,220 @@ +// Copyright (c) 2015 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool. If making changes by +// hand only do so within the body of existing method and function +// implementations. See the translator.README.txt file in the tools directory +// for more information. +// + +#include "libcef_dll/cpptoc/sslcert_principal_cpptoc.h" +#include "libcef_dll/transfer_util.h" + + +// MEMBER FUNCTIONS - Body may be edited by hand. + +cef_string_userfree_t CEF_CALLBACK sslcert_principal_get_display_name( + struct _cef_sslcert_principal_t* self) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + DCHECK(self); + if (!self) + return NULL; + + // Execute + CefString _retval = CefSSLCertPrincipalCppToC::Get(self)->GetDisplayName(); + + // Return type: string + return _retval.DetachToUserFree(); +} + +cef_string_userfree_t CEF_CALLBACK sslcert_principal_get_common_name( + struct _cef_sslcert_principal_t* self) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + DCHECK(self); + if (!self) + return NULL; + + // Execute + CefString _retval = CefSSLCertPrincipalCppToC::Get(self)->GetCommonName(); + + // Return type: string + return _retval.DetachToUserFree(); +} + +cef_string_userfree_t CEF_CALLBACK sslcert_principal_get_locality_name( + struct _cef_sslcert_principal_t* self) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + DCHECK(self); + if (!self) + return NULL; + + // Execute + CefString _retval = CefSSLCertPrincipalCppToC::Get(self)->GetLocalityName(); + + // Return type: string + return _retval.DetachToUserFree(); +} + +cef_string_userfree_t CEF_CALLBACK sslcert_principal_get_state_or_province_name( + struct _cef_sslcert_principal_t* self) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + DCHECK(self); + if (!self) + return NULL; + + // Execute + CefString _retval = CefSSLCertPrincipalCppToC::Get( + self)->GetStateOrProvinceName(); + + // Return type: string + return _retval.DetachToUserFree(); +} + +cef_string_userfree_t CEF_CALLBACK sslcert_principal_get_country_name( + struct _cef_sslcert_principal_t* self) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + DCHECK(self); + if (!self) + return NULL; + + // Execute + CefString _retval = CefSSLCertPrincipalCppToC::Get(self)->GetCountryName(); + + // Return type: string + return _retval.DetachToUserFree(); +} + +void CEF_CALLBACK sslcert_principal_get_street_addresses( + struct _cef_sslcert_principal_t* self, cef_string_list_t addresses) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + DCHECK(self); + if (!self) + return; + // Verify param: addresses; type: string_vec_byref + DCHECK(addresses); + if (!addresses) + return; + + // Translate param: addresses; type: string_vec_byref + std::vector addressesList; + transfer_string_list_contents(addresses, addressesList); + + // Execute + CefSSLCertPrincipalCppToC::Get(self)->GetStreetAddresses( + addressesList); + + // Restore param: addresses; type: string_vec_byref + cef_string_list_clear(addresses); + transfer_string_list_contents(addressesList, addresses); +} + +void CEF_CALLBACK sslcert_principal_get_organization_names( + struct _cef_sslcert_principal_t* self, cef_string_list_t names) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + DCHECK(self); + if (!self) + return; + // Verify param: names; type: string_vec_byref + DCHECK(names); + if (!names) + return; + + // Translate param: names; type: string_vec_byref + std::vector namesList; + transfer_string_list_contents(names, namesList); + + // Execute + CefSSLCertPrincipalCppToC::Get(self)->GetOrganizationNames( + namesList); + + // Restore param: names; type: string_vec_byref + cef_string_list_clear(names); + transfer_string_list_contents(namesList, names); +} + +void CEF_CALLBACK sslcert_principal_get_organization_unit_names( + struct _cef_sslcert_principal_t* self, cef_string_list_t names) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + DCHECK(self); + if (!self) + return; + // Verify param: names; type: string_vec_byref + DCHECK(names); + if (!names) + return; + + // Translate param: names; type: string_vec_byref + std::vector namesList; + transfer_string_list_contents(names, namesList); + + // Execute + CefSSLCertPrincipalCppToC::Get(self)->GetOrganizationUnitNames( + namesList); + + // Restore param: names; type: string_vec_byref + cef_string_list_clear(names); + transfer_string_list_contents(namesList, names); +} + +void CEF_CALLBACK sslcert_principal_get_domain_components( + struct _cef_sslcert_principal_t* self, cef_string_list_t components) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + DCHECK(self); + if (!self) + return; + // Verify param: components; type: string_vec_byref + DCHECK(components); + if (!components) + return; + + // Translate param: components; type: string_vec_byref + std::vector componentsList; + transfer_string_list_contents(components, componentsList); + + // Execute + CefSSLCertPrincipalCppToC::Get(self)->GetDomainComponents( + componentsList); + + // Restore param: components; type: string_vec_byref + cef_string_list_clear(components); + transfer_string_list_contents(componentsList, components); +} + + +// CONSTRUCTOR - Do not edit by hand. + +CefSSLCertPrincipalCppToC::CefSSLCertPrincipalCppToC(CefSSLCertPrincipal* cls) + : CefCppToC(cls) { + struct_.struct_.get_display_name = sslcert_principal_get_display_name; + struct_.struct_.get_common_name = sslcert_principal_get_common_name; + struct_.struct_.get_locality_name = sslcert_principal_get_locality_name; + struct_.struct_.get_state_or_province_name = + sslcert_principal_get_state_or_province_name; + struct_.struct_.get_country_name = sslcert_principal_get_country_name; + struct_.struct_.get_street_addresses = sslcert_principal_get_street_addresses; + struct_.struct_.get_organization_names = + sslcert_principal_get_organization_names; + struct_.struct_.get_organization_unit_names = + sslcert_principal_get_organization_unit_names; + struct_.struct_.get_domain_components = + sslcert_principal_get_domain_components; +} + +#ifndef NDEBUG +template<> base::AtomicRefCount CefCppToC::DebugObjCt = 0; +#endif + diff --git a/libcef_dll/cpptoc/sslcert_principal_cpptoc.h b/libcef_dll/cpptoc/sslcert_principal_cpptoc.h new file mode 100644 index 000000000..d52060032 --- /dev/null +++ b/libcef_dll/cpptoc/sslcert_principal_cpptoc.h @@ -0,0 +1,36 @@ +// Copyright (c) 2015 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool. If making changes by +// hand only do so within the body of existing method and function +// implementations. See the translator.README.txt file in the tools directory +// for more information. +// + +#ifndef CEF_LIBCEF_DLL_CPPTOC_SSLCERT_PRINCIPAL_CPPTOC_H_ +#define CEF_LIBCEF_DLL_CPPTOC_SSLCERT_PRINCIPAL_CPPTOC_H_ +#pragma once + +#ifndef BUILDING_CEF_SHARED +#pragma message("Warning: "__FILE__" may be accessed DLL-side only") +#else // BUILDING_CEF_SHARED + +#include "include/cef_ssl_info.h" +#include "include/capi/cef_ssl_info_capi.h" +#include "libcef_dll/cpptoc/cpptoc.h" + +// Wrap a C++ class with a C structure. +// This class may be instantiated and accessed DLL-side only. +class CefSSLCertPrincipalCppToC + : public CefCppToC { + public: + explicit CefSSLCertPrincipalCppToC(CefSSLCertPrincipal* cls); +}; + +#endif // BUILDING_CEF_SHARED +#endif // CEF_LIBCEF_DLL_CPPTOC_SSLCERT_PRINCIPAL_CPPTOC_H_ + diff --git a/libcef_dll/cpptoc/sslinfo_cpptoc.cc b/libcef_dll/cpptoc/sslinfo_cpptoc.cc new file mode 100644 index 000000000..e7c6a283c --- /dev/null +++ b/libcef_dll/cpptoc/sslinfo_cpptoc.cc @@ -0,0 +1,146 @@ +// Copyright (c) 2015 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool. If making changes by +// hand only do so within the body of existing method and function +// implementations. See the translator.README.txt file in the tools directory +// for more information. +// + +#include "libcef_dll/cpptoc/binary_value_cpptoc.h" +#include "libcef_dll/cpptoc/sslcert_principal_cpptoc.h" +#include "libcef_dll/cpptoc/sslinfo_cpptoc.h" + + +// MEMBER FUNCTIONS - Body may be edited by hand. + +cef_sslcert_principal_t* CEF_CALLBACK sslinfo_get_subject( + struct _cef_sslinfo_t* self) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + DCHECK(self); + if (!self) + return NULL; + + // Execute + CefRefPtr _retval = CefSSLInfoCppToC::Get( + self)->GetSubject(); + + // Return type: refptr_same + return CefSSLCertPrincipalCppToC::Wrap(_retval); +} + +cef_sslcert_principal_t* CEF_CALLBACK sslinfo_get_issuer( + struct _cef_sslinfo_t* self) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + DCHECK(self); + if (!self) + return NULL; + + // Execute + CefRefPtr _retval = CefSSLInfoCppToC::Get( + self)->GetIssuer(); + + // Return type: refptr_same + return CefSSLCertPrincipalCppToC::Wrap(_retval); +} + +struct _cef_binary_value_t* CEF_CALLBACK sslinfo_get_serial_number( + struct _cef_sslinfo_t* self) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + DCHECK(self); + if (!self) + return NULL; + + // Execute + CefRefPtr _retval = CefSSLInfoCppToC::Get( + self)->GetSerialNumber(); + + // Return type: refptr_same + return CefBinaryValueCppToC::Wrap(_retval); +} + +cef_time_t CEF_CALLBACK sslinfo_get_valid_start(struct _cef_sslinfo_t* self) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + DCHECK(self); + if (!self) + return CefTime(); + + // Execute + cef_time_t _retval = CefSSLInfoCppToC::Get(self)->GetValidStart(); + + // Return type: simple + return _retval; +} + +cef_time_t CEF_CALLBACK sslinfo_get_valid_expiry(struct _cef_sslinfo_t* self) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + DCHECK(self); + if (!self) + return CefTime(); + + // Execute + cef_time_t _retval = CefSSLInfoCppToC::Get(self)->GetValidExpiry(); + + // Return type: simple + return _retval; +} + +struct _cef_binary_value_t* CEF_CALLBACK sslinfo_get_derencoded( + struct _cef_sslinfo_t* self) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + DCHECK(self); + if (!self) + return NULL; + + // Execute + CefRefPtr _retval = CefSSLInfoCppToC::Get( + self)->GetDEREncoded(); + + // Return type: refptr_same + return CefBinaryValueCppToC::Wrap(_retval); +} + +struct _cef_binary_value_t* CEF_CALLBACK sslinfo_get_pemencoded( + struct _cef_sslinfo_t* self) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + DCHECK(self); + if (!self) + return NULL; + + // Execute + CefRefPtr _retval = CefSSLInfoCppToC::Get( + self)->GetPEMEncoded(); + + // Return type: refptr_same + return CefBinaryValueCppToC::Wrap(_retval); +} + + +// CONSTRUCTOR - Do not edit by hand. + +CefSSLInfoCppToC::CefSSLInfoCppToC(CefSSLInfo* cls) + : CefCppToC(cls) { + struct_.struct_.get_subject = sslinfo_get_subject; + struct_.struct_.get_issuer = sslinfo_get_issuer; + struct_.struct_.get_serial_number = sslinfo_get_serial_number; + struct_.struct_.get_valid_start = sslinfo_get_valid_start; + struct_.struct_.get_valid_expiry = sslinfo_get_valid_expiry; + struct_.struct_.get_derencoded = sslinfo_get_derencoded; + struct_.struct_.get_pemencoded = sslinfo_get_pemencoded; +} + +#ifndef NDEBUG +template<> base::AtomicRefCount CefCppToC::DebugObjCt = 0; +#endif + diff --git a/libcef_dll/cpptoc/sslinfo_cpptoc.h b/libcef_dll/cpptoc/sslinfo_cpptoc.h new file mode 100644 index 000000000..dc37a52ca --- /dev/null +++ b/libcef_dll/cpptoc/sslinfo_cpptoc.h @@ -0,0 +1,35 @@ +// Copyright (c) 2015 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool. If making changes by +// hand only do so within the body of existing method and function +// implementations. See the translator.README.txt file in the tools directory +// for more information. +// + +#ifndef CEF_LIBCEF_DLL_CPPTOC_SSLINFO_CPPTOC_H_ +#define CEF_LIBCEF_DLL_CPPTOC_SSLINFO_CPPTOC_H_ +#pragma once + +#ifndef BUILDING_CEF_SHARED +#pragma message("Warning: "__FILE__" may be accessed DLL-side only") +#else // BUILDING_CEF_SHARED + +#include "include/cef_ssl_info.h" +#include "include/capi/cef_ssl_info_capi.h" +#include "libcef_dll/cpptoc/cpptoc.h" + +// Wrap a C++ class with a C structure. +// This class may be instantiated and accessed DLL-side only. +class CefSSLInfoCppToC + : public CefCppToC { + public: + explicit CefSSLInfoCppToC(CefSSLInfo* cls); +}; + +#endif // BUILDING_CEF_SHARED +#endif // CEF_LIBCEF_DLL_CPPTOC_SSLINFO_CPPTOC_H_ + diff --git a/libcef_dll/ctocpp/request_handler_ctocpp.cc b/libcef_dll/ctocpp/request_handler_ctocpp.cc index 8bb196293..f3475da36 100644 --- a/libcef_dll/ctocpp/request_handler_ctocpp.cc +++ b/libcef_dll/ctocpp/request_handler_ctocpp.cc @@ -16,6 +16,7 @@ #include "libcef_dll/cpptoc/frame_cpptoc.h" #include "libcef_dll/cpptoc/quota_callback_cpptoc.h" #include "libcef_dll/cpptoc/request_cpptoc.h" +#include "libcef_dll/cpptoc/sslinfo_cpptoc.h" #include "libcef_dll/cpptoc/web_plugin_info_cpptoc.h" #include "libcef_dll/ctocpp/request_handler_ctocpp.h" #include "libcef_dll/ctocpp/resource_handler_ctocpp.h" @@ -252,18 +253,27 @@ void CefRequestHandlerCToCpp::OnProtocolExecution(CefRefPtr browser, allow_os_execution = allow_os_executionInt?true:false; } -bool CefRequestHandlerCToCpp::OnCertificateError(cef_errorcode_t cert_error, - const CefString& request_url, +bool CefRequestHandlerCToCpp::OnCertificateError(CefRefPtr browser, + cef_errorcode_t cert_error, const CefString& request_url, + CefRefPtr ssl_info, CefRefPtr callback) { if (CEF_MEMBER_MISSING(struct_, on_certificate_error)) return false; // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + // Verify param: browser; type: refptr_diff + DCHECK(browser.get()); + if (!browser.get()) + return false; // Verify param: request_url; type: string_byref_const DCHECK(!request_url.empty()); if (request_url.empty()) return false; + // Verify param: ssl_info; type: refptr_diff + DCHECK(ssl_info.get()); + if (!ssl_info.get()) + return false; // Verify param: callback; type: refptr_diff DCHECK(callback.get()); if (!callback.get()) @@ -271,8 +281,10 @@ bool CefRequestHandlerCToCpp::OnCertificateError(cef_errorcode_t cert_error, // Execute int _retval = struct_->on_certificate_error(struct_, + CefBrowserCppToC::Wrap(browser), cert_error, request_url.GetStruct(), + CefSSLInfoCppToC::Wrap(ssl_info), CefAllowCertificateErrorCallbackCppToC::Wrap(callback)); // Return type: bool diff --git a/libcef_dll/ctocpp/request_handler_ctocpp.h b/libcef_dll/ctocpp/request_handler_ctocpp.h index 989b36bbe..50b0f7a58 100644 --- a/libcef_dll/ctocpp/request_handler_ctocpp.h +++ b/libcef_dll/ctocpp/request_handler_ctocpp.h @@ -52,8 +52,9 @@ class CefRequestHandlerCToCpp CefRefPtr callback) override; void OnProtocolExecution(CefRefPtr browser, const CefString& url, bool& allow_os_execution) override; - bool OnCertificateError(cef_errorcode_t cert_error, - const CefString& request_url, + bool OnCertificateError(CefRefPtr browser, + cef_errorcode_t cert_error, const CefString& request_url, + CefRefPtr ssl_info, CefRefPtr callback) override; bool OnBeforePluginLoad(CefRefPtr browser, const CefString& url, const CefString& policy_url, CefRefPtr info) override; diff --git a/libcef_dll/ctocpp/sslcert_principal_ctocpp.cc b/libcef_dll/ctocpp/sslcert_principal_ctocpp.cc new file mode 100644 index 000000000..d83814b36 --- /dev/null +++ b/libcef_dll/ctocpp/sslcert_principal_ctocpp.cc @@ -0,0 +1,199 @@ +// Copyright (c) 2015 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool. If making changes by +// hand only do so within the body of existing method and function +// implementations. See the translator.README.txt file in the tools directory +// for more information. +// + +#include "libcef_dll/ctocpp/sslcert_principal_ctocpp.h" +#include "libcef_dll/transfer_util.h" + + +// VIRTUAL METHODS - Body may be edited by hand. + +CefString CefSSLCertPrincipalCToCpp::GetDisplayName() { + if (CEF_MEMBER_MISSING(struct_, get_display_name)) + return CefString(); + + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Execute + cef_string_userfree_t _retval = struct_->get_display_name(struct_); + + // Return type: string + CefString _retvalStr; + _retvalStr.AttachToUserFree(_retval); + return _retvalStr; +} + +CefString CefSSLCertPrincipalCToCpp::GetCommonName() { + if (CEF_MEMBER_MISSING(struct_, get_common_name)) + return CefString(); + + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Execute + cef_string_userfree_t _retval = struct_->get_common_name(struct_); + + // Return type: string + CefString _retvalStr; + _retvalStr.AttachToUserFree(_retval); + return _retvalStr; +} + +CefString CefSSLCertPrincipalCToCpp::GetLocalityName() { + if (CEF_MEMBER_MISSING(struct_, get_locality_name)) + return CefString(); + + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Execute + cef_string_userfree_t _retval = struct_->get_locality_name(struct_); + + // Return type: string + CefString _retvalStr; + _retvalStr.AttachToUserFree(_retval); + return _retvalStr; +} + +CefString CefSSLCertPrincipalCToCpp::GetStateOrProvinceName() { + if (CEF_MEMBER_MISSING(struct_, get_state_or_province_name)) + return CefString(); + + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Execute + cef_string_userfree_t _retval = struct_->get_state_or_province_name(struct_); + + // Return type: string + CefString _retvalStr; + _retvalStr.AttachToUserFree(_retval); + return _retvalStr; +} + +CefString CefSSLCertPrincipalCToCpp::GetCountryName() { + if (CEF_MEMBER_MISSING(struct_, get_country_name)) + return CefString(); + + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Execute + cef_string_userfree_t _retval = struct_->get_country_name(struct_); + + // Return type: string + CefString _retvalStr; + _retvalStr.AttachToUserFree(_retval); + return _retvalStr; +} + +void CefSSLCertPrincipalCToCpp::GetStreetAddresses( + std::vector& addresses) { + if (CEF_MEMBER_MISSING(struct_, get_street_addresses)) + return; + + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Translate param: addresses; type: string_vec_byref + cef_string_list_t addressesList = cef_string_list_alloc(); + DCHECK(addressesList); + if (addressesList) + transfer_string_list_contents(addresses, addressesList); + + // Execute + struct_->get_street_addresses(struct_, + addressesList); + + // Restore param:addresses; type: string_vec_byref + if (addressesList) { + addresses.clear(); + transfer_string_list_contents(addressesList, addresses); + cef_string_list_free(addressesList); + } +} + +void CefSSLCertPrincipalCToCpp::GetOrganizationNames( + std::vector& names) { + if (CEF_MEMBER_MISSING(struct_, get_organization_names)) + return; + + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Translate param: names; type: string_vec_byref + cef_string_list_t namesList = cef_string_list_alloc(); + DCHECK(namesList); + if (namesList) + transfer_string_list_contents(names, namesList); + + // Execute + struct_->get_organization_names(struct_, + namesList); + + // Restore param:names; type: string_vec_byref + if (namesList) { + names.clear(); + transfer_string_list_contents(namesList, names); + cef_string_list_free(namesList); + } +} + +void CefSSLCertPrincipalCToCpp::GetOrganizationUnitNames( + std::vector& names) { + if (CEF_MEMBER_MISSING(struct_, get_organization_unit_names)) + return; + + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Translate param: names; type: string_vec_byref + cef_string_list_t namesList = cef_string_list_alloc(); + DCHECK(namesList); + if (namesList) + transfer_string_list_contents(names, namesList); + + // Execute + struct_->get_organization_unit_names(struct_, + namesList); + + // Restore param:names; type: string_vec_byref + if (namesList) { + names.clear(); + transfer_string_list_contents(namesList, names); + cef_string_list_free(namesList); + } +} + +void CefSSLCertPrincipalCToCpp::GetDomainComponents( + std::vector& components) { + if (CEF_MEMBER_MISSING(struct_, get_domain_components)) + return; + + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Translate param: components; type: string_vec_byref + cef_string_list_t componentsList = cef_string_list_alloc(); + DCHECK(componentsList); + if (componentsList) + transfer_string_list_contents(components, componentsList); + + // Execute + struct_->get_domain_components(struct_, + componentsList); + + // Restore param:components; type: string_vec_byref + if (componentsList) { + components.clear(); + transfer_string_list_contents(componentsList, components); + cef_string_list_free(componentsList); + } +} + + +#ifndef NDEBUG +template<> base::AtomicRefCount CefCToCpp::DebugObjCt = 0; +#endif + diff --git a/libcef_dll/ctocpp/sslcert_principal_ctocpp.h b/libcef_dll/ctocpp/sslcert_principal_ctocpp.h new file mode 100644 index 000000000..1d745cdab --- /dev/null +++ b/libcef_dll/ctocpp/sslcert_principal_ctocpp.h @@ -0,0 +1,50 @@ +// Copyright (c) 2015 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool. If making changes by +// hand only do so within the body of existing method and function +// implementations. See the translator.README.txt file in the tools directory +// for more information. +// + +#ifndef CEF_LIBCEF_DLL_CTOCPP_SSLCERT_PRINCIPAL_CTOCPP_H_ +#define CEF_LIBCEF_DLL_CTOCPP_SSLCERT_PRINCIPAL_CTOCPP_H_ +#pragma once + +#ifndef USING_CEF_SHARED +#pragma message("Warning: "__FILE__" may be accessed wrapper-side only") +#else // USING_CEF_SHARED + +#include +#include "include/cef_ssl_info.h" +#include "include/capi/cef_ssl_info_capi.h" +#include "libcef_dll/ctocpp/ctocpp.h" + +// Wrap a C structure with a C++ class. +// This class may be instantiated and accessed wrapper-side only. +class CefSSLCertPrincipalCToCpp + : public CefCToCpp { + public: + explicit CefSSLCertPrincipalCToCpp(cef_sslcert_principal_t* str) + : CefCToCpp(str) {} + + // CefSSLCertPrincipal methods + virtual CefString GetDisplayName() OVERRIDE; + virtual CefString GetCommonName() OVERRIDE; + virtual CefString GetLocalityName() OVERRIDE; + virtual CefString GetStateOrProvinceName() OVERRIDE; + virtual CefString GetCountryName() OVERRIDE; + virtual void GetStreetAddresses(std::vector& addresses) OVERRIDE; + virtual void GetOrganizationNames(std::vector& names) OVERRIDE; + virtual void GetOrganizationUnitNames(std::vector& names) OVERRIDE; + virtual void GetDomainComponents(std::vector& components) OVERRIDE; +}; + +#endif // USING_CEF_SHARED +#endif // CEF_LIBCEF_DLL_CTOCPP_SSLCERT_PRINCIPAL_CTOCPP_H_ + diff --git a/libcef_dll/ctocpp/sslinfo_ctocpp.cc b/libcef_dll/ctocpp/sslinfo_ctocpp.cc new file mode 100644 index 000000000..36b9d031c --- /dev/null +++ b/libcef_dll/ctocpp/sslinfo_ctocpp.cc @@ -0,0 +1,116 @@ +// Copyright (c) 2015 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool. If making changes by +// hand only do so within the body of existing method and function +// implementations. See the translator.README.txt file in the tools directory +// for more information. +// + +#include "libcef_dll/ctocpp/binary_value_ctocpp.h" +#include "libcef_dll/ctocpp/sslcert_principal_ctocpp.h" +#include "libcef_dll/ctocpp/sslinfo_ctocpp.h" + + +// VIRTUAL METHODS - Body may be edited by hand. + +CefRefPtr CefSSLInfoCToCpp::GetSubject() { + if (CEF_MEMBER_MISSING(struct_, get_subject)) + return NULL; + + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Execute + cef_sslcert_principal_t* _retval = struct_->get_subject(struct_); + + // Return type: refptr_same + return CefSSLCertPrincipalCToCpp::Wrap(_retval); +} + +CefRefPtr CefSSLInfoCToCpp::GetIssuer() { + if (CEF_MEMBER_MISSING(struct_, get_issuer)) + return NULL; + + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Execute + cef_sslcert_principal_t* _retval = struct_->get_issuer(struct_); + + // Return type: refptr_same + return CefSSLCertPrincipalCToCpp::Wrap(_retval); +} + +CefRefPtr CefSSLInfoCToCpp::GetSerialNumber() { + if (CEF_MEMBER_MISSING(struct_, get_serial_number)) + return NULL; + + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Execute + cef_binary_value_t* _retval = struct_->get_serial_number(struct_); + + // Return type: refptr_same + return CefBinaryValueCToCpp::Wrap(_retval); +} + +CefTime CefSSLInfoCToCpp::GetValidStart() { + if (CEF_MEMBER_MISSING(struct_, get_valid_start)) + return CefTime(); + + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Execute + cef_time_t _retval = struct_->get_valid_start(struct_); + + // Return type: simple + return _retval; +} + +CefTime CefSSLInfoCToCpp::GetValidExpiry() { + if (CEF_MEMBER_MISSING(struct_, get_valid_expiry)) + return CefTime(); + + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Execute + cef_time_t _retval = struct_->get_valid_expiry(struct_); + + // Return type: simple + return _retval; +} + +CefRefPtr CefSSLInfoCToCpp::GetDEREncoded() { + if (CEF_MEMBER_MISSING(struct_, get_derencoded)) + return NULL; + + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Execute + cef_binary_value_t* _retval = struct_->get_derencoded(struct_); + + // Return type: refptr_same + return CefBinaryValueCToCpp::Wrap(_retval); +} + +CefRefPtr CefSSLInfoCToCpp::GetPEMEncoded() { + if (CEF_MEMBER_MISSING(struct_, get_pemencoded)) + return NULL; + + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Execute + cef_binary_value_t* _retval = struct_->get_pemencoded(struct_); + + // Return type: refptr_same + return CefBinaryValueCToCpp::Wrap(_retval); +} + + +#ifndef NDEBUG +template<> base::AtomicRefCount CefCToCpp::DebugObjCt = 0; +#endif + diff --git a/libcef_dll/ctocpp/sslinfo_ctocpp.h b/libcef_dll/ctocpp/sslinfo_ctocpp.h new file mode 100644 index 000000000..57ca90a16 --- /dev/null +++ b/libcef_dll/ctocpp/sslinfo_ctocpp.h @@ -0,0 +1,45 @@ +// Copyright (c) 2015 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool. If making changes by +// hand only do so within the body of existing method and function +// implementations. See the translator.README.txt file in the tools directory +// for more information. +// + +#ifndef CEF_LIBCEF_DLL_CTOCPP_SSLINFO_CTOCPP_H_ +#define CEF_LIBCEF_DLL_CTOCPP_SSLINFO_CTOCPP_H_ +#pragma once + +#ifndef USING_CEF_SHARED +#pragma message("Warning: "__FILE__" may be accessed wrapper-side only") +#else // USING_CEF_SHARED + +#include "include/cef_ssl_info.h" +#include "include/capi/cef_ssl_info_capi.h" +#include "libcef_dll/ctocpp/ctocpp.h" + +// Wrap a C structure with a C++ class. +// This class may be instantiated and accessed wrapper-side only. +class CefSSLInfoCToCpp + : public CefCToCpp { + public: + explicit CefSSLInfoCToCpp(cef_sslinfo_t* str) + : CefCToCpp(str) {} + + // CefSSLInfo methods + virtual CefRefPtr GetSubject() OVERRIDE; + virtual CefRefPtr GetIssuer() OVERRIDE; + virtual CefRefPtr GetSerialNumber() OVERRIDE; + virtual CefTime GetValidStart() OVERRIDE; + virtual CefTime GetValidExpiry() OVERRIDE; + virtual CefRefPtr GetDEREncoded() OVERRIDE; + virtual CefRefPtr GetPEMEncoded() OVERRIDE; +}; + +#endif // USING_CEF_SHARED +#endif // CEF_LIBCEF_DLL_CTOCPP_SSLINFO_CTOCPP_H_ + diff --git a/libcef_dll/libcef_dll.cc b/libcef_dll/libcef_dll.cc index cde827369..10a906711 100644 --- a/libcef_dll/libcef_dll.cc +++ b/libcef_dll/libcef_dll.cc @@ -59,6 +59,8 @@ #include "libcef_dll/cpptoc/print_settings_cpptoc.h" #include "libcef_dll/cpptoc/process_message_cpptoc.h" #include "libcef_dll/cpptoc/quota_callback_cpptoc.h" +#include "libcef_dll/cpptoc/sslcert_principal_cpptoc.h" +#include "libcef_dll/cpptoc/sslinfo_cpptoc.h" #include "libcef_dll/cpptoc/scheme_registrar_cpptoc.h" #include "libcef_dll/cpptoc/stream_reader_cpptoc.h" #include "libcef_dll/cpptoc/stream_writer_cpptoc.h" @@ -244,6 +246,8 @@ CEF_EXPORT void cef_shutdown() { DCHECK(base::AtomicRefCountIsZero(&CefResourceHandlerCToCpp::DebugObjCt)); DCHECK(base::AtomicRefCountIsZero( &CefRunFileDialogCallbackCToCpp::DebugObjCt)); + DCHECK(base::AtomicRefCountIsZero(&CefSSLCertPrincipalCppToC::DebugObjCt)); + DCHECK(base::AtomicRefCountIsZero(&CefSSLInfoCppToC::DebugObjCt)); DCHECK(base::AtomicRefCountIsZero( &CefSchemeHandlerFactoryCToCpp::DebugObjCt)); DCHECK(base::AtomicRefCountIsZero(&CefSchemeRegistrarCppToC::DebugObjCt)); @@ -639,6 +643,78 @@ CEF_EXPORT void cef_get_extensions_for_mime_type(const cef_string_t* mime_type, transfer_string_list_contents(extensionsList, extensions); } +CEF_EXPORT cef_string_userfree_t cef_base64encode(const void* data, + size_t data_size) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Verify param: data; type: simple_byaddr + DCHECK(data); + if (!data) + return NULL; + + // Execute + CefString _retval = CefBase64Encode( + data, + data_size); + + // Return type: string + return _retval.DetachToUserFree(); +} + +CEF_EXPORT struct _cef_binary_value_t* cef_base64decode( + const cef_string_t* data) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Verify param: data; type: string_byref_const + DCHECK(data); + if (!data) + return NULL; + + // Execute + CefRefPtr _retval = CefBase64Decode( + CefString(data)); + + // Return type: refptr_same + return CefBinaryValueCppToC::Wrap(_retval); +} + +CEF_EXPORT cef_string_userfree_t cef_uriencode(const cef_string_t* text, + int use_plus) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Verify param: text; type: string_byref_const + DCHECK(text); + if (!text) + return NULL; + + // Execute + CefString _retval = CefURIEncode( + CefString(text), + use_plus?true:false); + + // Return type: string + return _retval.DetachToUserFree(); +} + +CEF_EXPORT cef_string_userfree_t cef_uridecode(const cef_string_t* text, + int convert_to_utf8, cef_uri_unescape_rule_t unescape_rule) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Verify param: text; type: string_byref_const + DCHECK(text); + if (!text) + return NULL; + + // Execute + CefString _retval = CefURIDecode( + CefString(text), + convert_to_utf8?true:false, + unescape_rule); + + // Return type: string + return _retval.DetachToUserFree(); +} + CEF_EXPORT int cef_register_extension(const cef_string_t* extension_name, const cef_string_t* javascript_code, struct _cef_v8handler_t* handler) { // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING diff --git a/libcef_dll/wrapper/libcef_dll_wrapper.cc b/libcef_dll/wrapper/libcef_dll_wrapper.cc index a3cfa30cf..ddfcb4262 100644 --- a/libcef_dll/wrapper/libcef_dll_wrapper.cc +++ b/libcef_dll/wrapper/libcef_dll_wrapper.cc @@ -97,6 +97,8 @@ #include "libcef_dll/ctocpp/print_settings_ctocpp.h" #include "libcef_dll/ctocpp/process_message_ctocpp.h" #include "libcef_dll/ctocpp/quota_callback_ctocpp.h" +#include "libcef_dll/ctocpp/sslcert_principal_ctocpp.h" +#include "libcef_dll/ctocpp/sslinfo_ctocpp.h" #include "libcef_dll/ctocpp/scheme_registrar_ctocpp.h" #include "libcef_dll/ctocpp/stream_reader_ctocpp.h" #include "libcef_dll/ctocpp/stream_writer_ctocpp.h" @@ -236,6 +238,8 @@ CEF_GLOBAL void CefShutdown() { DCHECK(base::AtomicRefCountIsZero(&CefResourceHandlerCppToC::DebugObjCt)); DCHECK(base::AtomicRefCountIsZero( &CefRunFileDialogCallbackCppToC::DebugObjCt)); + DCHECK(base::AtomicRefCountIsZero(&CefSSLCertPrincipalCToCpp::DebugObjCt)); + DCHECK(base::AtomicRefCountIsZero(&CefSSLInfoCToCpp::DebugObjCt)); DCHECK(base::AtomicRefCountIsZero( &CefSchemeHandlerFactoryCppToC::DebugObjCt)); DCHECK(base::AtomicRefCountIsZero(&CefSchemeRegistrarCToCpp::DebugObjCt)); @@ -593,6 +597,81 @@ CEF_GLOBAL void CefGetExtensionsForMimeType(const CefString& mime_type, } } +CEF_GLOBAL CefString CefBase64Encode(const void* data, size_t data_size) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Verify param: data; type: simple_byaddr + DCHECK(data); + if (!data) + return CefString(); + + // Execute + cef_string_userfree_t _retval = cef_base64encode( + data, + data_size); + + // Return type: string + CefString _retvalStr; + _retvalStr.AttachToUserFree(_retval); + return _retvalStr; +} + +CEF_GLOBAL CefRefPtr CefBase64Decode(const CefString& data) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Verify param: data; type: string_byref_const + DCHECK(!data.empty()); + if (data.empty()) + return NULL; + + // Execute + cef_binary_value_t* _retval = cef_base64decode( + data.GetStruct()); + + // Return type: refptr_same + return CefBinaryValueCToCpp::Wrap(_retval); +} + +CEF_GLOBAL CefString CefURIEncode(const CefString& text, bool use_plus) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Verify param: text; type: string_byref_const + DCHECK(!text.empty()); + if (text.empty()) + return CefString(); + + // Execute + cef_string_userfree_t _retval = cef_uriencode( + text.GetStruct(), + use_plus); + + // Return type: string + CefString _retvalStr; + _retvalStr.AttachToUserFree(_retval); + return _retvalStr; +} + +CEF_GLOBAL CefString CefURIDecode(const CefString& text, bool convert_to_utf8, + cef_uri_unescape_rule_t unescape_rule) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Verify param: text; type: string_byref_const + DCHECK(!text.empty()); + if (text.empty()) + return CefString(); + + // Execute + cef_string_userfree_t _retval = cef_uridecode( + text.GetStruct(), + convert_to_utf8, + unescape_rule); + + // Return type: string + CefString _retvalStr; + _retvalStr.AttachToUserFree(_retval); + return _retvalStr; +} + CEF_GLOBAL bool CefRegisterExtension(const CefString& extension_name, const CefString& javascript_code, CefRefPtr handler) { // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING diff --git a/tests/cefclient/browser/client_handler.cc b/tests/cefclient/browser/client_handler.cc index c960d8d9a..2aa201a3a 100644 --- a/tests/cefclient/browser/client_handler.cc +++ b/tests/cefclient/browser/client_handler.cc @@ -6,12 +6,14 @@ #include #include +#include #include #include #include "include/base/cef_bind.h" #include "include/cef_browser.h" #include "include/cef_frame.h" +#include "include/cef_url.h" #include "include/wrapper/cef_closure_task.h" #include "cefclient/browser/main_context.h" #include "cefclient/browser/resource_util.h" @@ -44,6 +46,121 @@ enum client_menu_ids { // Musr match the value in client_renderer.cc. const char kFocusedNodeChangedMessage[] = "ClientRenderer.FocusedNodeChanged"; +std::string GetTimeString(const CefTime& value) { + if (value.GetTimeT() == 0) + return "Unspecified"; + + static const char* kMonths[] = { + "January", "February", "March", "April", "May", "June", "July", "August", + "September", "October", "November", "December" + }; + std::string month; + if (value.month >= 1 && value.month <= 12) + month = kMonths[value.month - 1]; + else + month = "Invalid"; + + std::stringstream ss; + ss << month << " " << value.day_of_month << ", " << value.year << " " << + std::setfill('0') << std::setw(2) << value.hour << ":" << + std::setfill('0') << std::setw(2) << value.minute << ":" << + std::setfill('0') << std::setw(2) << value.second; + return ss.str(); +} + +std::string GetBinaryString(CefRefPtr value) { + if (!value.get()) + return " "; + + // Retrieve the value. + const size_t size = value->GetSize(); + std::string src; + src.resize(size); + value->GetData(const_cast(src.data()), size, 0); + + // Encode the value. + return CefBase64Encode(src.data(), src.size()); +} + +std::string GetErrorString(cef_errorcode_t code) { + // Case condition that returns |code| as a string. + #define CASE(code) case code: return #code + + switch (code) { + CASE(ERR_NONE); + CASE(ERR_FAILED); + CASE(ERR_ABORTED); + CASE(ERR_INVALID_ARGUMENT); + CASE(ERR_INVALID_HANDLE); + CASE(ERR_FILE_NOT_FOUND); + CASE(ERR_TIMED_OUT); + CASE(ERR_FILE_TOO_BIG); + CASE(ERR_UNEXPECTED); + CASE(ERR_ACCESS_DENIED); + CASE(ERR_NOT_IMPLEMENTED); + CASE(ERR_CONNECTION_CLOSED); + CASE(ERR_CONNECTION_RESET); + CASE(ERR_CONNECTION_REFUSED); + CASE(ERR_CONNECTION_ABORTED); + CASE(ERR_CONNECTION_FAILED); + CASE(ERR_NAME_NOT_RESOLVED); + CASE(ERR_INTERNET_DISCONNECTED); + CASE(ERR_SSL_PROTOCOL_ERROR); + CASE(ERR_ADDRESS_INVALID); + CASE(ERR_ADDRESS_UNREACHABLE); + CASE(ERR_SSL_CLIENT_AUTH_CERT_NEEDED); + CASE(ERR_TUNNEL_CONNECTION_FAILED); + CASE(ERR_NO_SSL_VERSIONS_ENABLED); + CASE(ERR_SSL_VERSION_OR_CIPHER_MISMATCH); + CASE(ERR_SSL_RENEGOTIATION_REQUESTED); + CASE(ERR_CERT_COMMON_NAME_INVALID); + CASE(ERR_CERT_DATE_INVALID); + CASE(ERR_CERT_AUTHORITY_INVALID); + CASE(ERR_CERT_CONTAINS_ERRORS); + CASE(ERR_CERT_NO_REVOCATION_MECHANISM); + CASE(ERR_CERT_UNABLE_TO_CHECK_REVOCATION); + CASE(ERR_CERT_REVOKED); + CASE(ERR_CERT_INVALID); + CASE(ERR_CERT_END); + CASE(ERR_INVALID_URL); + CASE(ERR_DISALLOWED_URL_SCHEME); + CASE(ERR_UNKNOWN_URL_SCHEME); + CASE(ERR_TOO_MANY_REDIRECTS); + CASE(ERR_UNSAFE_REDIRECT); + CASE(ERR_UNSAFE_PORT); + CASE(ERR_INVALID_RESPONSE); + CASE(ERR_INVALID_CHUNKED_ENCODING); + CASE(ERR_METHOD_NOT_SUPPORTED); + CASE(ERR_UNEXPECTED_PROXY_AUTH); + CASE(ERR_EMPTY_RESPONSE); + CASE(ERR_RESPONSE_HEADERS_TOO_BIG); + CASE(ERR_CACHE_MISS); + CASE(ERR_INSECURE_RESPONSE); + default: + return "UNKNOWN"; + } +} + +// Load a data: URI containing the error message. +void LoadErrorPage(CefRefPtr frame, + const std::string& failed_url, + cef_errorcode_t error_code, + const std::string& other_info) { + std::stringstream ss; + ss << "Page failed to load" + "" + "

Page failed to load.

" + "URL: "<< failed_url << "" + "
Error: " << GetErrorString(error_code) << + " (" << error_code << ")"; + + if (!other_info.empty()) + ss << "
" << other_info; + + ss << ""; + frame->LoadURL(test_runner::GetDataURI(ss.str(), "text/html")); +} + } // namespace ClientHandler::ClientHandler(Delegate* delegate, @@ -360,13 +477,8 @@ void ClientHandler::OnLoadError(CefRefPtr browser, return; } - // Display a load error message. - std::stringstream ss; - ss << "" - "

Failed to load URL " << std::string(failedUrl) << - " with error " << std::string(errorText) << " (" << errorCode << - ").

"; - frame->LoadString(ss.str(), failedUrl); + // Load the error page. + LoadErrorPage(frame, failedUrl, errorCode, errorText); } bool ClientHandler::OnBeforeBrowse(CefRefPtr browser, @@ -413,6 +525,47 @@ void ClientHandler::OnProtocolExecution(CefRefPtr browser, allow_os_execution = true; } +bool ClientHandler::OnCertificateError( + CefRefPtr browser, + ErrorCode cert_error, + const CefString& request_url, + CefRefPtr ssl_info, + CefRefPtr callback) { + CEF_REQUIRE_UI_THREAD(); + + CefRefPtr subject = ssl_info->GetSubject(); + CefRefPtr issuer = ssl_info->GetIssuer(); + + // Build a table showing certificate information. + std::stringstream ss; + ss << "X.509 Certificate Information:" + "" << + "" + "" + "" + "" + "" + "" + "" + "" + "" + "
FieldValue
Subject" << + (subject.get() ? subject->GetDisplayName().ToString() : " ") << + "
Issuer" << + (issuer.get() ? issuer->GetDisplayName().ToString() : " ") << + "
Serial #*" << + GetBinaryString(ssl_info->GetSerialNumber()) << "
Valid Start" << + GetTimeString(ssl_info->GetValidStart()) << "
Valid Expiry" << + GetTimeString(ssl_info->GetValidExpiry()) << "
DER Encoded*" << + GetBinaryString(ssl_info->GetDEREncoded()) << "
PEM Encoded*" << + GetBinaryString(ssl_info->GetPEMEncoded()) << "
* Displayed value is base64 encoded."; + + // Load the error page. + LoadErrorPage(browser->GetMainFrame(), request_url, cert_error, ss.str()); + + return false; // Cancel the request. +} + void ClientHandler::OnRenderProcessTerminated(CefRefPtr browser, TerminationStatus status) { CEF_REQUIRE_UI_THREAD(); diff --git a/tests/cefclient/browser/client_handler.h b/tests/cefclient/browser/client_handler.h index 301bdfee8..58b725894 100644 --- a/tests/cefclient/browser/client_handler.h +++ b/tests/cefclient/browser/client_handler.h @@ -206,6 +206,12 @@ class ClientHandler : public CefClient, void OnProtocolExecution(CefRefPtr browser, const CefString& url, bool& allow_os_execution) OVERRIDE; + bool OnCertificateError( + CefRefPtr browser, + ErrorCode cert_error, + const CefString& request_url, + CefRefPtr ssl_info, + CefRefPtr callback) OVERRIDE; void OnRenderProcessTerminated(CefRefPtr browser, TerminationStatus status) OVERRIDE; diff --git a/tests/cefclient/browser/scheme_test.cc b/tests/cefclient/browser/scheme_test.cc index 3e92a1e0f..69d849628 100644 --- a/tests/cefclient/browser/scheme_test.cc +++ b/tests/cefclient/browser/scheme_test.cc @@ -46,8 +46,7 @@ class ClientSchemeHandler : public CefResourceHandler { "
";
 
       // Output a string representation of the request
-      std::string dump;
-      test_runner::DumpRequestContents(request, dump);
+      const std::string& dump = test_runner::DumpRequestContents(request);
       data_.append(dump);
 
       data_.append("

Try the test form:" diff --git a/tests/cefclient/browser/test_runner.cc b/tests/cefclient/browser/test_runner.cc index 5eba5ca6f..af75477d4 100644 --- a/tests/cefclient/browser/test_runner.cc +++ b/tests/cefclient/browser/test_runner.cc @@ -4,6 +4,8 @@ #include "cefclient/browser/test_runner.h" +#include + #include "include/base/cef_bind.h" #include "include/cef_task.h" #include "include/cef_trace.h" @@ -318,7 +320,7 @@ void RunTest(CefRefPtr browser, int id) { } } -void DumpRequestContents(CefRefPtr request, std::string& str) { +std::string DumpRequestContents(CefRefPtr request) { std::stringstream ss; ss << "URL: " << std::string(request->GetURL()); @@ -365,7 +367,13 @@ void DumpRequestContents(CefRefPtr request, std::string& str) { } } - str = ss.str(); + return ss.str(); +} + +std::string GetDataURI(const std::string& data, + const std::string& mime_type) { + return "data:" + mime_type + ";base64," + + CefURIEncode(CefBase64Encode(data.data(), data.size()), false).ToString(); } CefRefPtr GetResourceHandler( @@ -379,8 +387,7 @@ CefRefPtr GetResourceHandler( if (ParseTestUrl(url, &file_name, &mime_type)) { if (file_name == "request.html") { // Show the request contents. - std::string dump; - DumpRequestContents(request, dump); + const std::string& dump = DumpRequestContents(request); std::string str = "
" + dump +
                           "
"; CefRefPtr stream = diff --git a/tests/cefclient/browser/test_runner.h b/tests/cefclient/browser/test_runner.h index b1bbb581d..9cfbc5cba 100644 --- a/tests/cefclient/browser/test_runner.h +++ b/tests/cefclient/browser/test_runner.h @@ -20,8 +20,12 @@ namespace test_runner { // Run a test. void RunTest(CefRefPtr browser, int id); -// Dump the contents of the request into a string. -void DumpRequestContents(CefRefPtr request, std::string& str); +// Returns the contents of the CefRequest as a string. +std::string DumpRequestContents(CefRefPtr request); + +// Returns a data: URI with the specified contents. +std::string GetDataURI(const std::string& data, + const std::string& mime_type); // Get test resources. CefRefPtr GetResourceHandler( diff --git a/tests/unittests/url_unittest.cc b/tests/unittests/url_unittest.cc index f902c65a4..490c99842 100644 --- a/tests/unittests/url_unittest.cc +++ b/tests/unittests/url_unittest.cc @@ -231,3 +231,46 @@ TEST(URLTest, GetMimeType) { mime_type = CefGetMimeType("gif"); EXPECT_STREQ("image/gif", mime_type.ToString().c_str()); } + +TEST(URLTest, Base64Encode) { + const std::string& test_str_decoded = "A test string"; + const std::string& test_str_encoded = "QSB0ZXN0IHN0cmluZw=="; + const CefString& encoded_value = + CefBase64Encode(test_str_decoded.data(), test_str_decoded.size()); + EXPECT_STREQ(test_str_encoded.c_str(), encoded_value.ToString().c_str()); +} + +TEST(URLTest, Base64Decode) { + const std::string& test_str_decoded = "A test string"; + const std::string& test_str_encoded = "QSB0ZXN0IHN0cmluZw=="; + CefRefPtr decoded_value = CefBase64Decode(test_str_encoded); + EXPECT_TRUE(decoded_value.get()); + + const size_t decoded_size = decoded_value->GetSize(); + EXPECT_EQ(test_str_decoded.size(), decoded_size); + + std::string decoded_str; + decoded_str.resize(decoded_size + 1); // Include space for NUL-terminator. + const size_t get_data_result = + decoded_value->GetData(const_cast(decoded_str.data()), + decoded_size, 0); + EXPECT_EQ(decoded_size, get_data_result); + EXPECT_STREQ(test_str_decoded.c_str(), decoded_str.c_str()); +} + +TEST(URLTest, URIEncode) { + const std::string& test_str_decoded = "A test string="; + const std::string& test_str_encoded = "A%20test%20string%3D"; + const CefString& encoded_value = CefURIEncode(test_str_decoded, false); + EXPECT_STREQ(test_str_encoded.c_str(), encoded_value.ToString().c_str()); +} + +TEST(URLTest, URIDecode) { + const std::string& test_str_decoded = "A test string="; + const std::string& test_str_encoded = "A%20test%20string%3D"; + const CefString& decoded_value = + CefURIDecode(test_str_encoded, false, + static_cast( + UU_SPACES | UU_URL_SPECIAL_CHARS)); + EXPECT_STREQ(test_str_decoded.c_str(), decoded_value.ToString().c_str()); +}