[LFC][IFC] InlineFormattingState::addDetachingRule should accumulate rules.
[WebKit-https.git] / Source / WebKit / NetworkProcess / cache / NetworkCacheCodersCocoa.cpp
1 /*
2  * Copyright (C) 2011, 2014-2015 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "NetworkCacheCoders.h"
28
29 #if PLATFORM(COCOA)
30 #include <Security/SecCertificate.h>
31 #include <Security/SecTrust.h>
32 #include <wtf/cf/TypeCastsCF.h>
33 #include <wtf/spi/cocoa/SecuritySPI.h>
34 #endif
35
36 WTF_DECLARE_CF_TYPE_TRAIT(SecCertificate);
37
38 namespace WTF {
39 namespace Persistence {
40
41 static void encodeCFData(Encoder& encoder, CFDataRef data)
42 {
43     uint64_t length = CFDataGetLength(data);
44     const uint8_t* bytePtr = CFDataGetBytePtr(data);
45
46     encoder << length;
47     encoder.encodeFixedLengthData(bytePtr, length);
48 }
49
50 static bool decodeCFData(Decoder& decoder, RetainPtr<CFDataRef>& data)
51 {
52     uint64_t size = 0;
53     if (!decoder.decode(size))
54         return false;
55
56     Vector<uint8_t> vector(size);
57     if (!decoder.decodeFixedLengthData(vector.data(), vector.size()))
58         return false;
59
60     data = adoptCF(CFDataCreate(nullptr, vector.data(), vector.size()));
61     return true;
62 }
63
64
65 #if HAVE(SEC_TRUST_SERIALIZATION)
66 static void encodeSecTrustRef(Encoder& encoder, SecTrustRef trust)
67 {
68     auto data = adoptCF(SecTrustSerialize(trust, nullptr));
69     if (!data) {
70         encoder << false;
71         return;
72     }
73
74     encoder << true;
75     encodeCFData(encoder, data.get());
76 }
77
78 static bool decodeSecTrustRef(Decoder& decoder, RetainPtr<SecTrustRef>& result)
79 {
80     bool hasTrust;
81     if (!decoder.decode(hasTrust))
82         return false;
83
84     if (!hasTrust)
85         return true;
86
87     RetainPtr<CFDataRef> trustData;
88     if (!decodeCFData(decoder, trustData))
89         return false;
90
91     auto trust = adoptCF(SecTrustDeserialize(trustData.get(), nullptr));
92     if (!trust)
93         return false;
94
95     result = WTFMove(trust);
96     return true;
97 }
98 #endif
99
100 static void encodeCertificateChain(Encoder& encoder, CFArrayRef certificateChain)
101 {
102     CFIndex size = CFArrayGetCount(certificateChain);
103     Vector<CFTypeRef, 32> values(size);
104
105     CFArrayGetValues(certificateChain, CFRangeMake(0, size), values.data());
106
107     encoder << static_cast<uint64_t>(size);
108
109     for (CFIndex i = 0; i < size; ++i) {
110         ASSERT(values[i]);
111         auto data = adoptCF(SecCertificateCopyData(checked_cf_cast<SecCertificateRef>(values[i])));
112         encodeCFData(encoder, data.get());
113     }
114 }
115
116 static bool decodeCertificateChain(Decoder& decoder, RetainPtr<CFArrayRef>& certificateChain)
117 {
118     uint64_t size;
119     if (!decoder.decode(size))
120         return false;
121
122     auto array = adoptCF(CFArrayCreateMutable(0, 0, &kCFTypeArrayCallBacks));
123
124     for (size_t i = 0; i < size; ++i) {
125         RetainPtr<CFDataRef> data;
126         if (!decodeCFData(decoder, data))
127             return false;
128
129         auto certificate = adoptCF(SecCertificateCreateWithData(0, data.get()));
130         CFArrayAppendValue(array.get(), certificate.get());
131     }
132
133     certificateChain = WTFMove(array);
134     return true;
135 }
136
137 void Coder<WebCore::CertificateInfo>::encode(Encoder& encoder, const WebCore::CertificateInfo& certificateInfo)
138 {
139     encoder.encodeEnum(certificateInfo.type());
140
141     switch (certificateInfo.type()) {
142 #if HAVE(SEC_TRUST_SERIALIZATION)
143     case WebCore::CertificateInfo::Type::Trust:
144         encodeSecTrustRef(encoder, certificateInfo.trust());
145         break;
146 #endif
147     case WebCore::CertificateInfo::Type::CertificateChain: {
148         encodeCertificateChain(encoder, certificateInfo.certificateChain());
149         break;
150     }
151     case WebCore::CertificateInfo::Type::None:
152         // Do nothing.
153         break;
154     }
155 }
156
157 bool Coder<WebCore::CertificateInfo>::decode(Decoder& decoder, WebCore::CertificateInfo& certificateInfo)
158 {
159     WebCore::CertificateInfo::Type certificateInfoType;
160     if (!decoder.decodeEnum(certificateInfoType))
161         return false;
162
163     switch (certificateInfoType) {
164 #if HAVE(SEC_TRUST_SERIALIZATION)
165     case WebCore::CertificateInfo::Type::Trust: {
166         RetainPtr<SecTrustRef> trust;
167         if (!decodeSecTrustRef(decoder, trust))
168             return false;
169
170         certificateInfo = WebCore::CertificateInfo(WTFMove(trust));
171         return true;
172     }
173 #endif
174     case WebCore::CertificateInfo::Type::CertificateChain: {
175         RetainPtr<CFArrayRef> certificateChain;
176         if (!decodeCertificateChain(decoder, certificateChain))
177             return false;
178
179         certificateInfo = WebCore::CertificateInfo(WTFMove(certificateChain));
180         return true;
181     }    
182     case WebCore::CertificateInfo::Type::None:
183         // Do nothing.
184         break;
185     }
186
187     return true;
188 }
189
190 }
191 }