⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 277426 in webkit


Ignore:
Timestamp:
May 13, 2021, 1:00:14 AM (5 years ago)
Author:
Carlos Garcia Campos
Message:

[GTK][WPE] Add ArgumentCoder for GTlsCertificate
​https://bugs.webkit.org/show_bug.cgi?id=225509

Reviewed by Adrian Perez de Castro.

Move the GTlsCertificate serialization from CertificateInfo ArgumentCoder to its own.

  • Shared/glib/ArgumentCodersGLib.cpp:

(IPC::ArgumentCoder<GRefPtr<GVariant>>::encode):
(IPC::ArgumentCoder<GRefPtr<GVariant>>::decode):
(IPC::ArgumentCoder<GRefPtr<GTlsCertificate>>::encode):
(IPC::ArgumentCoder<GRefPtr<GTlsCertificate>>::decode):
(IPC::encode): Deleted.
(IPC::decode): Deleted.

  • Shared/glib/ArgumentCodersGLib.h:
  • Shared/glib/UserMessage.cpp:

(WebKit::UserMessage::encode const):
(WebKit::UserMessage::decode):

  • Shared/soup/WebCoreArgumentCodersSoup.cpp:

(IPC::ArgumentCoder<CertificateInfo>::encode):
(IPC::ArgumentCoder<CertificateInfo>::decode):

Location:
trunk/Source/WebKit
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit/ChangeLog

    r277420 r277426  
     12021-05-13  Carlos Garcia Campos  <cgarcia@igalia.com>
     2
     3        [GTK][WPE] Add ArgumentCoder for GTlsCertificate
     4        https://bugs.webkit.org/show_bug.cgi?id=225509
     5
     6        Reviewed by Adrian Perez de Castro.
     7
     8        Move the GTlsCertificate serialization from CertificateInfo ArgumentCoder to its own.
     9
     10        * Shared/glib/ArgumentCodersGLib.cpp:
     11        (IPC::ArgumentCoder<GRefPtr<GVariant>>::encode):
     12        (IPC::ArgumentCoder<GRefPtr<GVariant>>::decode):
     13        (IPC::ArgumentCoder<GRefPtr<GTlsCertificate>>::encode):
     14        (IPC::ArgumentCoder<GRefPtr<GTlsCertificate>>::decode):
     15        (IPC::encode): Deleted.
     16        (IPC::decode): Deleted.
     17        * Shared/glib/ArgumentCodersGLib.h:
     18        * Shared/glib/UserMessage.cpp:
     19        (WebKit::UserMessage::encode const):
     20        (WebKit::UserMessage::decode):
     21        * Shared/soup/WebCoreArgumentCodersSoup.cpp:
     22        (IPC::ArgumentCoder<CertificateInfo>::encode):
     23        (IPC::ArgumentCoder<CertificateInfo>::decode):
     24
    1252021-05-12  Chris Dumez  <cdumez@apple.com>
    226

  • trunk/Source/WebKit/Shared/glib/ArgumentCodersGLib.cpp

    r262274 r277426  
    2828
    2929#include "DataReference.h"
    30 #include <glib.h>
     30#include <gio/gio.h>
    3131#include <wtf/glib/GUniquePtr.h>
    3232#include <wtf/text/CString.h>
    … …  
    3434namespace IPC {
    3535
    36 void encode(Encoder& encoder, GVariant* variant)
     36void ArgumentCoder<GRefPtr<GVariant>>::encode(Encoder& encoder, GRefPtr<GVariant> variant)
    3737{
    3838    if (!variant) {
    … …  
    4141    }
    4242
    43     encoder << CString(g_variant_get_type_string(variant));
    44     encoder << DataReference(static_cast<const uint8_t*>(g_variant_get_data(variant)), g_variant_get_size(variant));
     43    encoder << CString(g_variant_get_type_string(variant.get()));
     44    encoder << DataReference(static_cast<const uint8_t*>(g_variant_get_data(variant.get())), g_variant_get_size(variant.get()));
    4545}
    4646
    47 Optional<GRefPtr<GVariant>> decode(Decoder& decoder)
     47Optional<GRefPtr<GVariant>> ArgumentCoder<GRefPtr<GVariant>>::decode(Decoder& decoder)
    4848{
    4949    CString variantTypeString;
    … …  
    6666}
    6767
     68void ArgumentCoder<GRefPtr<GTlsCertificate>>::encode(Encoder& encoder, GRefPtr<GTlsCertificate> certificate)
     69{
     70    if (!certificate) {
     71        encoder << 0;
     72        return;
     73    }
     74
     75    Vector<GRefPtr<GByteArray>> certificatesDataList;
     76    for (auto* nextCertificate = certificate.get(); nextCertificate; nextCertificate = g_tls_certificate_get_issuer(nextCertificate)) {
     77        GRefPtr<GByteArray> certificateData;
     78        g_object_get(nextCertificate, "certificate", &certificateData.outPtr(), nullptr);
     79
     80        if (!certificateData) {
     81            certificatesDataList.clear();
     82            break;
     83        }
     84
     85        certificatesDataList.append(WTFMove(certificateData));
     86    }
     87
     88    encoder << static_cast<uint32_t>(certificatesDataList.size());
     89    if (certificatesDataList.isEmpty())
     90        return;
     91
     92    // Encode starting from the root certificate.
     93    while (!certificatesDataList.isEmpty()) {
     94        auto certificateData = certificatesDataList.takeLast();
     95        encoder << IPC::DataReference(certificateData->data, certificateData->len);
     96    }
     97}
     98
     99Optional<GRefPtr<GTlsCertificate>> ArgumentCoder<GRefPtr<GTlsCertificate>>::decode(Decoder& decoder)
     100{
     101    uint32_t chainLength;
     102    if (!decoder.decode(chainLength))
     103        return WTF::nullopt;
     104
     105    if (!chainLength)
     106        return GRefPtr<GTlsCertificate>();
     107
     108    GType certificateType = g_tls_backend_get_certificate_type(g_tls_backend_get_default());
     109    GRefPtr<GTlsCertificate> certificate;
     110    GTlsCertificate* issuer = nullptr;
     111    for (uint32_t i = 0; i < chainLength; i++) {
     112        IPC::DataReference certificateDataReference;
     113        if (!decoder.decode(certificateDataReference))
     114            return WTF::nullopt;
     115
     116        GRefPtr<GByteArray> certificateData = adoptGRef(g_byte_array_sized_new(certificateDataReference.size()));
     117        g_byte_array_append(certificateData.get(), certificateDataReference.data(), certificateDataReference.size());
     118
     119        certificate = adoptGRef(G_TLS_CERTIFICATE(g_initable_new(
     120            certificateType, nullptr, nullptr,
     121            "certificate", certificateData.get(),
     122            "issuer", issuer,
     123            nullptr)));
     124        issuer = certificate.get();
     125    }
     126
     127    return certificate;
     128}
     129
    68130} // namespace IPC

  • trunk/Source/WebKit/Shared/glib/ArgumentCodersGLib.h

    r251181 r277426  
    3030
    3131typedef struct _GVariant GVariant;
     32typedef struct _GTlsCertificate GTlsCertificate;
    3233
    3334namespace IPC {
    3435
    35 void encode(Encoder&, GVariant*);
    36 Optional<GRefPtr<GVariant>> decode(Decoder&);
     36template<> struct ArgumentCoder<GRefPtr<GVariant>> {
     37    static void encode(Encoder&, GRefPtr<GVariant>);
     38    static Optional<GRefPtr<GVariant>> decode(Decoder&);
     39};
     40
     41template<> struct ArgumentCoder<GRefPtr<GTlsCertificate>> {
     42    static void encode(Encoder&, GRefPtr<GTlsCertificate>);
     43    static Optional<GRefPtr<GTlsCertificate>> decode(Decoder&);
     44};
    3745
    3846} // namespace IPC

  • trunk/Source/WebKit/Shared/glib/UserMessage.cpp

    r262994 r277426  
    4646    }
    4747
    48     IPC::encode(encoder, parameters.get());
     48    encoder << parameters;
    4949
    5050    Vector<IPC::Attachment> attachments;
    … …  
    7979    }
    8080
    81     Optional<GRefPtr<GVariant>> parameters = IPC::decode(decoder);
     81    Optional<GRefPtr<GVariant>> parameters;
     82    decoder >> parameters;
    8283    if (!parameters)
    8384        return WTF::nullopt;

  • trunk/Source/WebKit/Shared/soup/WebCoreArgumentCodersSoup.cpp

    r270573 r277426  
    2727
    2828#include "config.h"
     29#include "WebCoreArgumentCoders.h"
     30
     31#include "ArgumentCodersGLib.h"
    2932#include "DataReference.h"
    30 #include "WebCoreArgumentCoders.h"
    31 
    3233#include <WebCore/CertificateInfo.h>
    3334#include <WebCore/DictionaryPopupInfo.h>
    … …  
    5556void ArgumentCoder<CertificateInfo>::encode(Encoder& encoder, const CertificateInfo& certificateInfo)
    5657{
    57     auto* certificate = certificateInfo.certificate();
    58     if (!certificate) {
    59         encoder << 0;
     58    GRefPtr<GTlsCertificate> certificate = certificateInfo.certificate();
     59    encoder << certificate;
     60    if (!certificate)
    6061        return;
     62
     63    encoder << static_cast<uint32_t>(certificateInfo.tlsErrors());
     64}
     65
     66bool ArgumentCoder<CertificateInfo>::decode(Decoder& decoder, CertificateInfo& certificateInfo)
     67{
     68    Optional<GRefPtr<GTlsCertificate>> certificate;
     69    decoder >> certificate;
     70    if (!certificate)
     71        return false;
     72
     73    if (certificate.value()) {
     74        uint32_t tlsErrors;
     75        if (!decoder.decode(tlsErrors))
     76            return false;
     77
     78        certificateInfo.setCertificate(certificate->get());
     79        certificateInfo.setTLSErrors(static_cast<GTlsCertificateFlags>(tlsErrors));
    6180    }
    62 
    63     Vector<GRefPtr<GByteArray>> certificatesDataList;
    64     for (; certificate; certificate = g_tls_certificate_get_issuer(certificate)) {
    65         GByteArray* certificateData = nullptr;
    66         g_object_get(G_OBJECT(certificate), "certificate", &certificateData, nullptr);
    67 
    68         if (!certificateData) {
    69             certificatesDataList.clear();
    70             break;
    71         }
    72 
    73         certificatesDataList.append(adoptGRef(certificateData));
    74     }
    75 
    76     encoder << static_cast<uint32_t>(certificatesDataList.size());
    77 
    78     if (certificatesDataList.isEmpty())
    79         return;
    80 
    81     // Encode starting from the root certificate.
    82     for (size_t i = certificatesDataList.size(); i > 0; --i) {
    83         GByteArray* certificate = certificatesDataList[i - 1].get();
    84         encoder << IPC::DataReference(certificate->data, certificate->len);
    85     }
    86 
    87     encoder << static_cast<uint32_t>(certificateInfo.tlsErrors());
    88 }
    89 
    90 bool ArgumentCoder<CertificateInfo>::decode(Decoder& decoder, CertificateInfo& certificateInfo)
    91 {
    92     uint32_t chainLength;
    93     if (!decoder.decode(chainLength))
    94         return false;
    95 
    96     if (!chainLength)
    97         return true;
    98 
    99     GType certificateType = g_tls_backend_get_certificate_type(g_tls_backend_get_default());
    100     GRefPtr<GTlsCertificate> certificate;
    101     for (uint32_t i = 0; i < chainLength; i++) {
    102         IPC::DataReference certificateDataReference;
    103         if (!decoder.decode(certificateDataReference))
    104             return false;
    105 
    106         GByteArray* certificateData = g_byte_array_sized_new(certificateDataReference.size());
    107         GRefPtr<GByteArray> certificateBytes = adoptGRef(g_byte_array_append(certificateData, certificateDataReference.data(), certificateDataReference.size()));
    108 
    109         certificate = adoptGRef(G_TLS_CERTIFICATE(g_initable_new(
    110             certificateType, nullptr, nullptr, "certificate", certificateBytes.get(), "issuer", certificate.get(), nullptr)));
    111     }
    112 
    113     uint32_t tlsErrors;
    114     if (!decoder.decode(tlsErrors))
    115         return false;
    116 
    117     certificateInfo.setCertificate(certificate.get());
    118     certificateInfo.setTLSErrors(static_cast<GTlsCertificateFlags>(tlsErrors));
    11981
    12082    return true;
Note: See TracChangeset for help on using the changeset viewer.