mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Bug 1114703: Remove mozilla::pkix's polyfill for std::bind, r=mmc 

--HG--
extra : rebase_source : 11457f210c7f7534db2e6ebe1a8328985ff6d8b0
This commit is contained in:
Brian Smith 2015-01-21 04:00:40 -08:00
Родитель 12229012ec
Коммит 2968c94831
12 изменённых файлов: 76 добавлений и 338 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

231
security/pkix/include/pkix/bind.h
Просмотреть файл

@ -1,231 +0,0 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This code is made available to you under your choice of the following sets
* of licensing terms:
*/
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
/* Copyright 2013 Mozilla Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// Work around missing std::bind, std::ref, std::cref in older compilers. This
// implementation isn't intended to be complete; rather, it is the minimal
// implementation needed to make our use of std::bind work for compilers that
// lack both C++11 and TR1 support for these features. We cannot even assume
// that rvalue references work, which means we don't get perfect forwarding
// and thus we basically have to define a new overload for every distinct call
// signature.
//
// A positive side-effect of this code is improved debugging usability; it is
// much more convenient to step through code that uses this polyfill than it is
// to step through the many nested layers of a real std::bind implementation.
//
// Build with MOZILLA_PKIX_USE_REAL_FUNCTIONAL defined in order to use the
// compiler's definitions of these functions. This is helpful in order to
// ensure that the calling code is actually compatible with the real std::bind
// and friends.
#ifndef mozilla_pkix__bind_h
#define mozilla_pkix__bind_h
#ifdef MOZILLA_PKIX_USE_REAL_FUNCTIONAL
#include <functional>
#endif
namespace mozilla { namespace pkix {
#ifdef MOZILLA_PKIX_USE_REAL_FUNCTIONAL
using std::bind;
using std::cref;
using std::ref;
using std::placeholders::_1;
using std::placeholders::_2;
using std::placeholders::_3;
using std::placeholders::_4;
#else
extern class Placeholder1 { } _1;
extern class Placeholder2 { } _2;
extern class Placeholder3 { } _3;
extern class Placeholder4 { } _4;
template <typename V> V& ref(V& v) { return v; }
template <typename V> const V& cref(const V& v) { return v; }
namespace internal {
template <typename R, typename P1, typename B1>
class Bind1
{
public:
typedef R (&F)(P1&, B1&);
Bind1(F f, B1& b1) : f(f), b1(b1) { }
R operator()(P1& p1) const { return f(p1, b1); }
private:
F f;
B1& b1;
void operator=(const Bind1&) = delete;
};
template <typename R, typename P1, typename B1, typename B2>
class Bind2
{
public:
typedef R (&F)(P1&, B1&, B2&);
Bind2(F f, B1& b1, B2& b2) : f(f), b1(b1), b2(b2) { }
R operator()(P1& p1) const { return f(p1, b1, b2); }
private:
F f;
B1& b1;
B2& b2;
void operator=(const Bind2&) = delete;
};
template <typename R, typename P1, typename B1, typename B2, typename B3>
class Bind3
{
public:
typedef R (&F)(P1&, B1, B2, B3&);
Bind3(F f, B1& b1, B2& b2, B3& b3)
: f(f), b1(b1), b2(b2), b3(b3) { }
R operator()(P1& p1) const { return f(p1, b1, b2, b3); }
private:
F f;
B1& b1;
B2& b2;
B3& b3;
void operator=(const Bind3&) = delete;
};
template <typename R, typename P1, typename B1, typename B2, typename B3,
typename B4>
class Bind4
{
public:
typedef R (&F)(P1&, B1, B2, B3&, B4&);
Bind4(F f, B1& b1, B2& b2, B3& b3, B4& b4)
: f(f), b1(b1), b2(b2), b3(b3), b4(b4) { }
R operator()(P1& p1) const { return f(p1, b1, b2, b3, b4); }
private:
F f;
B1& b1;
B2& b2;
B3& b3;
B4& b4;
void operator=(const Bind4&) = delete;
};
template <typename R, typename C1, typename P1, typename P2, typename P3,
typename P4>
class BindToMemberFunction4
{
public:
// XXX: C++ doesn't have reference-to-member function, only
// pointer-to-member function, so we can't enforce the non-nullness of f
// using the type system.
typedef R (C1::*F)(P1&, P2&, P3, P4&);
BindToMemberFunction4(F f, C1& that) : f(f), that(that) { }
R operator()(P1& p1, P2& p2, P3 p3, P4& p4) const
{
return (that.*f)(p1, p2, p3, p4);
}
private:
const F f;
C1& that;
void operator=(const BindToMemberFunction4&) = delete;
};
template <typename R, typename P1, typename B1, typename B2, typename B3,
typename B4, typename B5>
class Bind5
{
public:
typedef R (&F)(P1&, B1, B2, B3, B4, B5);
Bind5(F f, B1 b1, B2 b2, B3 b3, B4 b4, B5 b5)
: f(f), b1(b1), b2(b2), b3(b3), b4(b4), b5(b5) { }
R operator()(P1& p1) const { return f(p1, b1, b2, b3, b4, b5); }
private:
F f;
B1 b1;
B2 b2;
B3 b3;
B4 b4;
B5 b5;
void operator=(const Bind5&) = delete;
};
} // namespace internal
template <typename R, typename P1, typename B1>
inline internal::Bind1<R, P1, B1>
bind(R (&f)(P1&, B1&), Placeholder1&, B1& b1)
{
return internal::Bind1<R, P1, B1>(f, b1);
}
template <typename R, typename P1, typename B1, typename B2>
inline internal::Bind2<R, P1, B1, B2>
bind(R (&f)(P1&, B1&, B2&), Placeholder1&, B1& b1, B2& b2)
{
return internal::Bind2<R, P1, B1, B2>(f, b1, b2);
}
template <typename R, typename P1, typename B1, typename B2, typename B3>
inline internal::Bind3<R, P1, const B1, const B2, B3>
bind(R (&f)(P1&, B1, B2, B3&), Placeholder1&, const B1& b1, const B2& b2,
B3& b3)
{
return internal::Bind3<R, P1, const B1, const B2, B3>(f, b1, b2, b3);
}
template <typename R, typename P1, typename B1, typename B2, typename B3,
typename B4>
inline internal::Bind4<R, P1, const B1, const B2, B3, B4>
bind(R (&f)(P1&, B1, B2, B3&, B4&), Placeholder1&, const B1& b1, const B2& b2,
B3& b3, B4& b4)
{
return internal::Bind4<R, P1, const B1, const B2, B3, B4>(f, b1, b2, b3, b4);
}
// XXX: C++ doesn't have reference-to-member function, only
// pointer-to-member function, so we can't enforce the non-nullness of f
// using the type system.
template <typename R, typename C1, typename P1, typename P2, typename P3,
typename P4>
inline internal::BindToMemberFunction4<R, C1, P1, P2, P3, P4>
bind(R (C1::*f)(P1&, P2&, P3, P4&), C1& that, Placeholder1&,
Placeholder2&, Placeholder3, Placeholder4&)
{
return internal::BindToMemberFunction4<R, C1, P1, P2, P3, P4>(f, that);
}
template <typename R, typename P1, typename B1, typename B2, typename B3,
typename B4, typename B5>
inline internal::Bind5<R, P1, B1, B2, B3, B4, B5&>
bind(R (&f)(P1&, B1, B2, B3, B4, B5&), Placeholder1&, B1 b1, B2 b2, B3 b3,
B4 b4, B5& b5)
{
return internal::Bind5<R, P1, B1, B2, B3, B4, B5&>(f, b1, b2, b3, b4, b5);
}
#endif
} } // namespace mozilla::pkix
#endif // mozilla_pkix__bind_h

38
security/pkix/lib/pkixbind.cpp
Просмотреть файл

@ -1,38 +0,0 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This code is made available to you under your choice of the following sets
* of licensing terms:
*/
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
/* Copyright 2013 Mozilla Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "pkix/bind.h"
#ifndef MOZILLA_PKIX_USE_REAL_FUNCTIONAL
namespace mozilla { namespace pkix {
Placeholder1 _1;
Placeholder2 _2;
Placeholder3 _3;
Placeholder4 _4;
} } // namespace mozilla::pkix
#endif

14
security/pkix/lib/pkixcert.cpp
Просмотреть файл

@ -22,7 +22,6 @@
* limitations under the License.
*/
#include "pkix/bind.h"
#include "pkixutil.h"
namespace mozilla { namespace pkix {
@ -140,9 +139,12 @@ BackCert::Init()
}
}
rv = der::OptionalExtensions(tbsCertificate, CSC | 3,
bind(&BackCert::RememberExtension, *this, _1,
_2, _3, _4));
rv = der::OptionalExtensions(
tbsCertificate, CSC | 3,
[this](Reader& extnID, const Input& extnValue, bool critical,
/*out*/ bool& understood) {
return RememberExtension(extnID, extnValue, critical, understood);
});
if (rv != Success) {
return rv;
}
@ -178,10 +180,8 @@ BackCert::Init()
return der::End(tbsCertificate);
}
// XXX: The second value is of type |const Input&| instead of type |Input| due
// to limitations in our std::bind polyfill.
Result
BackCert::RememberExtension(Reader& extnID, const Input& extnValue,
BackCert::RememberExtension(Reader& extnID, Input extnValue,
bool critical, /*out*/ bool& understood)
{
understood = false;

44
security/pkix/lib/pkixcheck.cpp
Просмотреть файл

@ -24,7 +24,6 @@
#include "pkixcheck.h"
#include "pkix/bind.h"
#include "pkixder.h"
#include "pkixutil.h"
@ -296,24 +295,6 @@ static const long UNLIMITED_PATH_LEN = -1; // must be less than zero
// BasicConstraints ::= SEQUENCE {
// cA BOOLEAN DEFAULT FALSE,
// pathLenConstraint INTEGER (0..MAX) OPTIONAL }
static Result
DecodeBasicConstraints(Reader& input, /*out*/ bool& isCA,
/*out*/ long& pathLenConstraint)
{
if (der::OptionalBoolean(input, isCA) != Success) {
return Result::ERROR_EXTENSION_VALUE_INVALID;
}
// TODO(bug 985025): If isCA is false, pathLenConstraint MUST NOT
// be included (as per RFC 5280 section 4.2.1.9), but for compatibility
// reasons, we don't check this for now.
if (der::OptionalInteger(input, UNLIMITED_PATH_LEN, pathLenConstraint)
!= Success) {
return Result::ERROR_EXTENSION_VALUE_INVALID;
}
return Success;
}
// RFC5280 4.2.1.9. Basic Constraints (id-ce-basicConstraints)
Result
@ -327,9 +308,19 @@ CheckBasicConstraints(EndEntityOrCA endEntityOrCA,
if (encodedBasicConstraints) {
Reader input(*encodedBasicConstraints);
if (der::Nested(input, der::SEQUENCE,
bind(DecodeBasicConstraints, _1, ref(isCA),
ref(pathLenConstraint))) != Success) {
Result rv = der::Nested(input, der::SEQUENCE,
[&isCA, &pathLenConstraint](Reader& r) {
Result rv = der::OptionalBoolean(r, isCA);
if (rv != Success) {
return rv;
}
// TODO(bug 985025): If isCA is false, pathLenConstraint
// MUST NOT be included (as per RFC 5280 section
// 4.2.1.9), but for compatibility reasons, we don't
// check this.
return der::OptionalInteger(r, UNLIMITED_PATH_LEN, pathLenConstraint);
});
if (rv != Success) {
return Result::ERROR_EXTENSION_VALUE_INVALID;
}
if (der::End(input) != Success) {
@ -488,10 +479,11 @@ CheckExtendedKeyUsage(EndEntityOrCA endEntityOrCA,
bool found = requiredEKU == KeyPurposeId::anyExtendedKeyUsage;
Reader input(*encodedExtendedKeyUsage);
if (der::NestedOf(input, der::SEQUENCE, der::OIDTag, der::EmptyAllowed::No,
bind(MatchEKU, _1, requiredEKU, endEntityOrCA,
ref(found), ref(foundOCSPSigning)))
!= Success) {
Result rv = der::NestedOf(input, der::SEQUENCE, der::OIDTag,
der::EmptyAllowed::No, [&](Reader& r) {
return MatchEKU(r, requiredEKU, endEntityOrCA, found, foundOCSPSigning);
});
if (rv != Success) {
return Result::ERROR_INADEQUATE_CERT_TYPE;
}
if (der::End(input) != Success) {

1
security/pkix/lib/pkixder.cpp
Просмотреть файл

@ -24,7 +24,6 @@
#include "pkixder.h"
#include "pkix/bind.h"
#include "pkixutil.h"
namespace mozilla { namespace pkix { namespace der {

20
security/pkix/lib/pkixder.h
Просмотреть файл

@ -186,14 +186,24 @@ Nested(Reader& input, uint8_t outerTag, uint8_t innerTag, Decoder decoder)
// Foo ::= SEQUENCE {
// }
//
// using a call like this:
// using code like this:
//
// rv = NestedOf(input, SEQEUENCE, SEQUENCE, bind(_1, Foo));
// Result Foo(Reader& r) { /*...*/ }
//
// Result Foo(Reader& input) {
// }
// rv = der::NestedOf(input, der::SEQEUENCE, der::SEQUENCE, Foo);
//
// In this example, Foo will get called once for each element of foos.
// or:
//
// Result Bar(Reader& r, int value) { /*...*/ }
//
// int value = /*...*/;
//
// rv = der::NestedOf(input, der::SEQUENCE, [value](Reader& r) {
// return Bar(r, value);
// });
//
// In these examples the function will get called once for each element of
// foos.
//
template <typename Decoder>
inline Result

18
security/pkix/lib/pkixnames.cpp
Просмотреть файл

@ -34,7 +34,6 @@
// constraints, the reference identifier is the entire encoded name constraint
// extension value.
#include "pkix/bind.h"
#include "pkixcheck.h"
#include "pkixutil.h"
@ -468,10 +467,10 @@ SearchNames(/*optional*/ const Input* subjectAltName,
// SET SIZE (1..MAX) OF AttributeTypeAndValue
Reader subjectReader(subject);
return der::NestedOf(subjectReader, der::SEQUENCE, der::SET,
der::EmptyAllowed::Yes,
bind(SearchWithinRDN, _1, referenceIDType,
referenceID, fallBackToEmailAddress,
fallBackToCommonName, ref(match)));
der::EmptyAllowed::Yes, [&](Reader& r) {
return SearchWithinRDN(r, referenceIDType, referenceID,
fallBackToEmailAddress, fallBackToCommonName, match);
});
}
// RelativeDistinguishedName ::=
@ -489,10 +488,11 @@ SearchWithinRDN(Reader& rdn,
/*in/out*/ MatchResult& match)
{
do {
Result rv = der::Nested(rdn, der::SEQUENCE,
bind(SearchWithinAVA, _1, referenceIDType,
referenceID, fallBackToEmailAddress,
fallBackToCommonName, ref(match)));
Result rv = der::Nested(rdn, der::SEQUENCE, [&](Reader& r) {
return SearchWithinAVA(r, referenceIDType, referenceID,
fallBackToEmailAddress, fallBackToCommonName,
match);
});
if (rv != Success) {
return rv;
}

29
security/pkix/lib/pkixocsp.cpp
Просмотреть файл

@ -24,7 +24,6 @@
#include <limits>
#include "pkix/bind.h"
#include "pkix/pkix.h"
#include "pkixcheck.h"
#include "pkixutil.h"
@ -298,8 +297,9 @@ VerifyEncodedOCSPResponse(TrustDomain& trustDomain, const struct CertID& certID,
thisUpdate, validThrough);
Reader input(encodedResponse);
Result rv = der::Nested(input, der::SEQUENCE,
bind(OCSPResponse, _1, ref(context)));
Result rv = der::Nested(input, der::SEQUENCE, [&context](Reader& r) {
return OCSPResponse(r, context);
});
if (rv != Success) {
return MapBadDERToMalformedOCSPResponse(rv);
}
@ -358,7 +358,9 @@ OCSPResponse(Reader& input, Context& context)
}
return der::Nested(input, der::CONTEXT_SPECIFIC | der::CONSTRUCTED | 0,
der::SEQUENCE, bind(ResponseBytes, _1, ref(context)));
der::SEQUENCE, [&context](Reader& r) {
return ResponseBytes(r, context);
});
}
// ResponseBytes ::= SEQUENCE {
@ -377,7 +379,9 @@ ResponseBytes(Reader& input, Context& context)
}
return der::Nested(input, der::OCTET_STRING, der::SEQUENCE,
bind(BasicResponse, _1, ref(context)));
[&context](Reader& r) {
return BasicResponse(r, context);
});
}
// BasicOCSPResponse ::= SEQUENCE {
@ -493,8 +497,9 @@ ResponseData(Reader& input, Context& context,
// responder will never return an empty response, and handling the case of an
// empty response makes things unnecessarily complicated.
rv = der::NestedOf(input, der::SEQUENCE, der::SEQUENCE,
der::EmptyAllowed::No,
bind(SingleResponse, _1, ref(context)));
der::EmptyAllowed::No, [&context](Reader& r) {
return SingleResponse(r, context);
});
if (rv != Success) {
return rv;
}
@ -517,8 +522,9 @@ static inline Result
SingleResponse(Reader& input, Context& context)
{
bool match = false;
Result rv = der::Nested(input, der::SEQUENCE,
bind(CertID, _1, cref(context), ref(match)));
Result rv = der::Nested(input, der::SEQUENCE, [&context, &match](Reader& r) {
return CertID(r, context, match);
});
if (rv != Success) {
return rv;
}
@ -599,8 +605,9 @@ SingleResponse(Reader& input, Context& context)
der::CONTEXT_SPECIFIC | der::CONSTRUCTED | 0;
if (input.Peek(NEXT_UPDATE_TAG)) {
Time nextUpdate(Time::uninitialized);
rv = der::Nested(input, NEXT_UPDATE_TAG,
bind(der::GeneralizedTime, _1, ref(nextUpdate)));
rv = der::Nested(input, NEXT_UPDATE_TAG, [&nextUpdate](Reader& r) {
return der::GeneralizedTime(r, nextUpdate);
});
if (rv != Success) {
return rv;
}

4
security/pkix/lib/pkixutil.h
Просмотреть файл

@ -140,8 +140,8 @@ private:
Input subjectAltName;
Input criticalNetscapeCertificateType;
Result RememberExtension(Reader& extnID, const Input& extnValue,
bool critical, /*out*/ bool& understood);
Result RememberExtension(Reader& extnID, Input extnValue, bool critical,
/*out*/ bool& understood);
BackCert(const BackCert&) = delete;
void operator=(const BackCert&) = delete;

1
security/pkix/moz.build
Просмотреть файл

@ -5,7 +5,6 @@
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
SOURCES += [
'lib/pkixbind.cpp',
'lib/pkixbuild.cpp',
'lib/pkixcert.cpp',
'lib/pkixcheck.cpp',

13
security/pkix/test/gtest/pkixder_input_tests.cpp
Просмотреть файл

@ -26,7 +26,6 @@
#include <vector>
#include <gtest/gtest.h>
#include "pkix/bind.h"
#include "pkixder.h"
using namespace mozilla::pkix;
@ -844,9 +843,10 @@ TEST_F(pkixder_input_tests, NestedOf)
std::vector<uint8_t> readValues;
ASSERT_EQ(Success,
NestedOf(input, SEQUENCE, INTEGER, EmptyAllowed::No,
mozilla::pkix::bind(NestedOfHelper, mozilla::pkix::_1,
mozilla::pkix::ref(readValues))));
NestedOf(input, SEQUENCE, INTEGER, EmptyAllowed::No,
[&readValues](Reader& r) {
return NestedOfHelper(r, readValues);
}));
ASSERT_EQ((size_t) 3, readValues.size());
ASSERT_EQ(0x01, readValues[0]);
ASSERT_EQ(0x02, readValues[1]);
@ -862,8 +862,9 @@ TEST_F(pkixder_input_tests, NestedOfWithTruncatedData)
std::vector<uint8_t> readValues;
ASSERT_EQ(Result::ERROR_BAD_DER,
NestedOf(input, SEQUENCE, INTEGER, EmptyAllowed::No,
mozilla::pkix::bind(NestedOfHelper, mozilla::pkix::_1,
mozilla::pkix::ref(readValues))));
[&readValues](Reader& r) {
return NestedOfHelper(r, readValues);
}));
ASSERT_EQ((size_t) 0, readValues.size());
}

1
security/pkix/test/gtest/pkixder_universal_types_tests.cpp
Просмотреть файл

@ -26,7 +26,6 @@
#include <vector>
#include <gtest/gtest.h>
#include "pkix/bind.h"
#include "pkixder.h"
#include "pkixtestutil.h"
#include "stdint.h"