224889 2021-04-21 13:12:54 -0700 Improve our constructDeletedValue() template specializations 2021-04-24 15:02:52 -0700 1 1 1 Unclassified WebKit WebCore Misc. WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=224755 https://bugs.webkit.org/show_bug.cgi?id=224975 InRadar P2 Normal --- 1 cdumez cdumez achristensen alecflett beidson cgarcia changseok darin esprehn+autocc ews-watchlist ggaren glenn japhet jsbell kangil.han kondapallykalyan mcatanzaro mmaxfield pdr webkit-bug-importer oldest_to_newest 1752891 0 cdumez 2021-04-21 13:12:54 -0700 Improve our constructDeletedValue() template specializations. 1752903 1 426738 cdumez 2021-04-21 13:28:39 -0700 Created attachment 426738 Patch 1752929 2 426745 cdumez 2021-04-21 14:19:24 -0700 Created attachment 426745 Patch 1752943 3 darin 2021-04-21 15:02:27 -0700 To review this we need to know safeToCompareToEmptyOrDeleted values for each class. If it’s true then we need to audit the == functions with the deleted value in mind. 1752945 4 426738 cdumez 2021-04-21 15:14:15 -0700 Comment on attachment 426738 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=426738&action=review > Source/WebCore/Modules/indexeddb/IDBKeyData.h:209 > + static void constructDeletedValue(IDBKeyData& key) { key.m_isDeletedValue = true; } safeToCompareToEmptyOrDeleted is false for IDBKeyData. > Source/WebCore/Modules/indexeddb/shared/IDBResourceIdentifier.h:111 > static void constructDeletedValue(IDBResourceIdentifier& identifier) safeToCompareToEmptyOrDeleted is false. > Source/WebCore/PAL/pal/SessionID.h:118 > + static void constructDeletedValue(PAL::SessionID& slot) { new (NotNull, &slot) PAL::SessionID(HashTableDeletedValue); } safeToCompareToEmptyOrDeleted is true but I did not change behavior here. > Source/WebCore/dom/MessagePortIdentifier.h:103 > + static void constructDeletedValue(WebCore::MessagePortIdentifier& slot) { new (NotNull, &slot.processIdentifier) WebCore::ProcessIdentifier(WTF::HashTableDeletedValue); } safeToCompareToEmptyOrDeleted is true. emptyValue is 0 and deletedValue is std::numeric_limits<uint64_t>::max() so this is OK. > Source/WebCore/history/BackForwardItemIdentifier.h:117 > + static void constructDeletedValue(WebCore::BackForwardItemIdentifier& slot) { new (NotNull, &slot.processIdentifier) WebCore::ProcessIdentifier(WTF::HashTableDeletedValue); } safeToCompareToEmptyOrDeleted is true. Empty value is 0, deleted value is std::numeric_limits<uint64_t>::max() so this is OK. > Source/WebCore/layout/LayoutUnits.h:247 > + static void constructDeletedValue(WebCore::Layout::SlotPosition& slot) { slot.column = std::numeric_limits<size_t>::max(); } safeToCompareToEmptyOrDeleted is true. Empty value is column=0/row=std::numeric_limits<size_t>::max(). Deleted value is column=std::numeric_limits<size_t>::max() so they cannot be equal. 1752946 5 426738 cdumez 2021-04-21 15:26:09 -0700 Comment on attachment 426738 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=426738&action=review > Source/WebCore/loader/PrivateClickMeasurement.h:525 > + static void constructDeletedValue(WebCore::PrivateClickMeasurement::SourceSite& slot) { new (NotNull, &slot.registrableDomain) WebCore::RegistrableDomain(WTF::HashTableDeletedValue); } safeToCompareToEmptyOrDeleted is false. > Source/WebCore/loader/PrivateClickMeasurement.h:532 > + static void constructDeletedValue(WebCore::PrivateClickMeasurement::AttributionDestinationSite& slot) { new (NotNull, &slot.registrableDomain) WebCore::RegistrableDomain(WTF::HashTableDeletedValue); } safeToCompareToEmptyOrDeleted is false. > Source/WebCore/page/ClientOrigin.h:105 > + static void constructDeletedValue(WebCore::ClientOrigin& slot) { new (NotNull, &slot.topOrigin) WebCore::SecurityOriginData(WTF::HashTableDeletedValue); } safeToCompareToEmptyOrDeleted is false. > Source/WebCore/page/GlobalWindowIdentifier.h:97 > + static void constructDeletedValue(WebCore::GlobalWindowIdentifier& slot) { new (NotNull, &slot.windowIdentifier) WebCore::WindowIdentifier(WTF::HashTableDeletedValue); } safeToCompareToEmptyOrDeleted is true. Empty value is 0, DeletedValue is std::numeric_limits<uint64_t>::max() so comparison is safe. > Source/WebCore/platform/Cookie.h:172 > + static void constructDeletedValue(WebCore::Cookie& slot) { new (NotNull, &slot.name) String(WTF::HashTableDeletedValue); } safeToCompareToEmptyOrDeleted is false. > Source/WebCore/platform/graphics/FontCache.h:210 > + static void constructDeletedValue(FontCascadeCacheKey& slot) { new (NotNull, &slot.fontDescriptionKey) FontDescriptionKey(WTF::HashTableDeletedValue); } safeToCompareToEmptyOrDeleted is false. > Source/WebCore/platform/graphics/IntPointHash.h:38 > + static void constructDeletedValue(WebCore::IntPoint& slot) { slot.setX(std::numeric_limits<int>::min()); } safeToCompareToEmptyOrDeleted is true. Empty value is x=0/y=std::numeric_limits<int>::min(). Deleted value is x=std::numeric_limits<int>::min()/y=0 so comparison is safe. > Source/WebCore/rendering/CSSValueKey.h:92 > + static void constructDeletedValue(WebCore::CSSValueKey& slot) { new (NotNull, &slot) WebCore::CSSValueKey { WebCore::CSSValueInvalid, true, true}; } safeToCompareToEmptyOrDeleted is true. Empty value is using false for the booleans while deleted value is using true for the booleans. Comparison is safe and I did not change behavior. > Source/WebCore/workers/service/ServiceWorkerClientIdentifier.h:112 > + static void constructDeletedValue(WebCore::ServiceWorkerClientIdentifier& slot) { new (NotNull, &slot.serverConnectionIdentifier) WebCore::SWServerConnectionIdentifier(HashTableDeletedValue); } safeToCompareToEmptyOrDeleted is true. Empty value is 0, deleted value is std::numeric_limits<uint64_t>::max() so comparison is safe. > Source/WebKit/NetworkProcess/cache/NetworkCache.h:86 > + static void constructDeletedValue(WebKit::NetworkCache::GlobalFrameID& slot) { new (NotNull, &slot.webPageID) WebCore::PageIdentifier(WTF::HashTableDeletedValue); } safeToCompareToEmptyOrDeleted is true. Empty value is 0, deleted value is std::numeric_limits<uint64_t>::max() so comparison is safe. > Source/WebKit/Platform/IPC/StringReference.h:106 > + static void constructDeletedValue(IPC::StringReference& stringReference) { stringReference.m_size = std::numeric_limits<size_t>::max(); } safeToCompareToEmptyOrDeleted is true. Empty value uses 0 for m_size while deleted value uses std::numeric_limits<size_t>::max() so this is safe to compare. > Source/WebKit/Shared/CallbackID.h:121 > + static void constructDeletedValue(WebKit::CallbackID& slot) { HashTraits<uint64_t>::constructDeletedValue(slot.m_id); } safeToCompareToEmptyOrDeleted is true. empty value is HashTraits<uint64_t>::emptyValue() (so 0) and deleted value is HashTraits<uint64_t>::constructDeletedValue() (so std::numeric_limits<uint64_t>::max()) so this should be safe to compare. > Source/WebKitLegacy/mac/History/BinaryPropertyList.cpp:77 > + static void constructDeletedValue(IntegerArray& slot) { HashTraits<size_t>::constructDeletedValue(slot.m_size); } safeToCompareToEmptyOrDeleted is true. emptyValue calls the default constructor of IntegerArray, which sets m_integers & m_size to 0. Deleted value uses HashTraits<size_t>::constructDeletedValue() for m_size, which ends up being std::numeric_limits<size_t>::max() so this should be safe to compare. 1752947 6 cdumez 2021-04-21 15:28:09 -0700 (In reply to Darin Adler from comment #3) > To review this we need to know safeToCompareToEmptyOrDeleted values for each > class. If it’s true then we need to audit the == functions with the deleted > value in mind. I had this in mind when I wrote the patch but I did another pass to be safe and added comments on the patch to facilitate review. 1752951 7 darin 2021-04-21 15:37:21 -0700 (In reply to Chris Dumez from comment #6) > I had this in mind when I wrote the patch but I did another pass to be safe > and added comments on the patch to facilitate review. Yes, looks great. To state the obvious, the two kinds of unsafe to worry about would be a crash when doing the comparison or a false positive where it would compare as equal. Most of your comments are about the "false positive" half. 1753159 8 426738 cdumez 2021-04-22 07:47:28 -0700 Comment on attachment 426738 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=426738&action=review >> Source/WebCore/dom/MessagePortIdentifier.h:103 >> + static void constructDeletedValue(WebCore::MessagePortIdentifier& slot) { new (NotNull, &slot.processIdentifier) WebCore::ProcessIdentifier(WTF::HashTableDeletedValue); } > > safeToCompareToEmptyOrDeleted is true. emptyValue is 0 and deletedValue is std::numeric_limits<uint64_t>::max() so this is OK. I am initializing the exact same data member as before so no additional crash risk AFAICT. >> Source/WebCore/history/BackForwardItemIdentifier.h:117 >> + static void constructDeletedValue(WebCore::BackForwardItemIdentifier& slot) { new (NotNull, &slot.processIdentifier) WebCore::ProcessIdentifier(WTF::HashTableDeletedValue); } > > safeToCompareToEmptyOrDeleted is true. Empty value is 0, deleted value is std::numeric_limits<uint64_t>::max() so this is OK. I am initializing the exact same data member as before so no additional crash risk AFAICT. >> Source/WebCore/layout/LayoutUnits.h:247 >> + static void constructDeletedValue(WebCore::Layout::SlotPosition& slot) { slot.column = std::numeric_limits<size_t>::max(); } > > safeToCompareToEmptyOrDeleted is true. Empty value is column=0/row=std::numeric_limits<size_t>::max(). Deleted value is column=std::numeric_limits<size_t>::max() so they cannot be equal. row is newly uninitialized for the deleted value and operator== looks like so: ``` inline bool operator==(const SlotPosition& a, const SlotPosition& b) { return a.column == b.column && a.row == b.row; } ``` Those are size_t types though and AFAIK, even if uninitialized, doing a comparison should not cause a crash. >> Source/WebCore/page/GlobalWindowIdentifier.h:97 >> + static void constructDeletedValue(WebCore::GlobalWindowIdentifier& slot) { new (NotNull, &slot.windowIdentifier) WebCore::WindowIdentifier(WTF::HashTableDeletedValue); } > > safeToCompareToEmptyOrDeleted is true. Empty value is 0, DeletedValue is std::numeric_limits<uint64_t>::max() so comparison is safe. I am initialized the exact same data member as before so no new crash risk AFAICT. >> Source/WebCore/platform/graphics/IntPointHash.h:38 >> + static void constructDeletedValue(WebCore::IntPoint& slot) { slot.setX(std::numeric_limits<int>::min()); } > > safeToCompareToEmptyOrDeleted is true. Empty value is x=0/y=std::numeric_limits<int>::min(). Deleted value is x=std::numeric_limits<int>::min()/y=0 so comparison is safe. y is newly uninitialized for the deleted value. operator== looks like so: ``` inline bool operator==(const IntPoint& a, const IntPoint& b) { return a.x() == b.x() && a.y() == b.y(); } ``` The data members have int type and comparison should not crash even if uninitialized. >> Source/WebCore/rendering/CSSValueKey.h:92 >> + static void constructDeletedValue(WebCore::CSSValueKey& slot) { new (NotNull, &slot) WebCore::CSSValueKey { WebCore::CSSValueInvalid, true, true}; } > > safeToCompareToEmptyOrDeleted is true. Empty value is using false for the booleans while deleted value is using true for the booleans. Comparison is safe and I did not change behavior. No new risk of crash AFAIK because this is still doing a full initialization. >> Source/WebCore/workers/service/ServiceWorkerClientIdentifier.h:112 >> + static void constructDeletedValue(WebCore::ServiceWorkerClientIdentifier& slot) { new (NotNull, &slot.serverConnectionIdentifier) WebCore::SWServerConnectionIdentifier(HashTableDeletedValue); } > > safeToCompareToEmptyOrDeleted is true. Empty value is 0, deleted value is std::numeric_limits<uint64_t>::max() so comparison is safe. No new risk of crash before I am initializing the exact same data member as before. >> Source/WebKit/NetworkProcess/cache/NetworkCache.h:86 >> + static void constructDeletedValue(WebKit::NetworkCache::GlobalFrameID& slot) { new (NotNull, &slot.webPageID) WebCore::PageIdentifier(WTF::HashTableDeletedValue); } > > safeToCompareToEmptyOrDeleted is true. Empty value is 0, deleted value is std::numeric_limits<uint64_t>::max() so comparison is safe. No new risk of crash before I am initializing the exact same data member as before. >> Source/WebKit/Platform/IPC/StringReference.h:106 >> + static void constructDeletedValue(IPC::StringReference& stringReference) { stringReference.m_size = std::numeric_limits<size_t>::max(); } > > safeToCompareToEmptyOrDeleted is true. Empty value uses 0 for m_size while deleted value uses std::numeric_limits<size_t>::max() so this is safe to compare. m_data is newly uninitialized in the deleted value case. operator== looks like so: ``` inline bool operator==(const StringReference& a, const StringReference& b) { return a.size() == b.size() && !memcmp(a.data(), b.data(), a.size()); } ``` The sizes would not match so we wouldn't do a memcmp(). The memcpy() would be equally bad before or after my change. >> Source/WebKit/Shared/CallbackID.h:121 >> + static void constructDeletedValue(WebKit::CallbackID& slot) { HashTraits<uint64_t>::constructDeletedValue(slot.m_id); } > > safeToCompareToEmptyOrDeleted is true. empty value is HashTraits<uint64_t>::emptyValue() (so 0) and deleted value is HashTraits<uint64_t>::constructDeletedValue() (so std::numeric_limits<uint64_t>::max()) so this should be safe to compare. No new risk of crash as far as I can tell before I am initializing the exact same data member as before. >> Source/WebKitLegacy/mac/History/BinaryPropertyList.cpp:77 >> + static void constructDeletedValue(IntegerArray& slot) { HashTraits<size_t>::constructDeletedValue(slot.m_size); } > > safeToCompareToEmptyOrDeleted is true. emptyValue calls the default constructor of IntegerArray, which sets m_integers & m_size to 0. Deleted value uses HashTraits<size_t>::constructDeletedValue() for m_size, which ends up being std::numeric_limits<size_t>::max() so this should be safe to compare. m_integers is newly uninitialized for the deleted value. operator== looks like so: ``` inline bool operator==(const IntegerArray& a, const IntegerArray& b) { return a.m_integers == b.m_integers && a.m_size == b.m_size; } ``` Even though m_integers is now uninitialized, this is doing a pure pointer comparison and should not crash AFAIK. 1753585 9 cdumez 2021-04-23 07:59:07 -0700 Anyone wants to review this? I tried to facilitate the review as much as possible by adding comments. This patch was inspired by Darin's feedback here: - https://bugs.webkit.org/show_bug.cgi?id=224755#c34 - https://bugs.webkit.org/show_bug.cgi?id=224755#c47 1753599 10 426738 mcatanzaro 2021-04-23 09:05:43 -0700 Comment on attachment 426738 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=426738&action=review >> Source/WebCore/Modules/indexeddb/IDBKeyData.h:209 >> + static void constructDeletedValue(IDBKeyData& key) { key.m_isDeletedValue = true; } > > safeToCompareToEmptyOrDeleted is false for IDBKeyData. Good. >> Source/WebCore/Modules/indexeddb/shared/IDBResourceIdentifier.h:111 >> static void constructDeletedValue(IDBResourceIdentifier& identifier) > > safeToCompareToEmptyOrDeleted is false. Good. >> Source/WebCore/PAL/pal/SessionID.h:118 >> + static void constructDeletedValue(PAL::SessionID& slot) { new (NotNull, &slot) PAL::SessionID(HashTableDeletedValue); } > > safeToCompareToEmptyOrDeleted is true but I did not change behavior here. Good. This one is safe anyway, because you're constructing the entire PAL::SessionID. >>> Source/WebCore/dom/MessagePortIdentifier.h:103 >>> + static void constructDeletedValue(WebCore::MessagePortIdentifier& slot) { new (NotNull, &slot.processIdentifier) WebCore::ProcessIdentifier(WTF::HashTableDeletedValue); } >> >> safeToCompareToEmptyOrDeleted is true. emptyValue is 0 and deletedValue is std::numeric_limits<uint64_t>::max() so this is OK. > > I am initializing the exact same data member as before so no additional crash risk AFAICT. Well you're right that you don't make this any worse than it was before, but the preexisting code is unsafe. The operator== first compares processIdentifier, then it compares portIdentifier. If both MessagePortIdentifierHash objects being compared are HashTableDeletedValue, operator== will read uninitialized data. That may be unlikely but IMO we should think harder about this one. We could either change operator== to consider only processIdentifier in case it matches HashTableDeletedValue, or change constructDeletedValue to also initialize portIdentifier. If we assume that two HashTableDeletedValues should never be compared, then it would be safe. But that doesn't seem very robust. >>> Source/WebCore/history/BackForwardItemIdentifier.h:117 >>> + static void constructDeletedValue(WebCore::BackForwardItemIdentifier& slot) { new (NotNull, &slot.processIdentifier) WebCore::ProcessIdentifier(WTF::HashTableDeletedValue); } >> >> safeToCompareToEmptyOrDeleted is true. Empty value is 0, deleted value is std::numeric_limits<uint64_t>::max() so this is OK. > > I am initializing the exact same data member as before so no additional crash risk AFAICT. Same problem, here itemIdentifier is left uninitialized, so uninitialized data will be read when comparing two BackForwardItemIdentifiers that are both HashTableDeletedValue. >>> Source/WebCore/layout/LayoutUnits.h:247 >>> + static void constructDeletedValue(WebCore::Layout::SlotPosition& slot) { slot.column = std::numeric_limits<size_t>::max(); } >> >> safeToCompareToEmptyOrDeleted is true. Empty value is column=0/row=std::numeric_limits<size_t>::max(). Deleted value is column=std::numeric_limits<size_t>::max() so they cannot be equal. > > row is newly uninitialized for the deleted value and operator== looks like so: > ``` > inline bool operator==(const SlotPosition& a, const SlotPosition& b) > { > return a.column == b.column && a.row == b.row; > } > ``` > > Those are size_t types though and AFAIK, even if uninitialized, doing a comparison should not cause a crash. Again, it works except when comparing two HashTableDeletedValues, then we read uninitialized data. >> Source/WebCore/loader/PrivateClickMeasurement.h:525 >> + static void constructDeletedValue(WebCore::PrivateClickMeasurement::SourceSite& slot) { new (NotNull, &slot.registrableDomain) WebCore::RegistrableDomain(WTF::HashTableDeletedValue); } > > safeToCompareToEmptyOrDeleted is false. Good. Nice cleanup with this one. >> Source/WebCore/loader/PrivateClickMeasurement.h:532 >> + static void constructDeletedValue(WebCore::PrivateClickMeasurement::AttributionDestinationSite& slot) { new (NotNull, &slot.registrableDomain) WebCore::RegistrableDomain(WTF::HashTableDeletedValue); } > > safeToCompareToEmptyOrDeleted is false. Good. >> Source/WebCore/page/ClientOrigin.h:105 >> + static void constructDeletedValue(WebCore::ClientOrigin& slot) { new (NotNull, &slot.topOrigin) WebCore::SecurityOriginData(WTF::HashTableDeletedValue); } > > safeToCompareToEmptyOrDeleted is false. Good. >>> Source/WebCore/page/GlobalWindowIdentifier.h:97 >>> + static void constructDeletedValue(WebCore::GlobalWindowIdentifier& slot) { new (NotNull, &slot.windowIdentifier) WebCore::WindowIdentifier(WTF::HashTableDeletedValue); } >> >> safeToCompareToEmptyOrDeleted is true. Empty value is 0, DeletedValue is std::numeric_limits<uint64_t>::max() so comparison is safe. > > I am initialized the exact same data member as before so no new crash risk AFAICT. Well it is not worse than the preexisting code, but it's not safe. This one is actually the worst so far because the comparison function checks the uninitialized value first, so it's *always* comparing uninitialized memory when comparing any normal GlobalWindowIdentifier against a HashTableDeletedValue GlobalWindowIdentifier. The other cases I complain about here only matter when comparing two HashTableDeletedValues, which maybe we don't do, but this one is clearly bad regardless. So please reconsider this one. >> Source/WebCore/platform/Cookie.h:172 >> + static void constructDeletedValue(WebCore::Cookie& slot) { new (NotNull, &slot.name) String(WTF::HashTableDeletedValue); } > > safeToCompareToEmptyOrDeleted is false. Good. >> Source/WebCore/platform/graphics/FontCache.h:210 >> + static void constructDeletedValue(FontCascadeCacheKey& slot) { new (NotNull, &slot.fontDescriptionKey) FontDescriptionKey(WTF::HashTableDeletedValue); } > > safeToCompareToEmptyOrDeleted is false. Good. >>> Source/WebCore/platform/graphics/IntPointHash.h:38 >>> + static void constructDeletedValue(WebCore::IntPoint& slot) { slot.setX(std::numeric_limits<int>::min()); } >> >> safeToCompareToEmptyOrDeleted is true. Empty value is x=0/y=std::numeric_limits<int>::min(). Deleted value is x=std::numeric_limits<int>::min()/y=0 so comparison is safe. > > y is newly uninitialized for the deleted value. operator== looks like so: > ``` > inline bool operator==(const IntPoint& a, const IntPoint& b) > { > return a.x() == b.x() && a.y() == b.y(); > } > ``` > > The data members have int type and comparison should not crash even if uninitialized. It works except when comparing two HashTableDeletedValues. (I expect safeToCompareToEmptyOrDeleted means "it will always work properly and not cause valgrind to complain" and not "it won't crash.") >>> Source/WebCore/rendering/CSSValueKey.h:92 >>> + static void constructDeletedValue(WebCore::CSSValueKey& slot) { new (NotNull, &slot) WebCore::CSSValueKey { WebCore::CSSValueInvalid, true, true}; } >> >> safeToCompareToEmptyOrDeleted is true. Empty value is using false for the booleans while deleted value is using true for the booleans. Comparison is safe and I did not change behavior. > > No new risk of crash AFAIK because this is still doing a full initialization. I agree, this one is safe. Good. >>> Source/WebCore/workers/service/ServiceWorkerClientIdentifier.h:112 >>> + static void constructDeletedValue(WebCore::ServiceWorkerClientIdentifier& slot) { new (NotNull, &slot.serverConnectionIdentifier) WebCore::SWServerConnectionIdentifier(HashTableDeletedValue); } >> >> safeToCompareToEmptyOrDeleted is true. Empty value is 0, deleted value is std::numeric_limits<uint64_t>::max() so comparison is safe. > > No new risk of crash before I am initializing the exact same data member as before. Again, it works except when comparing two HashTableDeletedValues, then we read uninitialized data. >>> Source/WebKit/NetworkProcess/cache/NetworkCache.h:86 >>> + static void constructDeletedValue(WebKit::NetworkCache::GlobalFrameID& slot) { new (NotNull, &slot.webPageID) WebCore::PageIdentifier(WTF::HashTableDeletedValue); } >> >> safeToCompareToEmptyOrDeleted is true. Empty value is 0, deleted value is std::numeric_limits<uint64_t>::max() so comparison is safe. > > No new risk of crash before I am initializing the exact same data member as before. Again, it works except when comparing two HashTableDeletedValues, then we read uninitialized data. >>> Source/WebKit/Platform/IPC/StringReference.h:106 >>> + static void constructDeletedValue(IPC::StringReference& stringReference) { stringReference.m_size = std::numeric_limits<size_t>::max(); } >> >> safeToCompareToEmptyOrDeleted is true. Empty value uses 0 for m_size while deleted value uses std::numeric_limits<size_t>::max() so this is safe to compare. > > m_data is newly uninitialized in the deleted value case. operator== looks like so: > ``` > inline bool operator==(const StringReference& a, const StringReference& b) > { > return a.size() == b.size() && !memcmp(a.data(), b.data(), a.size()); > } > ``` > > The sizes would not match so we wouldn't do a memcmp(). The memcpy() would be equally bad before or after my change. Again, it works except when comparing two HashTableDeletedValues, then we read uninitialized data. >>> Source/WebKit/Shared/CallbackID.h:121 >>> + static void constructDeletedValue(WebKit::CallbackID& slot) { HashTraits<uint64_t>::constructDeletedValue(slot.m_id); } >> >> safeToCompareToEmptyOrDeleted is true. empty value is HashTraits<uint64_t>::emptyValue() (so 0) and deleted value is HashTraits<uint64_t>::constructDeletedValue() (so std::numeric_limits<uint64_t>::max()) so this should be safe to compare. > > No new risk of crash as far as I can tell before I am initializing the exact same data member as before. This one is safe because m_id is the only data member checked by operator==. Good. >>> Source/WebKitLegacy/mac/History/BinaryPropertyList.cpp:77 >>> + static void constructDeletedValue(IntegerArray& slot) { HashTraits<size_t>::constructDeletedValue(slot.m_size); } >> >> safeToCompareToEmptyOrDeleted is true. emptyValue calls the default constructor of IntegerArray, which sets m_integers & m_size to 0. Deleted value uses HashTraits<size_t>::constructDeletedValue() for m_size, which ends up being std::numeric_limits<size_t>::max() so this should be safe to compare. > > m_integers is newly uninitialized for the deleted value. operator== looks like so: > ``` > inline bool operator==(const IntegerArray& a, const IntegerArray& b) > { > return a.m_integers == b.m_integers && a.m_size == b.m_size; > } > ``` > > Even though m_integers is now uninitialized, this is doing a pure pointer comparison and should not crash AFAIK. Well sure, this function *itself* won't crash, but this is the same case as GlobalWindowIdentifier: the comparison function checks the uninitialized value first, so it's *always* comparing uninitialized memory when comparing any normal IntegerArray against a HashTableDeletedValue IntegerArray. 1753606 11 426738 cdumez 2021-04-23 09:18:10 -0700 Comment on attachment 426738 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=426738&action=review >>>> Source/WebCore/dom/MessagePortIdentifier.h:103 >>>> + static void constructDeletedValue(WebCore::MessagePortIdentifier& slot) { new (NotNull, &slot.processIdentifier) WebCore::ProcessIdentifier(WTF::HashTableDeletedValue); } >>> >>> safeToCompareToEmptyOrDeleted is true. emptyValue is 0 and deletedValue is std::numeric_limits<uint64_t>::max() so this is OK. >> >> I am initializing the exact same data member as before so no additional crash risk AFAICT. > > Well you're right that you don't make this any worse than it was before, but the preexisting code is unsafe. The operator== first compares processIdentifier, then it compares portIdentifier. If both MessagePortIdentifierHash objects being compared are HashTableDeletedValue, operator== will read uninitialized data. That may be unlikely but IMO we should think harder about this one. We could either change operator== to consider only processIdentifier in case it matches HashTableDeletedValue, or change constructDeletedValue to also initialize portIdentifier. > > If we assume that two HashTableDeletedValues should never be compared, then it would be safe. But that doesn't seem very robust. Looks to me that what you are worried about (2 HashTableDeletedValues being compared) would only happen when trying to lookup/store a HashTableDeletedValues in a HashMap. My answer is that this is not something that is supported. Also, even if the 2 would not necessarily compute as equal due to uninitialized memory, it would not crash. But again, AFAIK (and looking at the HashTable implementation), this is a non-issue. 1753614 12 426738 darin 2021-04-23 09:34:06 -0700 Comment on attachment 426738 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=426738&action=review I’m going to say review+; this is really hard to review. >>>>> Source/WebCore/dom/MessagePortIdentifier.h:103 >>>>> + static void constructDeletedValue(WebCore::MessagePortIdentifier& slot) { new (NotNull, &slot.processIdentifier) WebCore::ProcessIdentifier(WTF::HashTableDeletedValue); } >>>> >>>> safeToCompareToEmptyOrDeleted is true. emptyValue is 0 and deletedValue is std::numeric_limits<uint64_t>::max() so this is OK. >>> >>> I am initializing the exact same data member as before so no additional crash risk AFAICT. >> >> Well you're right that you don't make this any worse than it was before, but the preexisting code is unsafe. The operator== first compares processIdentifier, then it compares portIdentifier. If both MessagePortIdentifierHash objects being compared are HashTableDeletedValue, operator== will read uninitialized data. That may be unlikely but IMO we should think harder about this one. We could either change operator== to consider only processIdentifier in case it matches HashTableDeletedValue, or change constructDeletedValue to also initialize portIdentifier. >> >> If we assume that two HashTableDeletedValues should never be compared, then it would be safe. But that doesn't seem very robust. > > Looks to me that what you are worried about (2 HashTableDeletedValues being compared) would only happen when trying to lookup/store a HashTableDeletedValues in a HashMap. My answer is that this is not something that is supported. > Also, even if the 2 would not necessarily compute as equal due to uninitialized memory, it would not crash. But again, AFAIK (and looking at the HashTable implementation), this is a non-issue. Chris is right; we don’t need to support comparing two deleted values with each other, even if safeToCompareToEmptyOrDeleted is true. >>>> Source/WebKitLegacy/mac/History/BinaryPropertyList.cpp:77 >>>> + static void constructDeletedValue(IntegerArray& slot) { HashTraits<size_t>::constructDeletedValue(slot.m_size); } >>> >>> safeToCompareToEmptyOrDeleted is true. emptyValue calls the default constructor of IntegerArray, which sets m_integers & m_size to 0. Deleted value uses HashTraits<size_t>::constructDeletedValue() for m_size, which ends up being std::numeric_limits<size_t>::max() so this should be safe to compare. >> >> m_integers is newly uninitialized for the deleted value. operator== looks like so: >> ``` >> inline bool operator==(const IntegerArray& a, const IntegerArray& b) >> { >> return a.m_integers == b.m_integers && a.m_size == b.m_size; >> } >> ``` >> >> Even though m_integers is now uninitialized, this is doing a pure pointer comparison and should not crash AFAIK. > > Well sure, this function *itself* won't crash, but this is the same case as GlobalWindowIdentifier: the comparison function checks the uninitialized value first, so it's *always* comparing uninitialized memory when comparing any normal IntegerArray against a HashTableDeletedValue IntegerArray. Not sure it’s a real problem. Depends on what kind of debugging tool we are using. Outside of debugging tools, there are no magic "uninitialized" values that can make integer comparison unsafe. 1753616 13 ews-feeder 2021-04-23 09:55:57 -0700 Committed r276502 (236960@main): <https://commits.webkit.org/236960@main> All reviewed patches have been landed. Closing bug and clearing flags on attachment 426738. 1753626 14 mcatanzaro 2021-04-23 10:31:47 -0700 (In reply to Darin Adler from comment #12) > Not sure it’s a real problem. Depends on what kind of debugging tool we are > using. Outside of debugging tools, there are no magic "uninitialized" values > that can make integer comparison unsafe. It's a real problem because the operator== is not going to work properly. The changes to GlobalWindowIdentifier and IntegerArray are not safe. Let's look at IntegerArray: inline bool operator==(const IntegerArray& a, const IntegerArray& b) { return a.m_integers == b.m_integers && a.m_size == b.m_size; } Let's say a is a normal IntegerArray and b is a HashTableDeletedValue. Then b.m_integers is uninitialized data. The first comparison will *probably* fail and return false, but we could just get unlucky. Comparing m_size first would avoid this. A similar change would fix GlobalWindowIdentifier. Alternatively, safeToCompareToEmptyOrDeleted should be changed to false. 1753628 15 cdumez 2021-04-23 10:34:30 -0700 (In reply to Michael Catanzaro from comment #14) > (In reply to Darin Adler from comment #12) > > Not sure it’s a real problem. Depends on what kind of debugging tool we are > > using. Outside of debugging tools, there are no magic "uninitialized" values > > that can make integer comparison unsafe. > > It's a real problem because the operator== is not going to work properly. > The changes to GlobalWindowIdentifier and IntegerArray are not safe. Let's > look at IntegerArray: > > inline bool operator==(const IntegerArray& a, const IntegerArray& b) > { > return a.m_integers == b.m_integers && a.m_size == b.m_size; > } > > Let's say a is a normal IntegerArray and b is a HashTableDeletedValue. Then > b.m_integers is uninitialized data. The first comparison will *probably* > fail and return false, but we could just get unlucky. Comparing m_size first > would avoid this. A similar change would fix GlobalWindowIdentifier. > Alternatively, safeToCompareToEmptyOrDeleted should be changed to false. What you just said does not seem to demonstrate that operator== is not going to work properly. Yes, when comparing a valid "a" and a deleted "b", then m_integers might match. That's fine because m_size won't. 1753648 16 mcatanzaro 2021-04-23 11:00:15 -0700 OK, it's unlikely that m_size would match, that's true. 1753658 17 darin 2021-04-23 11:12:15 -0700 (In reply to Michael Catanzaro from comment #16) > OK, it's unlikely that m_size would match, that's true. If it’s "unlikely" we have a problem. It needs to be impossible. We must make sure there is no way we can allocate an array that big. If we don’t prevent that, then it’s not a suitable deleted value for the hash table and could even create a problem like a security vulnerability. I *think* it’s impossible here, but we need to verify that. 1753659 18 darin 2021-04-23 11:13:01 -0700 I think it’s impossible because we would exhaust memory allocating the m_integers. 1753660 19 darin 2021-04-23 11:13:33 -0700 (In reply to Chris Dumez from comment #15) > (In reply to Michael Catanzaro from comment #14) > > (In reply to Darin Adler from comment #12) > > > Not sure it’s a real problem. Depends on what kind of debugging tool we are > > > using. Outside of debugging tools, there are no magic "uninitialized" values > > > that can make integer comparison unsafe. I meant scalar comparison, not integer comparison. 1753900 20 webkit-bug-importer 2021-04-24 15:02:52 -0700 <rdar://problem/77110024> 426738 2021-04-21 13:28:39 -0700 2021-04-23 09:55:59 -0700 Patch bug-224889-20210421132838.patch text/plain 37505 cdumez U3VidmVyc2lvbiBSZXZpc2lvbjogMjc2MzgyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMTEzNjQzMzdjNWFmZGRj YTM3M2ZjMTdiZTZhZmQzNjgzMzQ1ZTU1MC4uYWM1M2ZiM2ZmZjYyYzE4MDc5ZGViNTkzZWVlYjc2 MmI4YjhiMjhlMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDczIEBACisyMDIxLTA0LTIxICBDaHJp cyBEdW1leiAgPGNkdW1lekBhcHBsZS5jb20+CisKKyAgICAgICAgSW1wcm92ZSBvdXIgY29uc3Ry dWN0RGVsZXRlZFZhbHVlKCkgdGVtcGxhdGUgc3BlY2lhbGl6YXRpb25zCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjQ4ODkKKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBJbXByb3ZlIG91ciBjb25zdHJ1Y3RE ZWxldGVkVmFsdWUoKSB0ZW1wbGF0ZSBzcGVjaWFsaXphdGlvbnMgYW5kIG1ha2UgdGhlbSBtb3Jl IGNvbnNpc3RlbnQ6CisgICAgICAgIC0gVXNlIHBsYWNlbWVudC1uZXcgaW5zdGVhZCBvZiBvYmpl Y3QgYXNzaWdubWVudCBzaW5jZSB3ZSBkb24ndCB3YW50L25lZWQgdG8gZGVzdHJveSB0aGUKKyAg ICAgICAgICBleGlzdGluZyBvYmplY3QgKHNpbmNlIGl0IGlzIHVuaW5pdGlhbGl6ZWQpLgorICAg ICAgICAtIERvIGFzIGxpdHRsZSBpbml0aWFsaXphdGlvbiBhcyBwb3NzaWJsZSBmb3IgcGVyZm9y bWFuY2UgcmVhc29ucy4KKworICAgICAgICAqIE1vZHVsZXMvaW5kZXhlZGRiL0lEQktleURhdGEu Y3BwOgorICAgICAgICAoV2ViQ29yZTo6SURCS2V5RGF0YTo6ZGVsZXRlZFZhbHVlKTogRGVsZXRl ZC4KKyAgICAgICAgKiBNb2R1bGVzL2luZGV4ZWRkYi9JREJLZXlEYXRhLmg6CisgICAgICAgIChX ZWJDb3JlOjpJREJLZXlEYXRhSGFzaFRyYWl0czo6Y29uc3RydWN0RGVsZXRlZFZhbHVlKToKKyAg ICAgICAgKFdlYkNvcmU6OklEQktleURhdGFIYXNoVHJhaXRzOjppc0RlbGV0ZWRWYWx1ZSk6Cisg ICAgICAgIChXZWJDb3JlOjpJREJLZXlEYXRhOjppc0RlbGV0ZWRWYWx1ZSBjb25zdCk6IERlbGV0 ZWQuCisgICAgICAgICogTW9kdWxlcy9pbmRleGVkZGIvc2hhcmVkL0lEQlJlc291cmNlSWRlbnRp Zmllci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJREJSZXNvdXJjZUlkZW50aWZpZXI6OmRlbGV0 ZWRWYWx1ZSk6IERlbGV0ZWQuCisgICAgICAgIChXZWJDb3JlOjpJREJSZXNvdXJjZUlkZW50aWZp ZXI6OmlzSGFzaFRhYmxlRGVsZXRlZFZhbHVlIGNvbnN0KTogRGVsZXRlZC4KKyAgICAgICAgKiBN b2R1bGVzL2luZGV4ZWRkYi9zaGFyZWQvSURCUmVzb3VyY2VJZGVudGlmaWVyLmg6CisgICAgICAg IChXZWJDb3JlOjpJREJSZXNvdXJjZUlkZW50aWZpZXJIYXNoVHJhaXRzOjpjb25zdHJ1Y3REZWxl dGVkVmFsdWUpOgorICAgICAgICAoV2ViQ29yZTo6SURCUmVzb3VyY2VJZGVudGlmaWVySGFzaFRy YWl0czo6aXNEZWxldGVkVmFsdWUpOgorICAgICAgICAqIGRvbS9NZXNzYWdlUG9ydElkZW50aWZp ZXIuaDoKKyAgICAgICAgKFdURjo6SGFzaFRyYWl0czxXZWJDb3JlOjpNZXNzYWdlUG9ydElkZW50 aWZpZXI+Ojpjb25zdHJ1Y3REZWxldGVkVmFsdWUpOgorICAgICAgICAoV1RGOjpIYXNoVHJhaXRz PFdlYkNvcmU6Ok1lc3NhZ2VQb3J0SWRlbnRpZmllcj46OmlzRGVsZXRlZFZhbHVlKToKKyAgICAg ICAgKiBoaXN0b3J5L0JhY2tGb3J3YXJkSXRlbUlkZW50aWZpZXIuaDoKKyAgICAgICAgKFdURjo6 SGFzaFRyYWl0czxXZWJDb3JlOjpCYWNrRm9yd2FyZEl0ZW1JZGVudGlmaWVyPjo6Y29uc3RydWN0 RGVsZXRlZFZhbHVlKToKKyAgICAgICAgKFdURjo6SGFzaFRyYWl0czxXZWJDb3JlOjpCYWNrRm9y d2FyZEl0ZW1JZGVudGlmaWVyPjo6aXNEZWxldGVkVmFsdWUpOgorICAgICAgICAqIGxheW91dC9M YXlvdXRVbml0cy5oOgorICAgICAgICAoV1RGOjpIYXNoVHJhaXRzPFdlYkNvcmU6OkxheW91dDo6 U2xvdFBvc2l0aW9uPjo6Y29uc3RydWN0RGVsZXRlZFZhbHVlKToKKyAgICAgICAgKFdURjo6SGFz aFRyYWl0czxXZWJDb3JlOjpMYXlvdXQ6OlNsb3RQb3NpdGlvbj46OmlzRGVsZXRlZFZhbHVlKToK KyAgICAgICAgKiBsb2FkZXIvUHJpdmF0ZUNsaWNrTWVhc3VyZW1lbnQuaDoKKyAgICAgICAgKFdl YkNvcmU6OlByaXZhdGVDbGlja01lYXN1cmVtZW50OjpBdHRyaWJ1dGlvbkRlc3RpbmF0aW9uU2l0 ZTo6bWF0Y2hlcyBjb25zdCk6CisgICAgICAgIChXVEY6Okhhc2hUcmFpdHM8V2ViQ29yZTo6UHJp dmF0ZUNsaWNrTWVhc3VyZW1lbnQ6OlNvdXJjZVNpdGU+Ojpjb25zdHJ1Y3REZWxldGVkVmFsdWUp OgorICAgICAgICAoV1RGOjpIYXNoVHJhaXRzPFdlYkNvcmU6OlByaXZhdGVDbGlja01lYXN1cmVt ZW50OjpTb3VyY2VTaXRlPjo6aXNEZWxldGVkVmFsdWUpOgorICAgICAgICAoV1RGOjpIYXNoVHJh aXRzPFdlYkNvcmU6OlByaXZhdGVDbGlja01lYXN1cmVtZW50OjpBdHRyaWJ1dGlvbkRlc3RpbmF0 aW9uU2l0ZT46OmNvbnN0cnVjdERlbGV0ZWRWYWx1ZSk6CisgICAgICAgIChXVEY6Okhhc2hUcmFp dHM8V2ViQ29yZTo6UHJpdmF0ZUNsaWNrTWVhc3VyZW1lbnQ6OkF0dHJpYnV0aW9uRGVzdGluYXRp b25TaXRlPjo6aXNEZWxldGVkVmFsdWUpOgorICAgICAgICAoV2ViQ29yZTo6UHJpdmF0ZUNsaWNr TWVhc3VyZW1lbnQ6OlNvdXJjZVNpdGU6OmlzSGFzaFRhYmxlRGVsZXRlZFZhbHVlIGNvbnN0KTog RGVsZXRlZC4KKyAgICAgICAgKFdlYkNvcmU6OlByaXZhdGVDbGlja01lYXN1cmVtZW50OjpTb3Vy Y2VTaXRlOjpkZWxldGVkVmFsdWUpOiBEZWxldGVkLgorICAgICAgICAoV2ViQ29yZTo6UHJpdmF0 ZUNsaWNrTWVhc3VyZW1lbnQ6OlNvdXJjZVNpdGU6OmNvbnN0cnVjdERlbGV0ZWRWYWx1ZSk6IERl bGV0ZWQuCisgICAgICAgIChXZWJDb3JlOjpQcml2YXRlQ2xpY2tNZWFzdXJlbWVudDo6U291cmNl U2l0ZTo6ZGVsZXRlVmFsdWUpOiBEZWxldGVkLgorICAgICAgICAoV2ViQ29yZTo6UHJpdmF0ZUNs aWNrTWVhc3VyZW1lbnQ6OlNvdXJjZVNpdGU6OmlzRGVsZXRlZFZhbHVlIGNvbnN0KTogRGVsZXRl ZC4KKyAgICAgICAgKFdlYkNvcmU6OlByaXZhdGVDbGlja01lYXN1cmVtZW50OjpBdHRyaWJ1dGlv bkRlc3RpbmF0aW9uU2l0ZTo6aXNIYXNoVGFibGVEZWxldGVkVmFsdWUgY29uc3QpOiBEZWxldGVk LgorICAgICAgICAoV2ViQ29yZTo6UHJpdmF0ZUNsaWNrTWVhc3VyZW1lbnQ6OkF0dHJpYnV0aW9u RGVzdGluYXRpb25TaXRlOjpkZWxldGVkVmFsdWUpOiBEZWxldGVkLgorICAgICAgICAoV2ViQ29y ZTo6UHJpdmF0ZUNsaWNrTWVhc3VyZW1lbnQ6OkF0dHJpYnV0aW9uRGVzdGluYXRpb25TaXRlOjpj b25zdHJ1Y3REZWxldGVkVmFsdWUpOiBEZWxldGVkLgorICAgICAgICAoV2ViQ29yZTo6UHJpdmF0 ZUNsaWNrTWVhc3VyZW1lbnQ6OkF0dHJpYnV0aW9uRGVzdGluYXRpb25TaXRlOjpkZWxldGVWYWx1 ZSk6IERlbGV0ZWQuCisgICAgICAgIChXZWJDb3JlOjpQcml2YXRlQ2xpY2tNZWFzdXJlbWVudDo6 QXR0cmlidXRpb25EZXN0aW5hdGlvblNpdGU6OmlzRGVsZXRlZFZhbHVlIGNvbnN0KTogRGVsZXRl ZC4KKyAgICAgICAgKiBwYWdlL0NsaWVudE9yaWdpbi5oOgorICAgICAgICAoV1RGOjpIYXNoVHJh aXRzPFdlYkNvcmU6OkNsaWVudE9yaWdpbj46OmNvbnN0cnVjdERlbGV0ZWRWYWx1ZSk6CisgICAg ICAgICogcGFnZS9HbG9iYWxXaW5kb3dJZGVudGlmaWVyLmg6CisgICAgICAgIChXVEY6Okhhc2hU cmFpdHM8V2ViQ29yZTo6R2xvYmFsV2luZG93SWRlbnRpZmllcj46OmNvbnN0cnVjdERlbGV0ZWRW YWx1ZSk6CisgICAgICAgIChXVEY6Okhhc2hUcmFpdHM8V2ViQ29yZTo6R2xvYmFsV2luZG93SWRl bnRpZmllcj46OmlzRGVsZXRlZFZhbHVlKToKKyAgICAgICAgKiBwbGF0Zm9ybS9Db29raWUuaDoK KyAgICAgICAgKFdURjo6SGFzaFRyYWl0czxXZWJDb3JlOjpDb29raWU+Ojpjb25zdHJ1Y3REZWxl dGVkVmFsdWUpOgorICAgICAgICAoV2ViQ29yZTo6Q29va2llOjpDb29raWUpOiBEZWxldGVkLgor ICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL0ZvbnRDYWNoZS5jcHA6CisgICAgICAgIChXZWJD b3JlOjpGb250UGxhdGZvcm1EYXRhQ2FjaGVLZXlIYXNoVHJhaXRzOjpjb25zdHJ1Y3REZWxldGVk VmFsdWUpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL0ZvbnRDYWNoZS5oOgorICAgICAg ICAoV2ViQ29yZTo6Rm9udENhc2NhZGVDYWNoZUtleUhhc2hUcmFpdHM6OmNvbnN0cnVjdERlbGV0 ZWRWYWx1ZSk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvSW50UG9pbnRIYXNoLmg6Cisg ICAgICAgIChXVEY6Okhhc2hUcmFpdHM8V2ViQ29yZTo6SW50UG9pbnQ+Ojpjb25zdHJ1Y3REZWxl dGVkVmFsdWUpOgorICAgICAgICAoV1RGOjpIYXNoVHJhaXRzPFdlYkNvcmU6OkludFBvaW50Pjo6 aXNEZWxldGVkVmFsdWUpOgorICAgICAgICAqIHJlbmRlcmluZy9DU1NWYWx1ZUtleS5oOgorICAg ICAgICAoV1RGOjpIYXNoVHJhaXRzPFdlYkNvcmU6OkNTU1ZhbHVlS2V5Pjo6Y29uc3RydWN0RGVs ZXRlZFZhbHVlKToKKyAgICAgICAgKiB3b3JrZXJzL3NlcnZpY2UvU2VydmljZVdvcmtlckNsaWVu dElkZW50aWZpZXIuaDoKKyAgICAgICAgKFdURjo6SGFzaFRyYWl0czxXZWJDb3JlOjpTZXJ2aWNl V29ya2VyQ2xpZW50SWRlbnRpZmllcj46OmNvbnN0cnVjdERlbGV0ZWRWYWx1ZSk6CisgICAgICAg IChXVEY6Okhhc2hUcmFpdHM8V2ViQ29yZTo6U2VydmljZVdvcmtlckNsaWVudElkZW50aWZpZXI+ Ojppc0RlbGV0ZWRWYWx1ZSk6CisKIDIwMjEtMDQtMjEgIFR5bGVyIFdpbGNvY2sgIDx0d2lsY28u b0Bwcm90b25tYWlsLmNvbT4KIAogICAgICAgICBbY3NzLWNvdW50ZXItc3R5bGVzXSBQYXJzZSBA Y291bnRlci1zdHlsZSBkZXNjcmlwdG9ycwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvUEFM L0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL1BBTC9DaGFuZ2VMb2cKaW5kZXggZjViYzhhOGU2 MDAyNDhjMGI1OTFmZTVhYjg5ZmYwY2ZkZTlkMjAzMC4uM2JhMDZhNTA4ZWYwOTYwYTM1NTQ4MmM2 OTQwZjVmZDYzZTUxYmQ0YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvUEFML0NoYW5nZUxv ZworKysgYi9Tb3VyY2UvV2ViQ29yZS9QQUwvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTMgQEAKKzIw MjEtMDQtMjEgIENocmlzIER1bWV6ICA8Y2R1bWV6QGFwcGxlLmNvbT4KKworICAgICAgICBJbXBy b3ZlIG91ciBjb25zdHJ1Y3REZWxldGVkVmFsdWUoKSB0ZW1wbGF0ZSBzcGVjaWFsaXphdGlvbnMK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIyNDg4OQor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogcGFsL1Nl c3Npb25JRC5oOgorICAgICAgICAoV1RGOjpIYXNoVHJhaXRzPFBBTDo6U2Vzc2lvbklEPjo6Y29u c3RydWN0RGVsZXRlZFZhbHVlKToKKwogMjAyMS0wNC0yMCAgQnJlbnQgRnVsZ2hhbSAgPGJmdWxn aGFtQGFwcGxlLmNvbT4KIAogICAgICAgICBbQ29jb2FdIFByZXZlbnQgR1BVIGFuZCBXZWJDb250 ZW50IHByb2Nlc3NlcyBmcm9tIGF0dGVtcHRpbmcgdG8gY29ubmVjdCB0byB0aGUgQXBwU1NPIHNl cnZpY2UgCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJL aXQvQ2hhbmdlTG9nCmluZGV4IDFlNGQxMjI4MzgzYmFiZjMyYzQ3NzA2ZDc0NDM2ZjY0ZTI4MmRh YTIuLjViN2EzMGM0MGEzMTlmMTk3OGY2NDEzMzY1ZjMwZWM2YWRmN2ZiMWMgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCkBA IC0xLDMgKzEsMjQgQEAKKzIwMjEtMDQtMjEgIENocmlzIER1bWV6ICA8Y2R1bWV6QGFwcGxlLmNv bT4KKworICAgICAgICBJbXByb3ZlIG91ciBjb25zdHJ1Y3REZWxldGVkVmFsdWUoKSB0ZW1wbGF0 ZSBzcGVjaWFsaXphdGlvbnMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTIyNDg4OQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIEltcHJvdmUgb3VyIGNvbnN0cnVjdERlbGV0ZWRWYWx1ZSgpIHRlbXBsYXRlIHNw ZWNpYWxpemF0aW9ucyBhbmQgbWFrZSB0aGVtIG1vcmUgY29uc2lzdGVudDoKKyAgICAgICAgLSBV c2UgcGxhY2VtZW50LW5ldyBpbnN0ZWFkIG9mIG9iamVjdCBhc3NpZ25tZW50IHNpbmNlIHdlIGRv bid0IHdhbnQvbmVlZCB0byBkZXN0cm95IHRoZQorICAgICAgICAgIGV4aXN0aW5nIG9iamVjdCAo c2luY2UgaXQgaXMgdW5pbml0aWFsaXplZCkuCisgICAgICAgIC0gRG8gYXMgbGl0dGxlIGluaXRp YWxpemF0aW9uIGFzIHBvc3NpYmxlIGZvciBwZXJmb3JtYW5jZSByZWFzb25zLgorCisgICAgICAg ICogTmV0d29ya1Byb2Nlc3MvY2FjaGUvTmV0d29ya0NhY2hlLmg6CisgICAgICAgIChXVEY6Okhh c2hUcmFpdHM8V2ViS2l0OjpOZXR3b3JrQ2FjaGU6Okdsb2JhbEZyYW1lSUQ+Ojpjb25zdHJ1Y3RE ZWxldGVkVmFsdWUpOgorICAgICAgICAoV1RGOjpIYXNoVHJhaXRzPFdlYktpdDo6TmV0d29ya0Nh Y2hlOjpHbG9iYWxGcmFtZUlEPjo6aXNEZWxldGVkVmFsdWUpOgorICAgICAgICAqIFBsYXRmb3Jt L0lQQy9TdHJpbmdSZWZlcmVuY2UuaDoKKyAgICAgICAgKFdURjo6SGFzaFRyYWl0czxJUEM6OlN0 cmluZ1JlZmVyZW5jZT46OmNvbnN0cnVjdERlbGV0ZWRWYWx1ZSk6CisgICAgICAgICogU2hhcmVk L0NhbGxiYWNrSUQuaDoKKyAgICAgICAgKFdURjo6SGFzaFRyYWl0czxXZWJLaXQ6OkNhbGxiYWNr SUQ+Ojpjb25zdHJ1Y3REZWxldGVkVmFsdWUpOgorICAgICAgICAoV1RGOjpIYXNoVHJhaXRzPFdl YktpdDo6Q2FsbGJhY2tJRD46OmlzRGVsZXRlZFZhbHVlKToKKwogMjAyMS0wNC0yMSAgS2ltbW8g S2lubnVuZW4gIDxra2lubnVuZW5AYXBwbGUuY29tPgogCiAgICAgICAgIEZpeCBidWlsZCBicmVh ayBhZnRlciByMjc2MzYzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0TGVnYWN5L21hYy9DaGFu Z2VMb2cgYi9Tb3VyY2UvV2ViS2l0TGVnYWN5L21hYy9DaGFuZ2VMb2cKaW5kZXggOGE2MGFlYmRm NWZjMzRiMDNlM2JlMGUyMzNlMDZkMjQyYjVhM2EyMy4uN2JkNTBmZGE0ZmQ3MjgxNWU5MmJkOWIw ZDMyMzAyMTlmMmRmMzJhYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdExlZ2FjeS9tYWMvQ2hh bmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXRMZWdhY3kvbWFjL0NoYW5nZUxvZwpAQCAtMSwzICsx LDI0IEBACisyMDIxLTA0LTIxICBDaHJpcyBEdW1leiAgPGNkdW1lekBhcHBsZS5jb20+CisKKyAg ICAgICAgSW1wcm92ZSBvdXIgY29uc3RydWN0RGVsZXRlZFZhbHVlKCkgdGVtcGxhdGUgc3BlY2lh bGl6YXRpb25zCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0yMjQ4ODkKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAg ICBJbXByb3ZlIG91ciBjb25zdHJ1Y3REZWxldGVkVmFsdWUoKSB0ZW1wbGF0ZSBzcGVjaWFsaXph dGlvbnMgYW5kIG1ha2UgdGhlbSBtb3JlIGNvbnNpc3RlbnQ6CisgICAgICAgIC0gVXNlIHBsYWNl bWVudC1uZXcgaW5zdGVhZCBvZiBvYmplY3QgYXNzaWdubWVudCBzaW5jZSB3ZSBkb24ndCB3YW50 L25lZWQgdG8gZGVzdHJveSB0aGUKKyAgICAgICAgICBleGlzdGluZyBvYmplY3QgKHNpbmNlIGl0 IGlzIHVuaW5pdGlhbGl6ZWQpLgorICAgICAgICAtIERvIGFzIGxpdHRsZSBpbml0aWFsaXphdGlv biBhcyBwb3NzaWJsZSBmb3IgcGVyZm9ybWFuY2UgcmVhc29ucy4KKworICAgICAgICAqIEhpc3Rv cnkvQmluYXJ5UHJvcGVydHlMaXN0LmNwcDoKKyAgICAgICAgKEludGVnZXJBcnJheTo6aW50ZWdl cnMgY29uc3QpOgorICAgICAgICAoSW50ZWdlckFycmF5OjpzaXplIGNvbnN0KToKKyAgICAgICAg KEludGVnZXJBcnJheUhhc2hUcmFpdHM6OmNvbnN0cnVjdERlbGV0ZWRWYWx1ZSk6CisgICAgICAg IChJbnRlZ2VyQXJyYXlIYXNoVHJhaXRzOjppc0RlbGV0ZWRWYWx1ZSk6CisgICAgICAgIChJbnRl Z2VyQXJyYXk6Om1hcmtEZWxldGVkKTogRGVsZXRlZC4KKyAgICAgICAgKEludGVnZXJBcnJheTo6 aXNEZWxldGVkVmFsdWUgY29uc3QpOiBEZWxldGVkLgorICAgICAgICAoSW50ZWdlckFycmF5Ojpk ZWxldGVkVmFsdWVTaXplKTogRGVsZXRlZC4KKwogMjAyMS0wNC0xOSAgS2ltbW8gS2lubnVuZW4g IDxra2lubnVuZW5AYXBwbGUuY29tPgogCiAgICAgICAgIEVuYWJsZSAtV3RocmVhZC1zYWZldHks IGFkZCBhdHRyaWJ1dGVzIHRvIGN1c3RvbSBsb2NrIGNsYXNzZXMsIGFuZCBwcm92aWRlIG1hY3Jv cyB0byBkZWNsYXJlIGd1YXJkcwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9p bmRleGVkZGIvSURCS2V5RGF0YS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRk Yi9JREJLZXlEYXRhLmNwcAppbmRleCA1YjliZDIxNWU4NjQxNTkyNDY1OGFiMWQ3ZDI5NzEwYjNh ODQyYzBlLi5iNDFiMmYwZTNiMzYxNmU1OGM1M2UwNzQwMzQ2MmVmMGI5ZmExMmQyIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJLZXlEYXRhLmNwcAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJLZXlEYXRhLmNwcApAQCAtNDIw LDE0ICs0MjAsNiBAQCB2b2lkIElEQktleURhdGE6OnNldE51bWJlclZhbHVlKGRvdWJsZSB2YWx1 ZSkKICAgICBtX2lzTnVsbCA9IGZhbHNlOwogfQogCi1JREJLZXlEYXRhIElEQktleURhdGE6OmRl bGV0ZWRWYWx1ZSgpCi17Ci0gICAgSURCS2V5RGF0YSByZXN1bHQ7Ci0gICAgcmVzdWx0Lm1faXNO dWxsID0gZmFsc2U7Ci0gICAgcmVzdWx0Lm1faXNEZWxldGVkVmFsdWUgPSB0cnVlOwotICAgIHJl dHVybiByZXN1bHQ7Ci19Ci0KIGJvb2wgSURCS2V5RGF0YTo6aXNWYWxpZCgpIGNvbnN0CiB7CiAg ICAgaWYgKG1fdHlwZSA9PSBJbmRleGVkREI6OktleVR5cGU6OkludmFsaWQpCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJLZXlEYXRhLmggYi9Tb3VyY2Uv V2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJLZXlEYXRhLmgKaW5kZXggNDM5YzRiMDc0MDE2 ZDliMjUyMzdmNjlkZThiYmU2NWM1M2ViMjkwOS4uZjZmYTFmZjgxMTQ4YWYyOGMwYmMxMGYwMTMx MjBlMGMwMDcyNjllMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9pbmRleGVk ZGIvSURCS2V5RGF0YS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lE QktleURhdGEuaApAQCAtMTUyLDkgKzE1Miw2IEBAIHB1YmxpYzoKICAgICAgICAgcmV0dXJuIFN0 cmluZ0hhc2hlcjo6aGFzaE1lbW9yeShoYXNoQ29kZXMuZGF0YSgpLCBoYXNoQ29kZXMuc2l6ZSgp ICogc2l6ZW9mKHVuc2lnbmVkKSk7CiAgICAgfQogCi0gICAgc3RhdGljIElEQktleURhdGEgZGVs ZXRlZFZhbHVlKCk7Ci0gICAgYm9vbCBpc0RlbGV0ZWRWYWx1ZSgpIGNvbnN0IHsgcmV0dXJuIG1f aXNEZWxldGVkVmFsdWU7IH0KLQogICAgIFN0cmluZyBzdHJpbmcoKSBjb25zdAogICAgIHsKICAg ICAgICAgQVNTRVJUKG1fdHlwZSA9PSBJbmRleGVkREI6OktleVR5cGU6OlN0cmluZyk7CkBAIC0x ODgsNiArMTg1LDggQEAgcHVibGljOgogICAgIHNpemVfdCBzaXplKCkgY29uc3Q7CiAKIHByaXZh dGU6CisgICAgZnJpZW5kIHN0cnVjdCBJREJLZXlEYXRhSGFzaFRyYWl0czsKKwogICAgIHN0YXRp YyB2b2lkIGlzb2xhdGVkQ29weShjb25zdCBJREJLZXlEYXRhJiBzb3VyY2UsIElEQktleURhdGEm IGRlc3RpbmF0aW9uKTsKIAogICAgIEluZGV4ZWREQjo6S2V5VHlwZSBtX3R5cGU7CkBAIC0yMDcs MTYgKzIwNiw4IEBAIHN0cnVjdCBJREJLZXlEYXRhSGFzaFRyYWl0cyA6IHB1YmxpYyBXVEY6OkN1 c3RvbUhhc2hUcmFpdHM8SURCS2V5RGF0YT4gewogICAgIHN0YXRpYyBjb25zdCBib29sIGVtcHR5 VmFsdWVJc1plcm8gPSBmYWxzZTsKICAgICBzdGF0aWMgY29uc3QgYm9vbCBoYXNJc0VtcHR5VmFs dWVGdW5jdGlvbiA9IHRydWU7CiAKLSAgICBzdGF0aWMgdm9pZCBjb25zdHJ1Y3REZWxldGVkVmFs dWUoSURCS2V5RGF0YSYga2V5KQotICAgIHsKLSAgICAgICAgbmV3ICgma2V5KSBJREJLZXlEYXRh OwotICAgICAgICBrZXkgPSBJREJLZXlEYXRhOjpkZWxldGVkVmFsdWUoKTsKLSAgICB9Ci0KLSAg ICBzdGF0aWMgYm9vbCBpc0RlbGV0ZWRWYWx1ZShjb25zdCBJREJLZXlEYXRhJiBrZXkpCi0gICAg ewotICAgICAgICByZXR1cm4ga2V5LmlzRGVsZXRlZFZhbHVlKCk7Ci0gICAgfQorICAgIHN0YXRp YyB2b2lkIGNvbnN0cnVjdERlbGV0ZWRWYWx1ZShJREJLZXlEYXRhJiBrZXkpIHsga2V5Lm1faXNE ZWxldGVkVmFsdWUgPSB0cnVlOyB9CisgICAgc3RhdGljIGJvb2wgaXNEZWxldGVkVmFsdWUoY29u c3QgSURCS2V5RGF0YSYga2V5KSB7IHJldHVybiBrZXkubV9pc0RlbGV0ZWRWYWx1ZTsgfQogCiAg ICAgc3RhdGljIElEQktleURhdGEgZW1wdHlWYWx1ZSgpCiAgICAgewpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvTW9kdWxlcy9pbmRleGVkZGIvc2hhcmVkL0lEQlJlc291cmNlSWRlbnRpZmll ci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9zaGFyZWQvSURCUmVzb3Vy Y2VJZGVudGlmaWVyLmNwcAppbmRleCA5Zjg3N2Y2ZjQ2MmE3ODBjNDJiMmJjMGI3ODYyOWVmMzRk ZTc4YzY3Li4zYTYwMDY5Yzg4NTQzNjY4ZjNhODZiMGU1ODlhNWE5MmNkMTBlMDAxIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9zaGFyZWQvSURCUmVzb3VyY2VJ ZGVudGlmaWVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9zaGFy ZWQvSURCUmVzb3VyY2VJZGVudGlmaWVyLmNwcApAQCAtODQsMTYgKzg0LDYgQEAgSURCUmVzb3Vy Y2VJZGVudGlmaWVyIElEQlJlc291cmNlSWRlbnRpZmllcjo6ZW1wdHlWYWx1ZSgpCiAgICAgcmV0 dXJuIElEQlJlc291cmNlSWRlbnRpZmllcih7IH0sIDApOwogfQogCi1JREJSZXNvdXJjZUlkZW50 aWZpZXIgSURCUmVzb3VyY2VJZGVudGlmaWVyOjpkZWxldGVkVmFsdWUoKQotewotICAgIHJldHVy biBJREJSZXNvdXJjZUlkZW50aWZpZXIoSURCQ29ubmVjdGlvbklkZW50aWZpZXIgeyBXVEY6Okhh c2hUYWJsZURlbGV0ZWRWYWx1ZSB9LCBzdGQ6Om51bWVyaWNfbGltaXRzPHVpbnQ2NF90Pjo6bWF4 KCkpOwotfQotCi1ib29sIElEQlJlc291cmNlSWRlbnRpZmllcjo6aXNIYXNoVGFibGVEZWxldGVk VmFsdWUoKSBjb25zdAotewotICAgIHJldHVybiBtX2lkYkNvbm5lY3Rpb25JZGVudGlmaWVyLmlz SGFzaFRhYmxlRGVsZXRlZFZhbHVlKCkgJiYgbV9yZXNvdXJjZU51bWJlciA9PSBzdGQ6Om51bWVy aWNfbGltaXRzPHVpbnQ2NF90Pjo6bWF4KCk7Ci19Ci0KICNpZiAhTE9HX0RJU0FCTEVECiAKIFN0 cmluZyBJREJSZXNvdXJjZUlkZW50aWZpZXI6OmxvZ2dpbmdTdHJpbmcoKSBjb25zdApkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9pbmRleGVkZGIvc2hhcmVkL0lEQlJlc291cmNl SWRlbnRpZmllci5oIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9pbmRleGVkZGIvc2hhcmVkL0lE QlJlc291cmNlSWRlbnRpZmllci5oCmluZGV4IDM0YTk3ZDg4ZDIxMDM0NmEwMzMyMTU5ZmYxMDVj MGFjMTVmNTAxZmQuLmJlMTYxOTdmNjM0YTU5NmMzOWU1MTMwMjg1OTA2ODM1NzQ1ODY4MmEgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL3NoYXJlZC9JREJSZXNv dXJjZUlkZW50aWZpZXIuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9z aGFyZWQvSURCUmVzb3VyY2VJZGVudGlmaWVyLmgKQEAgLTQ5LDkgKzQ5LDYgQEAgcHVibGljOgog ICAgIElEQlJlc291cmNlSWRlbnRpZmllcihjb25zdCBJREJDbGllbnQ6OklEQkNvbm5lY3Rpb25Q cm94eSYsIGNvbnN0IElEQlJlcXVlc3QmKTsKICAgICBleHBsaWNpdCBJREJSZXNvdXJjZUlkZW50 aWZpZXIoY29uc3QgSURCU2VydmVyOjpJREJDb25uZWN0aW9uVG9DbGllbnQmKTsKIAotICAgIHN0 YXRpYyBJREJSZXNvdXJjZUlkZW50aWZpZXIgZGVsZXRlZFZhbHVlKCk7Ci0gICAgV0VCQ09SRV9F WFBPUlQgYm9vbCBpc0hhc2hUYWJsZURlbGV0ZWRWYWx1ZSgpIGNvbnN0OwotCiAgICAgc3RhdGlj IElEQlJlc291cmNlSWRlbnRpZmllciBlbXB0eVZhbHVlKCk7CiAgICAgYm9vbCBpc0VtcHR5KCkg Y29uc3QKICAgICB7CkBAIC04NCw2ICs4MSw4IEBAIHB1YmxpYzoKICAgICB0ZW1wbGF0ZTxjbGFz cyBEZWNvZGVyPiBzdGF0aWMgV0FSTl9VTlVTRURfUkVUVVJOIGJvb2wgZGVjb2RlKERlY29kZXIm LCBJREJSZXNvdXJjZUlkZW50aWZpZXImKTsKIAogcHJpdmF0ZToKKyAgICBmcmllbmQgc3RydWN0 IElEQlJlc291cmNlSWRlbnRpZmllckhhc2hUcmFpdHM7CisKICAgICBJREJSZXNvdXJjZUlkZW50 aWZpZXIoSURCQ29ubmVjdGlvbklkZW50aWZpZXIsIHVpbnQ2NF90IHJlc291cmNlSWRlbnRpZmll cik7CiAgICAgSURCQ29ubmVjdGlvbklkZW50aWZpZXIgbV9pZGJDb25uZWN0aW9uSWRlbnRpZmll cjsKICAgICB1aW50NjRfdCBtX3Jlc291cmNlTnVtYmVyIHsgMCB9OwpAQCAtMTExLDEyICsxMTAs MTIgQEAgc3RydWN0IElEQlJlc291cmNlSWRlbnRpZmllckhhc2hUcmFpdHMgOiBXVEY6OkN1c3Rv bUhhc2hUcmFpdHM8SURCUmVzb3VyY2VJZGVudGkKIAogICAgIHN0YXRpYyB2b2lkIGNvbnN0cnVj dERlbGV0ZWRWYWx1ZShJREJSZXNvdXJjZUlkZW50aWZpZXImIGlkZW50aWZpZXIpCiAgICAgewot ICAgICAgICBpZGVudGlmaWVyID0gSURCUmVzb3VyY2VJZGVudGlmaWVyOjpkZWxldGVkVmFsdWUo KTsKKyAgICAgICAgbmV3IChOb3ROdWxsLCAmaWRlbnRpZmllci5tX2lkYkNvbm5lY3Rpb25JZGVu dGlmaWVyKSBJREJDb25uZWN0aW9uSWRlbnRpZmllcihXVEY6Okhhc2hUYWJsZURlbGV0ZWRWYWx1 ZSk7CiAgICAgfQogCiAgICAgc3RhdGljIGJvb2wgaXNEZWxldGVkVmFsdWUoY29uc3QgSURCUmVz b3VyY2VJZGVudGlmaWVyJiBpZGVudGlmaWVyKQogICAgIHsKLSAgICAgICAgcmV0dXJuIGlkZW50 aWZpZXIuaXNIYXNoVGFibGVEZWxldGVkVmFsdWUoKTsKKyAgICAgICAgcmV0dXJuIGlkZW50aWZp ZXIubV9pZGJDb25uZWN0aW9uSWRlbnRpZmllci5pc0hhc2hUYWJsZURlbGV0ZWRWYWx1ZSgpOwog ICAgIH0KIH07CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1BBTC9wYWwvU2Vzc2lvbklE LmggYi9Tb3VyY2UvV2ViQ29yZS9QQUwvcGFsL1Nlc3Npb25JRC5oCmluZGV4IDVkMmFiZWRhNmUy ZWVkZTk4ZWJjMTZlZDJhMTBjZTMyYmQxNDMzOWMuLjZjN2EyNjIyNTgxYTIxNmIwZTZiNzBjN2Ri MmZkYTUzY2U4NGY2MjkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1BBTC9wYWwvU2Vzc2lv bklELmgKKysrIGIvU291cmNlL1dlYkNvcmUvUEFML3BhbC9TZXNzaW9uSUQuaApAQCAtMTE1LDcg KzExNSw3IEBAIHN0cnVjdCBTZXNzaW9uSURIYXNoIHsKIAogdGVtcGxhdGU8PiBzdHJ1Y3QgSGFz aFRyYWl0czxQQUw6OlNlc3Npb25JRD4gOiBHZW5lcmljSGFzaFRyYWl0czxQQUw6OlNlc3Npb25J RD4gewogICAgIHN0YXRpYyBQQUw6OlNlc3Npb25JRCBlbXB0eVZhbHVlKCkgeyByZXR1cm4gUEFM OjpTZXNzaW9uSUQoSGFzaFRhYmxlRW1wdHlWYWx1ZSk7IH0KLSAgICBzdGF0aWMgdm9pZCBjb25z dHJ1Y3REZWxldGVkVmFsdWUoUEFMOjpTZXNzaW9uSUQmIHNsb3QpIHsgc2xvdCA9IFBBTDo6U2Vz c2lvbklEKEhhc2hUYWJsZURlbGV0ZWRWYWx1ZSk7IH0KKyAgICBzdGF0aWMgdm9pZCBjb25zdHJ1 Y3REZWxldGVkVmFsdWUoUEFMOjpTZXNzaW9uSUQmIHNsb3QpIHsgbmV3IChOb3ROdWxsLCAmc2xv dCkgUEFMOjpTZXNzaW9uSUQoSGFzaFRhYmxlRGVsZXRlZFZhbHVlKTsgfQogICAgIHN0YXRpYyBi b29sIGlzRGVsZXRlZFZhbHVlKGNvbnN0IFBBTDo6U2Vzc2lvbklEJiBzbG90KSB7IHJldHVybiBz bG90LmlzSGFzaFRhYmxlRGVsZXRlZFZhbHVlKCk7IH0KIH07CiAKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL2RvbS9NZXNzYWdlUG9ydElkZW50aWZpZXIuaCBiL1NvdXJjZS9XZWJDb3JlL2Rv bS9NZXNzYWdlUG9ydElkZW50aWZpZXIuaAppbmRleCA4YmNjMTFkNjA3MDNmZmZmMTQ5OTE5MTQx MmFmMjkxZmI5MDkxYWM5Li5iOGEwZDA2NTljZWY2NmQ5YzJmODgyYjRkYjkwNGFhYjBjMWM0ODRk IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9kb20vTWVzc2FnZVBvcnRJZGVudGlmaWVyLmgK KysrIGIvU291cmNlL1dlYkNvcmUvZG9tL01lc3NhZ2VQb3J0SWRlbnRpZmllci5oCkBAIC0xMDAs OSArMTAwLDkgQEAgc3RydWN0IE1lc3NhZ2VQb3J0SWRlbnRpZmllckhhc2ggewogdGVtcGxhdGU8 PiBzdHJ1Y3QgSGFzaFRyYWl0czxXZWJDb3JlOjpNZXNzYWdlUG9ydElkZW50aWZpZXI+IDogR2Vu ZXJpY0hhc2hUcmFpdHM8V2ViQ29yZTo6TWVzc2FnZVBvcnRJZGVudGlmaWVyPiB7CiAgICAgc3Rh dGljIFdlYkNvcmU6Ok1lc3NhZ2VQb3J0SWRlbnRpZmllciBlbXB0eVZhbHVlKCkgeyByZXR1cm4g eyB9OyB9CiAKLSAgICBzdGF0aWMgdm9pZCBjb25zdHJ1Y3REZWxldGVkVmFsdWUoV2ViQ29yZTo6 TWVzc2FnZVBvcnRJZGVudGlmaWVyJiBzbG90KSB7IHNsb3QucHJvY2Vzc0lkZW50aWZpZXIgPSBt YWtlT2JqZWN0SWRlbnRpZmllcjxXZWJDb3JlOjpQcm9jZXNzSWRlbnRpZmllclR5cGU+KHN0ZDo6 bnVtZXJpY19saW1pdHM8dWludDY0X3Q+OjptYXgoKSk7IH0KKyAgICBzdGF0aWMgdm9pZCBjb25z dHJ1Y3REZWxldGVkVmFsdWUoV2ViQ29yZTo6TWVzc2FnZVBvcnRJZGVudGlmaWVyJiBzbG90KSB7 IG5ldyAoTm90TnVsbCwgJnNsb3QucHJvY2Vzc0lkZW50aWZpZXIpIFdlYkNvcmU6OlByb2Nlc3NJ ZGVudGlmaWVyKFdURjo6SGFzaFRhYmxlRGVsZXRlZFZhbHVlKTsgfQogCi0gICAgc3RhdGljIGJv b2wgaXNEZWxldGVkVmFsdWUoY29uc3QgV2ViQ29yZTo6TWVzc2FnZVBvcnRJZGVudGlmaWVyJiBz bG90KSB7IHJldHVybiBzbG90LnByb2Nlc3NJZGVudGlmaWVyLnRvVUludDY0KCkgPT0gc3RkOjpu dW1lcmljX2xpbWl0czx1aW50NjRfdD46Om1heCgpOyB9CisgICAgc3RhdGljIGJvb2wgaXNEZWxl dGVkVmFsdWUoY29uc3QgV2ViQ29yZTo6TWVzc2FnZVBvcnRJZGVudGlmaWVyJiBzbG90KSB7IHJl dHVybiBzbG90LnByb2Nlc3NJZGVudGlmaWVyLmlzSGFzaFRhYmxlRGVsZXRlZFZhbHVlKCk7IH0K IH07CiAKIHRlbXBsYXRlPD4gc3RydWN0IERlZmF1bHRIYXNoPFdlYkNvcmU6Ok1lc3NhZ2VQb3J0 SWRlbnRpZmllcj4gOiBNZXNzYWdlUG9ydElkZW50aWZpZXJIYXNoIHsgfTsKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL2hpc3RvcnkvQmFja0ZvcndhcmRJdGVtSWRlbnRpZmllci5oIGIvU291 cmNlL1dlYkNvcmUvaGlzdG9yeS9CYWNrRm9yd2FyZEl0ZW1JZGVudGlmaWVyLmgKaW5kZXggZTUz NWUxNTk1OWQzY2JjZDZjYzNkNWZhYTc0MDlhNjQ2YmFlZmQ2MC4uZmE0ZTg2NmNhZmVlMjg5OTI0 NzQzODhkZWIxYzYwZDhiYjY0NzA0MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaGlzdG9y eS9CYWNrRm9yd2FyZEl0ZW1JZGVudGlmaWVyLmgKKysrIGIvU291cmNlL1dlYkNvcmUvaGlzdG9y eS9CYWNrRm9yd2FyZEl0ZW1JZGVudGlmaWVyLmgKQEAgLTExNCw5ICsxMTQsOSBAQCBzdHJ1Y3Qg QmFja0ZvcndhcmRJdGVtSWRlbnRpZmllckhhc2ggewogdGVtcGxhdGU8PiBzdHJ1Y3QgSGFzaFRy YWl0czxXZWJDb3JlOjpCYWNrRm9yd2FyZEl0ZW1JZGVudGlmaWVyPiA6IEdlbmVyaWNIYXNoVHJh aXRzPFdlYkNvcmU6OkJhY2tGb3J3YXJkSXRlbUlkZW50aWZpZXI+IHsKICAgICBzdGF0aWMgV2Vi Q29yZTo6QmFja0ZvcndhcmRJdGVtSWRlbnRpZmllciBlbXB0eVZhbHVlKCkgeyByZXR1cm4geyB9 OyB9CiAKLSAgICBzdGF0aWMgdm9pZCBjb25zdHJ1Y3REZWxldGVkVmFsdWUoV2ViQ29yZTo6QmFj a0ZvcndhcmRJdGVtSWRlbnRpZmllciYgc2xvdCkgeyBzbG90LnByb2Nlc3NJZGVudGlmaWVyID0g T2JqZWN0SWRlbnRpZmllcjxXZWJDb3JlOjpQcm9jZXNzSWRlbnRpZmllclR5cGU+KEhhc2hUYWJs ZURlbGV0ZWRWYWx1ZSk7IH0KKyAgICBzdGF0aWMgdm9pZCBjb25zdHJ1Y3REZWxldGVkVmFsdWUo V2ViQ29yZTo6QmFja0ZvcndhcmRJdGVtSWRlbnRpZmllciYgc2xvdCkgeyBuZXcgKE5vdE51bGws ICZzbG90LnByb2Nlc3NJZGVudGlmaWVyKSBXZWJDb3JlOjpQcm9jZXNzSWRlbnRpZmllcihXVEY6 Okhhc2hUYWJsZURlbGV0ZWRWYWx1ZSk7IH0KIAotICAgIHN0YXRpYyBib29sIGlzRGVsZXRlZFZh bHVlKGNvbnN0IFdlYkNvcmU6OkJhY2tGb3J3YXJkSXRlbUlkZW50aWZpZXImIHNsb3QpIHsgcmV0 dXJuIHNsb3QucHJvY2Vzc0lkZW50aWZpZXIudG9VSW50NjQoKSA9PSBzdGQ6Om51bWVyaWNfbGlt aXRzPHVpbnQ2NF90Pjo6bWF4KCk7IH0KKyAgICBzdGF0aWMgYm9vbCBpc0RlbGV0ZWRWYWx1ZShj b25zdCBXZWJDb3JlOjpCYWNrRm9yd2FyZEl0ZW1JZGVudGlmaWVyJiBzbG90KSB7IHJldHVybiBz bG90LnByb2Nlc3NJZGVudGlmaWVyLmlzSGFzaFRhYmxlRGVsZXRlZFZhbHVlKCk7IH0KIH07CiAK IHRlbXBsYXRlPD4gc3RydWN0IERlZmF1bHRIYXNoPFdlYkNvcmU6OkJhY2tGb3J3YXJkSXRlbUlk ZW50aWZpZXI+IDogQmFja0ZvcndhcmRJdGVtSWRlbnRpZmllckhhc2ggeyB9OwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvbGF5b3V0L0xheW91dFVuaXRzLmggYi9Tb3VyY2UvV2ViQ29yZS9s YXlvdXQvTGF5b3V0VW5pdHMuaAppbmRleCA5ZGJjMjk3Y2FkMTIzY2NhNDU0NGU0NzgwN2ZlYTE0 YzZkOWUwMGRmLi40Mzk2NWE5OTJlOGFiMTc5NjVhYmE5ZDkyOGM4MmJlN2EwMTc5M2JlIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9sYXlvdXQvTGF5b3V0VW5pdHMuaAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9sYXlvdXQvTGF5b3V0VW5pdHMuaApAQCAtMjQ0LDggKzI0NCw4IEBAIHN0cnVjdCBT bG90UG9zaXRpb25IYXNoIHsKIHRlbXBsYXRlPD4gc3RydWN0IEhhc2hUcmFpdHM8V2ViQ29yZTo6 TGF5b3V0OjpTbG90UG9zaXRpb24+IDogR2VuZXJpY0hhc2hUcmFpdHM8V2ViQ29yZTo6TGF5b3V0 OjpTbG90UG9zaXRpb24+IHsKICAgICBzdGF0aWMgV2ViQ29yZTo6TGF5b3V0OjpTbG90UG9zaXRp b24gZW1wdHlWYWx1ZSgpIHsgcmV0dXJuIFdlYkNvcmU6OkxheW91dDo6U2xvdFBvc2l0aW9uKDAs IHN0ZDo6bnVtZXJpY19saW1pdHM8c2l6ZV90Pjo6bWF4KCkpOyB9CiAKLSAgICBzdGF0aWMgdm9p ZCBjb25zdHJ1Y3REZWxldGVkVmFsdWUoV2ViQ29yZTo6TGF5b3V0OjpTbG90UG9zaXRpb24mIHNs b3QpIHsgc2xvdCA9IFdlYkNvcmU6OkxheW91dDo6U2xvdFBvc2l0aW9uKHN0ZDo6bnVtZXJpY19s aW1pdHM8c2l6ZV90Pjo6bWF4KCksIDApOyB9Ci0gICAgc3RhdGljIGJvb2wgaXNEZWxldGVkVmFs dWUoY29uc3QgV2ViQ29yZTo6TGF5b3V0OjpTbG90UG9zaXRpb24mIHNsb3QpIHsgcmV0dXJuIHNs b3QgPT0gV2ViQ29yZTo6TGF5b3V0OjpTbG90UG9zaXRpb24oc3RkOjpudW1lcmljX2xpbWl0czxz aXplX3Q+OjptYXgoKSwgMCk7IH0KKyAgICBzdGF0aWMgdm9pZCBjb25zdHJ1Y3REZWxldGVkVmFs dWUoV2ViQ29yZTo6TGF5b3V0OjpTbG90UG9zaXRpb24mIHNsb3QpIHsgc2xvdC5jb2x1bW4gPSBz dGQ6Om51bWVyaWNfbGltaXRzPHNpemVfdD46Om1heCgpOyB9CisgICAgc3RhdGljIGJvb2wgaXNE ZWxldGVkVmFsdWUoY29uc3QgV2ViQ29yZTo6TGF5b3V0OjpTbG90UG9zaXRpb24mIHNsb3QpIHsg cmV0dXJuIHNsb3QuY29sdW1uID09IHN0ZDo6bnVtZXJpY19saW1pdHM8c2l6ZV90Pjo6bWF4KCk7 IH0KIH07CiB0ZW1wbGF0ZTw+IHN0cnVjdCBEZWZhdWx0SGFzaDxXZWJDb3JlOjpMYXlvdXQ6OlNs b3RQb3NpdGlvbj4gOiBTbG90UG9zaXRpb25IYXNoIHsgfTsKIH0KZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL2xvYWRlci9Qcml2YXRlQ2xpY2tNZWFzdXJlbWVudC5oIGIvU291cmNlL1dlYkNv cmUvbG9hZGVyL1ByaXZhdGVDbGlja01lYXN1cmVtZW50LmgKaW5kZXggMzU4ODdhYjA5Nzk4MmU0 MTFkMzZkZTE0NjU2YjhhMzU2MDAxYWM0Zi4uMjM1YWMxYWQ3Mjg3N2RjNjY2OGJkNGU3YWE4MjIz YjNlMTIwZDZhZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvbG9hZGVyL1ByaXZhdGVDbGlj a01lYXN1cmVtZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL1ByaXZhdGVDbGlja01l YXN1cmVtZW50LmgKQEAgLTg0LDExICs4NCw2IEBAIHB1YmxpYzoKICAgICAgICAgewogICAgICAg ICB9CiAKLSAgICAgICAgZXhwbGljaXQgU291cmNlU2l0ZShXVEY6Okhhc2hUYWJsZURlbGV0ZWRW YWx1ZVR5cGUpCi0gICAgICAgICAgICA6IHJlZ2lzdHJhYmxlRG9tYWluKFdURjo6SGFzaFRhYmxl RGVsZXRlZFZhbHVlKQotICAgICAgICB7Ci0gICAgICAgIH0KLQogICAgICAgICBib29sIG9wZXJh dG9yPT0oY29uc3QgU291cmNlU2l0ZSYgb3RoZXIpIGNvbnN0CiAgICAgICAgIHsKICAgICAgICAg ICAgIHJldHVybiByZWdpc3RyYWJsZURvbWFpbiA9PSBvdGhlci5yZWdpc3RyYWJsZURvbWFpbjsK QEAgLTk5LDMyICs5NCw2IEBAIHB1YmxpYzoKICAgICAgICAgICAgIHJldHVybiByZWdpc3RyYWJs ZURvbWFpbi5tYXRjaGVzKHVybCk7CiAgICAgICAgIH0KIAotICAgICAgICBib29sIGlzSGFzaFRh YmxlRGVsZXRlZFZhbHVlKCkgY29uc3QKLSAgICAgICAgewotICAgICAgICAgICAgcmV0dXJuIHJl Z2lzdHJhYmxlRG9tYWluLmlzSGFzaFRhYmxlRGVsZXRlZFZhbHVlKCk7Ci0gICAgICAgIH0KLQot ICAgICAgICBzdGF0aWMgU291cmNlU2l0ZSBkZWxldGVkVmFsdWUoKQotICAgICAgICB7Ci0gICAg ICAgICAgICByZXR1cm4gU291cmNlU2l0ZSB7IFdURjo6SGFzaFRhYmxlRGVsZXRlZFZhbHVlIH07 Ci0gICAgICAgIH0KLQotICAgICAgICBzdGF0aWMgdm9pZCBjb25zdHJ1Y3REZWxldGVkVmFsdWUo U291cmNlU2l0ZSYgc291cmNlU2l0ZSkKLSAgICAgICAgewotICAgICAgICAgICAgbmV3ICgmc291 cmNlU2l0ZSkgU291cmNlU2l0ZTsKLSAgICAgICAgICAgIHNvdXJjZVNpdGUgPSBTb3VyY2VTaXRl OjpkZWxldGVkVmFsdWUoKTsKLSAgICAgICAgfQotCi0gICAgICAgIHZvaWQgZGVsZXRlVmFsdWUo KQotICAgICAgICB7Ci0gICAgICAgICAgICByZWdpc3RyYWJsZURvbWFpbiA9IFJlZ2lzdHJhYmxl RG9tYWluIHsgV1RGOjpIYXNoVGFibGVEZWxldGVkVmFsdWUgfTsKLSAgICAgICAgfQotCi0gICAg ICAgIGJvb2wgaXNEZWxldGVkVmFsdWUoKSBjb25zdAotICAgICAgICB7Ci0gICAgICAgICAgICBy ZXR1cm4gaXNIYXNoVGFibGVEZWxldGVkVmFsdWUoKTsKLSAgICAgICAgfQotCiAgICAgICAgIFJl Z2lzdHJhYmxlRG9tYWluIHJlZ2lzdHJhYmxlRG9tYWluOwogICAgIH07CiAKQEAgLTE0OSwxMSAr MTE4LDYgQEAgcHVibGljOgogICAgICAgICB7CiAgICAgICAgIH0KIAotICAgICAgICBleHBsaWNp dCBBdHRyaWJ1dGlvbkRlc3RpbmF0aW9uU2l0ZShXVEY6Okhhc2hUYWJsZURlbGV0ZWRWYWx1ZVR5 cGUpCi0gICAgICAgICAgICA6IHJlZ2lzdHJhYmxlRG9tYWluIHsgV1RGOjpIYXNoVGFibGVEZWxl dGVkVmFsdWUgfQotICAgICAgICB7Ci0gICAgICAgIH0KLQogICAgICAgICBleHBsaWNpdCBBdHRy aWJ1dGlvbkRlc3RpbmF0aW9uU2l0ZShSZWdpc3RyYWJsZURvbWFpbiYmIGRvbWFpbikKICAgICAg ICAgICAgIDogcmVnaXN0cmFibGVEb21haW4geyBXVEZNb3ZlKGRvbWFpbikgfQogICAgICAgICB7 CkBAIC0xNjgsMzIgKzEzMiw2IEBAIHB1YmxpYzoKICAgICAgICAgewogICAgICAgICAgICAgcmV0 dXJuIHJlZ2lzdHJhYmxlRG9tYWluID09IFJlZ2lzdHJhYmxlRG9tYWluIHsgdXJsIH07CiAgICAg ICAgIH0KLSAgICAgICAgCi0gICAgICAgIGJvb2wgaXNIYXNoVGFibGVEZWxldGVkVmFsdWUoKSBj b25zdAotICAgICAgICB7Ci0gICAgICAgICAgICByZXR1cm4gcmVnaXN0cmFibGVEb21haW4uaXNI YXNoVGFibGVEZWxldGVkVmFsdWUoKTsKLSAgICAgICAgfQotCi0gICAgICAgIHN0YXRpYyBBdHRy aWJ1dGlvbkRlc3RpbmF0aW9uU2l0ZSBkZWxldGVkVmFsdWUoKQotICAgICAgICB7Ci0gICAgICAg ICAgICByZXR1cm4gQXR0cmlidXRpb25EZXN0aW5hdGlvblNpdGUgeyBXVEY6Okhhc2hUYWJsZURl bGV0ZWRWYWx1ZSB9OwotICAgICAgICB9Ci0KLSAgICAgICAgc3RhdGljIHZvaWQgY29uc3RydWN0 RGVsZXRlZFZhbHVlKEF0dHJpYnV0aW9uRGVzdGluYXRpb25TaXRlJiBkZXN0aW5hdGlvblNpdGUp Ci0gICAgICAgIHsKLSAgICAgICAgICAgIG5ldyAoJmRlc3RpbmF0aW9uU2l0ZSkgQXR0cmlidXRp b25EZXN0aW5hdGlvblNpdGU7Ci0gICAgICAgICAgICBkZXN0aW5hdGlvblNpdGUgPSBBdHRyaWJ1 dGlvbkRlc3RpbmF0aW9uU2l0ZTo6ZGVsZXRlZFZhbHVlKCk7Ci0gICAgICAgIH0KLQotICAgICAg ICB2b2lkIGRlbGV0ZVZhbHVlKCkKLSAgICAgICAgewotICAgICAgICAgICAgcmVnaXN0cmFibGVE b21haW4gPSBSZWdpc3RyYWJsZURvbWFpbiB7IFdURjo6SGFzaFRhYmxlRGVsZXRlZFZhbHVlIH07 Ci0gICAgICAgIH0KLQotICAgICAgICBib29sIGlzRGVsZXRlZFZhbHVlKCkgY29uc3QKLSAgICAg ICAgewotICAgICAgICAgICAgcmV0dXJuIGlzSGFzaFRhYmxlRGVsZXRlZFZhbHVlKCk7Ci0gICAg ICAgIH0KIAogICAgICAgICBSZWdpc3RyYWJsZURvbWFpbiByZWdpc3RyYWJsZURvbWFpbjsKICAg ICB9OwpAQCAtNTg0LDE0ICs1MjIsMTQgQEAgdGVtcGxhdGU8dHlwZW5hbWUgVD4gc3RydWN0IERl ZmF1bHRIYXNoOwogdGVtcGxhdGU8PiBzdHJ1Y3QgRGVmYXVsdEhhc2g8V2ViQ29yZTo6UHJpdmF0 ZUNsaWNrTWVhc3VyZW1lbnQ6OlNvdXJjZVNpdGU+IDogV2ViQ29yZTo6UHJpdmF0ZUNsaWNrTWVh c3VyZW1lbnQ6OlNvdXJjZVNpdGVIYXNoIHsgfTsKIHRlbXBsYXRlPD4gc3RydWN0IEhhc2hUcmFp dHM8V2ViQ29yZTo6UHJpdmF0ZUNsaWNrTWVhc3VyZW1lbnQ6OlNvdXJjZVNpdGU+IDogR2VuZXJp Y0hhc2hUcmFpdHM8V2ViQ29yZTo6UHJpdmF0ZUNsaWNrTWVhc3VyZW1lbnQ6OlNvdXJjZVNpdGU+ IHsKICAgICBzdGF0aWMgV2ViQ29yZTo6UHJpdmF0ZUNsaWNrTWVhc3VyZW1lbnQ6OlNvdXJjZVNp dGUgZW1wdHlWYWx1ZSgpIHsgcmV0dXJuIHsgfTsgfQotICAgIHN0YXRpYyB2b2lkIGNvbnN0cnVj dERlbGV0ZWRWYWx1ZShXZWJDb3JlOjpQcml2YXRlQ2xpY2tNZWFzdXJlbWVudDo6U291cmNlU2l0 ZSYgc2xvdCkgeyBXZWJDb3JlOjpQcml2YXRlQ2xpY2tNZWFzdXJlbWVudDo6U291cmNlU2l0ZTo6 Y29uc3RydWN0RGVsZXRlZFZhbHVlKHNsb3QpOyB9Ci0gICAgc3RhdGljIGJvb2wgaXNEZWxldGVk VmFsdWUoY29uc3QgV2ViQ29yZTo6UHJpdmF0ZUNsaWNrTWVhc3VyZW1lbnQ6OlNvdXJjZVNpdGUm IHNsb3QpIHsgcmV0dXJuIHNsb3QuaXNEZWxldGVkVmFsdWUoKTsgfQorICAgIHN0YXRpYyB2b2lk IGNvbnN0cnVjdERlbGV0ZWRWYWx1ZShXZWJDb3JlOjpQcml2YXRlQ2xpY2tNZWFzdXJlbWVudDo6 U291cmNlU2l0ZSYgc2xvdCkgeyBuZXcgKE5vdE51bGwsICZzbG90LnJlZ2lzdHJhYmxlRG9tYWlu KSBXZWJDb3JlOjpSZWdpc3RyYWJsZURvbWFpbihXVEY6Okhhc2hUYWJsZURlbGV0ZWRWYWx1ZSk7 IH0KKyAgICBzdGF0aWMgYm9vbCBpc0RlbGV0ZWRWYWx1ZShjb25zdCBXZWJDb3JlOjpQcml2YXRl Q2xpY2tNZWFzdXJlbWVudDo6U291cmNlU2l0ZSYgc2xvdCkgeyByZXR1cm4gc2xvdC5yZWdpc3Ry YWJsZURvbWFpbi5pc0hhc2hUYWJsZURlbGV0ZWRWYWx1ZSgpOyB9CiB9OwogCiB0ZW1wbGF0ZTw+ IHN0cnVjdCBEZWZhdWx0SGFzaDxXZWJDb3JlOjpQcml2YXRlQ2xpY2tNZWFzdXJlbWVudDo6QXR0 cmlidXRpb25EZXN0aW5hdGlvblNpdGU+IDogV2ViQ29yZTo6UHJpdmF0ZUNsaWNrTWVhc3VyZW1l bnQ6OkF0dHJpYnV0aW9uRGVzdGluYXRpb25TaXRlSGFzaCB7IH07CiB0ZW1wbGF0ZTw+IHN0cnVj dCBIYXNoVHJhaXRzPFdlYkNvcmU6OlByaXZhdGVDbGlja01lYXN1cmVtZW50OjpBdHRyaWJ1dGlv bkRlc3RpbmF0aW9uU2l0ZT4gOiBHZW5lcmljSGFzaFRyYWl0czxXZWJDb3JlOjpQcml2YXRlQ2xp Y2tNZWFzdXJlbWVudDo6QXR0cmlidXRpb25EZXN0aW5hdGlvblNpdGU+IHsKICAgICBzdGF0aWMg V2ViQ29yZTo6UHJpdmF0ZUNsaWNrTWVhc3VyZW1lbnQ6OkF0dHJpYnV0aW9uRGVzdGluYXRpb25T aXRlIGVtcHR5VmFsdWUoKSB7IHJldHVybiB7IH07IH0KLSAgICBzdGF0aWMgdm9pZCBjb25zdHJ1 Y3REZWxldGVkVmFsdWUoV2ViQ29yZTo6UHJpdmF0ZUNsaWNrTWVhc3VyZW1lbnQ6OkF0dHJpYnV0 aW9uRGVzdGluYXRpb25TaXRlJiBzbG90KSB7IFdlYkNvcmU6OlByaXZhdGVDbGlja01lYXN1cmVt ZW50OjpBdHRyaWJ1dGlvbkRlc3RpbmF0aW9uU2l0ZTo6Y29uc3RydWN0RGVsZXRlZFZhbHVlKHNs b3QpOyB9Ci0gICAgc3RhdGljIGJvb2wgaXNEZWxldGVkVmFsdWUoY29uc3QgV2ViQ29yZTo6UHJp dmF0ZUNsaWNrTWVhc3VyZW1lbnQ6OkF0dHJpYnV0aW9uRGVzdGluYXRpb25TaXRlJiBzbG90KSB7 IHJldHVybiBzbG90LmlzRGVsZXRlZFZhbHVlKCk7IH0KKyAgICBzdGF0aWMgdm9pZCBjb25zdHJ1 Y3REZWxldGVkVmFsdWUoV2ViQ29yZTo6UHJpdmF0ZUNsaWNrTWVhc3VyZW1lbnQ6OkF0dHJpYnV0 aW9uRGVzdGluYXRpb25TaXRlJiBzbG90KSB7IG5ldyAoTm90TnVsbCwgJnNsb3QucmVnaXN0cmFi bGVEb21haW4pIFdlYkNvcmU6OlJlZ2lzdHJhYmxlRG9tYWluKFdURjo6SGFzaFRhYmxlRGVsZXRl ZFZhbHVlKTsgfQorICAgIHN0YXRpYyBib29sIGlzRGVsZXRlZFZhbHVlKGNvbnN0IFdlYkNvcmU6 OlByaXZhdGVDbGlja01lYXN1cmVtZW50OjpBdHRyaWJ1dGlvbkRlc3RpbmF0aW9uU2l0ZSYgc2xv dCkgeyByZXR1cm4gc2xvdC5yZWdpc3RyYWJsZURvbWFpbi5pc0hhc2hUYWJsZURlbGV0ZWRWYWx1 ZSgpOyB9CiB9OwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9DbGllbnRPcmln aW4uaCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvQ2xpZW50T3JpZ2luLmgKaW5kZXggZTU0ZWQ3NWVh ODAwYjAzYTI3YTBlNTJjMGE4MDgyMGZlMTMxZjYxMy4uMTllMjdhMDIyYTU3MThhZWQ0MjhmM2Rh YjBhNDZiOWYwZmM1MmZkNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9DbGllbnRP cmlnaW4uaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0NsaWVudE9yaWdpbi5oCkBAIC0xMDIs NyArMTAyLDcgQEAgc3RydWN0IENsaWVudE9yaWdpbktleUhhc2ggewogdGVtcGxhdGU8PiBzdHJ1 Y3QgSGFzaFRyYWl0czxXZWJDb3JlOjpDbGllbnRPcmlnaW4+IDogR2VuZXJpY0hhc2hUcmFpdHM8 V2ViQ29yZTo6Q2xpZW50T3JpZ2luPiB7CiAgICAgc3RhdGljIFdlYkNvcmU6OkNsaWVudE9yaWdp biBlbXB0eVZhbHVlKCkgeyByZXR1cm4gV2ViQ29yZTo6Q2xpZW50T3JpZ2luOjplbXB0eUtleSgp OyB9CiAKLSAgICBzdGF0aWMgdm9pZCBjb25zdHJ1Y3REZWxldGVkVmFsdWUoV2ViQ29yZTo6Q2xp ZW50T3JpZ2luJiBzbG90KSB7IHNsb3QudG9wT3JpZ2luID0gV2ViQ29yZTo6U2VjdXJpdHlPcmln aW5EYXRhKEhhc2hUYWJsZURlbGV0ZWRWYWx1ZSk7IH0KKyAgICBzdGF0aWMgdm9pZCBjb25zdHJ1 Y3REZWxldGVkVmFsdWUoV2ViQ29yZTo6Q2xpZW50T3JpZ2luJiBzbG90KSB7IG5ldyAoTm90TnVs bCwgJnNsb3QudG9wT3JpZ2luKSBXZWJDb3JlOjpTZWN1cml0eU9yaWdpbkRhdGEoV1RGOjpIYXNo VGFibGVEZWxldGVkVmFsdWUpOyB9CiAgICAgc3RhdGljIGJvb2wgaXNEZWxldGVkVmFsdWUoY29u c3QgV2ViQ29yZTo6Q2xpZW50T3JpZ2luJiBzbG90KSB7IHJldHVybiBzbG90LnRvcE9yaWdpbi5p c0hhc2hUYWJsZURlbGV0ZWRWYWx1ZSgpOyB9CiB9OwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wYWdlL0dsb2JhbFdpbmRvd0lkZW50aWZpZXIuaCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2Uv R2xvYmFsV2luZG93SWRlbnRpZmllci5oCmluZGV4IDVhMWQ3MjNmZGMwYzdlMDg3ZjQ5ZmU1ZGQ2 ODcwZTNhMWM3MDkwMWMuLmYyYmNkMDUwNGE2OTUzYTUyYjYwNTczYTc3YzA1NzUwMjk3ZGYyYzQg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvR2xvYmFsV2luZG93SWRlbnRpZmllci5o CisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvR2xvYmFsV2luZG93SWRlbnRpZmllci5oCkBAIC05 NCw4ICs5NCw4IEBAIHN0cnVjdCBHbG9iYWxXaW5kb3dJZGVudGlmaWVySGFzaCB7CiB0ZW1wbGF0 ZTw+IHN0cnVjdCBIYXNoVHJhaXRzPFdlYkNvcmU6Okdsb2JhbFdpbmRvd0lkZW50aWZpZXI+IDog R2VuZXJpY0hhc2hUcmFpdHM8V2ViQ29yZTo6R2xvYmFsV2luZG93SWRlbnRpZmllcj4gewogICAg IHN0YXRpYyBXZWJDb3JlOjpHbG9iYWxXaW5kb3dJZGVudGlmaWVyIGVtcHR5VmFsdWUoKSB7IHJl dHVybiB7IH07IH0KIAotICAgIHN0YXRpYyB2b2lkIGNvbnN0cnVjdERlbGV0ZWRWYWx1ZShXZWJD b3JlOjpHbG9iYWxXaW5kb3dJZGVudGlmaWVyJiBzbG90KSB7IHNsb3Qud2luZG93SWRlbnRpZmll ciA9IG1ha2VPYmplY3RJZGVudGlmaWVyPFdlYkNvcmU6OldpbmRvd0lkZW50aWZpZXJUeXBlPihz dGQ6Om51bWVyaWNfbGltaXRzPHVpbnQ2NF90Pjo6bWF4KCkpOyB9Ci0gICAgc3RhdGljIGJvb2wg aXNEZWxldGVkVmFsdWUoY29uc3QgV2ViQ29yZTo6R2xvYmFsV2luZG93SWRlbnRpZmllciYgc2xv dCkgeyByZXR1cm4gc2xvdC53aW5kb3dJZGVudGlmaWVyLnRvVUludDY0KCkgPT0gc3RkOjpudW1l cmljX2xpbWl0czx1aW50NjRfdD46Om1heCgpOyB9CisgICAgc3RhdGljIHZvaWQgY29uc3RydWN0 RGVsZXRlZFZhbHVlKFdlYkNvcmU6Okdsb2JhbFdpbmRvd0lkZW50aWZpZXImIHNsb3QpIHsgbmV3 IChOb3ROdWxsLCAmc2xvdC53aW5kb3dJZGVudGlmaWVyKSBXZWJDb3JlOjpXaW5kb3dJZGVudGlm aWVyKFdURjo6SGFzaFRhYmxlRGVsZXRlZFZhbHVlKTsgfQorICAgIHN0YXRpYyBib29sIGlzRGVs ZXRlZFZhbHVlKGNvbnN0IFdlYkNvcmU6Okdsb2JhbFdpbmRvd0lkZW50aWZpZXImIHNsb3QpIHsg cmV0dXJuIHNsb3Qud2luZG93SWRlbnRpZmllci5pc0hhc2hUYWJsZURlbGV0ZWRWYWx1ZSgpOyB9 CiB9OwogCiB0ZW1wbGF0ZTw+IHN0cnVjdCBEZWZhdWx0SGFzaDxXZWJDb3JlOjpHbG9iYWxXaW5k b3dJZGVudGlmaWVyPiA6IEdsb2JhbFdpbmRvd0lkZW50aWZpZXJIYXNoIHsgfTsKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL0Nvb2tpZS5oIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vQ29va2llLmgKaW5kZXggOTg0MzU5Yzg4ZWQ5MTUxNjFmMjIxODI5MjdkZTUzMjI5OGQ3 MDk1Zi4uNWYwOTgwNmYxODMzMzM3NDdmZjZlOTI0MGUzNDVlN2ExMGZjMWVlZiAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vQ29va2llLmgKKysrIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vQ29va2llLmgKQEAgLTQzLDEwICs0Myw2IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsK IAogc3RydWN0IENvb2tpZSB7CiAgICAgQ29va2llKCkgPSBkZWZhdWx0OwotICAgIENvb2tpZShX VEY6Okhhc2hUYWJsZURlbGV0ZWRWYWx1ZVR5cGUpCi0gICAgICAgIDogbmFtZShXVEY6Okhhc2hU YWJsZURlbGV0ZWRWYWx1ZSkKLSAgICB7Ci0gICAgfQogCiAgICAgdGVtcGxhdGU8Y2xhc3MgRW5j b2Rlcj4gdm9pZCBlbmNvZGUoRW5jb2RlciYpIGNvbnN0OwogICAgIHRlbXBsYXRlPGNsYXNzIERl Y29kZXI+IHN0YXRpYyBPcHRpb25hbDxDb29raWU+IGRlY29kZShEZWNvZGVyJik7CkBAIC0xNzMs NyArMTY5LDcgQEAgbmFtZXNwYWNlIFdURiB7CiAgICAgdGVtcGxhdGU8PiBzdHJ1Y3QgRGVmYXVs dEhhc2g8V2ViQ29yZTo6Q29va2llPiA6IFdlYkNvcmU6OkNvb2tpZUhhc2ggeyB9OwogICAgIHRl bXBsYXRlPD4gc3RydWN0IEhhc2hUcmFpdHM8V2ViQ29yZTo6Q29va2llPiA6IEdlbmVyaWNIYXNo VHJhaXRzPFdlYkNvcmU6OkNvb2tpZT4gewogICAgICAgICBzdGF0aWMgV2ViQ29yZTo6Q29va2ll IGVtcHR5VmFsdWUoKSB7IHJldHVybiB7IH07IH0KLSAgICAgICAgc3RhdGljIHZvaWQgY29uc3Ry dWN0RGVsZXRlZFZhbHVlKFdlYkNvcmU6OkNvb2tpZSYgc2xvdCkgeyBzbG90ID0gV2ViQ29yZTo6 Q29va2llKFdURjo6SGFzaFRhYmxlRGVsZXRlZFZhbHVlKTsgfQorICAgICAgICBzdGF0aWMgdm9p ZCBjb25zdHJ1Y3REZWxldGVkVmFsdWUoV2ViQ29yZTo6Q29va2llJiBzbG90KSB7IG5ldyAoTm90 TnVsbCwgJnNsb3QubmFtZSkgU3RyaW5nKFdURjo6SGFzaFRhYmxlRGVsZXRlZFZhbHVlKTsgfQog ICAgICAgICBzdGF0aWMgYm9vbCBpc0RlbGV0ZWRWYWx1ZShjb25zdCBXZWJDb3JlOjpDb29raWUm IHNsb3QpIHsgcmV0dXJuIHNsb3QubmFtZS5pc0hhc2hUYWJsZURlbGV0ZWRWYWx1ZSgpOyB9CiAK ICAgICAgICAgc3RhdGljIGNvbnN0IGJvb2wgaGFzSXNFbXB0eVZhbHVlRnVuY3Rpb24gPSB0cnVl OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvRm9udENhY2hl LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0ZvbnRDYWNoZS5jcHAKaW5k ZXggOGJiMzNlZDU3YWU4NDJjZjEwOTQ2YWQyNzQ3Yjk1OTZjYjA0YTU4Ni4uZjlkZTRlMWZmNzI0 Y2JlNWU2YjA3MGQzNTFjZjMyYjY4MzZhMjViMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvRm9udENhY2hlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9Gb250Q2FjaGUuY3BwCkBAIC05OSw3ICs5OSw3IEBAIHN0cnVjdCBGb250 UGxhdGZvcm1EYXRhQ2FjaGVLZXlIYXNoVHJhaXRzIDogcHVibGljIFNpbXBsZUNsYXNzSGFzaFRy YWl0czxGb250UGxhCiAgICAgc3RhdGljIGNvbnN0ZXhwciBib29sIGVtcHR5VmFsdWVJc1plcm8g PSBmYWxzZTsKICAgICBzdGF0aWMgdm9pZCBjb25zdHJ1Y3REZWxldGVkVmFsdWUoRm9udFBsYXRm b3JtRGF0YUNhY2hlS2V5JiBzbG90KQogICAgIHsKLSAgICAgICAgbmV3IChOb3ROdWxsLCAmc2xv dCkgRm9udFBsYXRmb3JtRGF0YUNhY2hlS2V5IHsgRm9udERlc2NyaXB0aW9uS2V5IHsgV1RGOjpI YXNoVGFibGVEZWxldGVkVmFsdWUgfSwgeyB9LCB7IH0sIHsgfSB9OworICAgICAgICBuZXcgKE5v dE51bGwsICZzbG90LmRlc2NyaXB0aW9uS2V5KSBGb250RGVzY3JpcHRpb25LZXkoV1RGOjpIYXNo VGFibGVEZWxldGVkVmFsdWUpOwogICAgIH0KICAgICBzdGF0aWMgYm9vbCBpc0RlbGV0ZWRWYWx1 ZShjb25zdCBGb250UGxhdGZvcm1EYXRhQ2FjaGVLZXkmIGtleSkKICAgICB7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9Gb250Q2FjaGUuaCBiL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0ZvbnRDYWNoZS5oCmluZGV4IDRlYmE2ZmNmMmY3Yzgw NDhmYjgzZDY1NTRiOGZkNmFmODdjMWFjOWQuLmM5ZDQ4ZmUxMjM1NGEwNTU3MWJlZTE5MjI3NmMy MTBmMjY0Zjk0N2IgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L0ZvbnRDYWNoZS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0ZvbnRD YWNoZS5oCkBAIC0yMDcsNyArMjA3LDcgQEAgc3RydWN0IEZvbnRDYXNjYWRlQ2FjaGVLZXlIYXNo IHsKIAogc3RydWN0IEZvbnRDYXNjYWRlQ2FjaGVLZXlIYXNoVHJhaXRzIDogSGFzaFRyYWl0czxG b250Q2FzY2FkZUNhY2hlS2V5PiB7CiAgICAgc3RhdGljIEZvbnRDYXNjYWRlQ2FjaGVLZXkgZW1w dHlWYWx1ZSgpIHsgcmV0dXJuIHsgfTsgfQotICAgIHN0YXRpYyB2b2lkIGNvbnN0cnVjdERlbGV0 ZWRWYWx1ZShGb250Q2FzY2FkZUNhY2hlS2V5JiBzbG90KSB7IG5ldyAoTm90TnVsbCwgJnNsb3Qp IEZvbnRDYXNjYWRlQ2FjaGVLZXkgeyBGb250RGVzY3JpcHRpb25LZXkgeyBXVEY6Okhhc2hUYWJs ZURlbGV0ZWRWYWx1ZSB9LCB7IH0sIHsgfSwgeyB9IH07IH0KKyAgICBzdGF0aWMgdm9pZCBjb25z dHJ1Y3REZWxldGVkVmFsdWUoRm9udENhc2NhZGVDYWNoZUtleSYgc2xvdCkgeyBuZXcgKE5vdE51 bGwsICZzbG90LmZvbnREZXNjcmlwdGlvbktleSkgRm9udERlc2NyaXB0aW9uS2V5KFdURjo6SGFz aFRhYmxlRGVsZXRlZFZhbHVlKTsgfQogICAgIHN0YXRpYyBib29sIGlzRGVsZXRlZFZhbHVlKGNv bnN0IEZvbnRDYXNjYWRlQ2FjaGVLZXkmIGtleSkgeyByZXR1cm4ga2V5LmZvbnREZXNjcmlwdGlv bktleS5pc0hhc2hUYWJsZURlbGV0ZWRWYWx1ZSgpOyB9CiB9OwogCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9JbnRQb2ludEhhc2guaCBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL0ludFBvaW50SGFzaC5oCmluZGV4IDk3MTI4MmM3NDI3NmJm M2FiN2Q0NzEyYjA3MGYxY2QyNDJmN2U2NGYuLjExMjdiODFkZjA3YzcyNmEwOGEwYzE2YmI4ZDdj YTgxZDE4OWY1NGMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L0ludFBvaW50SGFzaC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0lu dFBvaW50SGFzaC5oCkBAIC0zNSw4ICszNSw4IEBAIHN0cnVjdCBJbnRQb2ludEhhc2ggewogdGVt cGxhdGU8PiBzdHJ1Y3QgSGFzaFRyYWl0czxXZWJDb3JlOjpJbnRQb2ludD4gOiBHZW5lcmljSGFz aFRyYWl0czxXZWJDb3JlOjpJbnRQb2ludD4gewogICAgIHN0YXRpYyBXZWJDb3JlOjpJbnRQb2lu dCBlbXB0eVZhbHVlKCkgeyByZXR1cm4gV2ViQ29yZTo6SW50UG9pbnQoMCwgc3RkOjpudW1lcmlj X2xpbWl0czxpbnQ+OjptaW4oKSk7IH0KICAgICAKLSAgICBzdGF0aWMgdm9pZCBjb25zdHJ1Y3RE ZWxldGVkVmFsdWUoV2ViQ29yZTo6SW50UG9pbnQmIHNsb3QpIHsgc2xvdCA9IFdlYkNvcmU6Oklu dFBvaW50KHN0ZDo6bnVtZXJpY19saW1pdHM8aW50Pjo6bWluKCksIDApOyB9Ci0gICAgc3RhdGlj IGJvb2wgaXNEZWxldGVkVmFsdWUoY29uc3QgV2ViQ29yZTo6SW50UG9pbnQmIHNsb3QpIHsgcmV0 dXJuIHNsb3QgPT0gV2ViQ29yZTo6SW50UG9pbnQoc3RkOjpudW1lcmljX2xpbWl0czxpbnQ+Ojpt aW4oKSwgMCk7IH0KKyAgICBzdGF0aWMgdm9pZCBjb25zdHJ1Y3REZWxldGVkVmFsdWUoV2ViQ29y ZTo6SW50UG9pbnQmIHNsb3QpIHsgc2xvdC5zZXRYKHN0ZDo6bnVtZXJpY19saW1pdHM8aW50Pjo6 bWluKCkpOyB9CisgICAgc3RhdGljIGJvb2wgaXNEZWxldGVkVmFsdWUoY29uc3QgV2ViQ29yZTo6 SW50UG9pbnQmIHNsb3QpIHsgcmV0dXJuIHNsb3QueCgpID09IHN0ZDo6bnVtZXJpY19saW1pdHM8 aW50Pjo6bWluKCk7IH0KIH07CiB0ZW1wbGF0ZTw+IHN0cnVjdCBEZWZhdWx0SGFzaDxXZWJDb3Jl OjpJbnRQb2ludD4gOiBJbnRQb2ludEhhc2ggeyB9OwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9yZW5kZXJpbmcvQ1NTVmFsdWVLZXkuaCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9D U1NWYWx1ZUtleS5oCmluZGV4IGNiMmU4M2RkMjdhZjU0OGQxNTZkZjY1ODJjYzljMWM0MDkxNzc2 YmQuLjJkYmY3NDYwOTgyMWY1MDViNDBmMzMxZTY2YjE3ZTY3MDZiYWJkMTcgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9DU1NWYWx1ZUtleS5oCisrKyBiL1NvdXJjZS9XZWJD b3JlL3JlbmRlcmluZy9DU1NWYWx1ZUtleS5oCkBAIC04OSw3ICs4OSw3IEBAIHN0cnVjdCBDU1NW YWx1ZUtleUhhc2ggewogCiB0ZW1wbGF0ZTw+IHN0cnVjdCBIYXNoVHJhaXRzPFdlYkNvcmU6OkNT U1ZhbHVlS2V5PiA6IEdlbmVyaWNIYXNoVHJhaXRzPFdlYkNvcmU6OkNTU1ZhbHVlS2V5PiB7CiAg ICAgc3RhdGljIFdlYkNvcmU6OkNTU1ZhbHVlS2V5IGVtcHR5VmFsdWUoKSB7IHJldHVybiBXZWJD b3JlOjpDU1NWYWx1ZUtleSB7IFdlYkNvcmU6OkNTU1ZhbHVlSW52YWxpZCwgZmFsc2UsIGZhbHNl fTsgfQotICAgIHN0YXRpYyB2b2lkIGNvbnN0cnVjdERlbGV0ZWRWYWx1ZShXZWJDb3JlOjpDU1NW YWx1ZUtleSYgc2xvdCkgeyBzbG90ID0gV2ViQ29yZTo6Q1NTVmFsdWVLZXkgeyBXZWJDb3JlOjpD U1NWYWx1ZUludmFsaWQsIHRydWUsIHRydWV9O30KKyAgICBzdGF0aWMgdm9pZCBjb25zdHJ1Y3RE ZWxldGVkVmFsdWUoV2ViQ29yZTo6Q1NTVmFsdWVLZXkmIHNsb3QpIHsgbmV3IChOb3ROdWxsLCAm c2xvdCkgV2ViQ29yZTo6Q1NTVmFsdWVLZXkgeyBXZWJDb3JlOjpDU1NWYWx1ZUludmFsaWQsIHRy dWUsIHRydWV9OyB9CiAgICAgc3RhdGljIGJvb2wgaXNEZWxldGVkVmFsdWUoY29uc3QgV2ViQ29y ZTo6Q1NTVmFsdWVLZXkmIHNsb3QpIHsgcmV0dXJuIHNsb3QuY3NzVmFsdWVJRCA9PSBXZWJDb3Jl OjpDU1NWYWx1ZUludmFsaWQgJiYgc2xvdC51c2VEYXJrQXBwZWFyYW5jZSAmJiBzbG90LnVzZUVs ZXZhdGVkVXNlckludGVyZmFjZUxldmVsOyB9CiB9OwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS93b3JrZXJzL3NlcnZpY2UvU2VydmljZVdvcmtlckNsaWVudElkZW50aWZpZXIuaCBiL1Nv dXJjZS9XZWJDb3JlL3dvcmtlcnMvc2VydmljZS9TZXJ2aWNlV29ya2VyQ2xpZW50SWRlbnRpZmll ci5oCmluZGV4IDkzOGJiNTkyZjcyNjhjNjlhYzM3MTgzNzVhNzJiOTY5NmM3Mjk1ZjEuLmMzZmRi NWUxZDZiYTA3MzFmMjZmZjVhNGYzNzU1OGRiNGY0YzE1NzYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL3dvcmtlcnMvc2VydmljZS9TZXJ2aWNlV29ya2VyQ2xpZW50SWRlbnRpZmllci5oCisr KyBiL1NvdXJjZS9XZWJDb3JlL3dvcmtlcnMvc2VydmljZS9TZXJ2aWNlV29ya2VyQ2xpZW50SWRl bnRpZmllci5oCkBAIC0xMDksOSArMTA5LDkgQEAgc3RydWN0IFNlcnZpY2VXb3JrZXJDbGllbnRJ ZGVudGlmaWVySGFzaCB7CiB0ZW1wbGF0ZTw+IHN0cnVjdCBIYXNoVHJhaXRzPFdlYkNvcmU6OlNl cnZpY2VXb3JrZXJDbGllbnRJZGVudGlmaWVyPiA6IEdlbmVyaWNIYXNoVHJhaXRzPFdlYkNvcmU6 OlNlcnZpY2VXb3JrZXJDbGllbnRJZGVudGlmaWVyPiB7CiAgICAgc3RhdGljIFdlYkNvcmU6OlNl cnZpY2VXb3JrZXJDbGllbnRJZGVudGlmaWVyIGVtcHR5VmFsdWUoKSB7IHJldHVybiB7IH07IH0K IAotICAgIHN0YXRpYyB2b2lkIGNvbnN0cnVjdERlbGV0ZWRWYWx1ZShXZWJDb3JlOjpTZXJ2aWNl V29ya2VyQ2xpZW50SWRlbnRpZmllciYgc2xvdCkgeyBzbG90LnNlcnZlckNvbm5lY3Rpb25JZGVu dGlmaWVyID0gbWFrZU9iamVjdElkZW50aWZpZXI8V2ViQ29yZTo6U1dTZXJ2ZXJDb25uZWN0aW9u SWRlbnRpZmllclR5cGU+KHN0ZDo6bnVtZXJpY19saW1pdHM8dWludDY0X3Q+OjptYXgoKSk7IH0K KyAgICBzdGF0aWMgdm9pZCBjb25zdHJ1Y3REZWxldGVkVmFsdWUoV2ViQ29yZTo6U2VydmljZVdv cmtlckNsaWVudElkZW50aWZpZXImIHNsb3QpIHsgbmV3IChOb3ROdWxsLCAmc2xvdC5zZXJ2ZXJD b25uZWN0aW9uSWRlbnRpZmllcikgV2ViQ29yZTo6U1dTZXJ2ZXJDb25uZWN0aW9uSWRlbnRpZmll cihIYXNoVGFibGVEZWxldGVkVmFsdWUpOyB9CiAKLSAgICBzdGF0aWMgYm9vbCBpc0RlbGV0ZWRW YWx1ZShjb25zdCBXZWJDb3JlOjpTZXJ2aWNlV29ya2VyQ2xpZW50SWRlbnRpZmllciYgc2xvdCkg eyByZXR1cm4gc2xvdC5zZXJ2ZXJDb25uZWN0aW9uSWRlbnRpZmllci50b1VJbnQ2NCgpID09IHN0 ZDo6bnVtZXJpY19saW1pdHM8dWludDY0X3Q+OjptYXgoKTsgfQorICAgIHN0YXRpYyBib29sIGlz RGVsZXRlZFZhbHVlKGNvbnN0IFdlYkNvcmU6OlNlcnZpY2VXb3JrZXJDbGllbnRJZGVudGlmaWVy JiBzbG90KSB7IHJldHVybiBzbG90LnNlcnZlckNvbm5lY3Rpb25JZGVudGlmaWVyLmlzSGFzaFRh YmxlRGVsZXRlZFZhbHVlKCk7IH0KIH07CiAKIHRlbXBsYXRlPD4gc3RydWN0IERlZmF1bHRIYXNo PFdlYkNvcmU6OlNlcnZpY2VXb3JrZXJDbGllbnRJZGVudGlmaWVyPiA6IFNlcnZpY2VXb3JrZXJD bGllbnRJZGVudGlmaWVySGFzaCB7IH07CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L05ldHdv cmtQcm9jZXNzL2NhY2hlL05ldHdvcmtDYWNoZS5oIGIvU291cmNlL1dlYktpdC9OZXR3b3JrUHJv Y2Vzcy9jYWNoZS9OZXR3b3JrQ2FjaGUuaAppbmRleCBjNzVkMTcwNGE3NzJlMjk5OTlkZTQzMDlk ODU5YWY4MTdhMDU3NDg0Li42MDE2MDNjODllYmM3OTJlZTNhNzdhNmU2YWEyNWQzNzQwYjE0ODU5 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L05ldHdvcmtQcm9jZXNzL2NhY2hlL05ldHdvcmtD YWNoZS5oCisrKyBiL1NvdXJjZS9XZWJLaXQvTmV0d29ya1Byb2Nlc3MvY2FjaGUvTmV0d29ya0Nh Y2hlLmgKQEAgLTgzLDkgKzgzLDkgQEAgc3RydWN0IEdsb2JhbEZyYW1lSURIYXNoIHsKIHRlbXBs YXRlPD4gc3RydWN0IEhhc2hUcmFpdHM8V2ViS2l0OjpOZXR3b3JrQ2FjaGU6Okdsb2JhbEZyYW1l SUQ+IDogR2VuZXJpY0hhc2hUcmFpdHM8V2ViS2l0OjpOZXR3b3JrQ2FjaGU6Okdsb2JhbEZyYW1l SUQ+IHsKICAgICBzdGF0aWMgV2ViS2l0OjpOZXR3b3JrQ2FjaGU6Okdsb2JhbEZyYW1lSUQgZW1w dHlWYWx1ZSgpIHsgcmV0dXJuIHsgfTsgfQogCi0gICAgc3RhdGljIHZvaWQgY29uc3RydWN0RGVs ZXRlZFZhbHVlKFdlYktpdDo6TmV0d29ya0NhY2hlOjpHbG9iYWxGcmFtZUlEJiBzbG90KSB7IHNs b3Qud2ViUGFnZUlEID0gbWFrZU9iamVjdElkZW50aWZpZXI8V2ViQ29yZTo6UGFnZUlkZW50aWZp ZXJUeXBlPihzdGQ6Om51bWVyaWNfbGltaXRzPHVpbnQ2NF90Pjo6bWF4KCkpOyB9CisgICAgc3Rh dGljIHZvaWQgY29uc3RydWN0RGVsZXRlZFZhbHVlKFdlYktpdDo6TmV0d29ya0NhY2hlOjpHbG9i YWxGcmFtZUlEJiBzbG90KSB7IG5ldyAoTm90TnVsbCwgJnNsb3Qud2ViUGFnZUlEKSBXZWJDb3Jl OjpQYWdlSWRlbnRpZmllcihXVEY6Okhhc2hUYWJsZURlbGV0ZWRWYWx1ZSk7IH0KIAotICAgIHN0 YXRpYyBib29sIGlzRGVsZXRlZFZhbHVlKGNvbnN0IFdlYktpdDo6TmV0d29ya0NhY2hlOjpHbG9i YWxGcmFtZUlEJiBzbG90KSB7IHJldHVybiBzbG90LndlYlBhZ2VJRC50b1VJbnQ2NCgpID09IHN0 ZDo6bnVtZXJpY19saW1pdHM8dWludDY0X3Q+OjptYXgoKTsgfQorICAgIHN0YXRpYyBib29sIGlz RGVsZXRlZFZhbHVlKGNvbnN0IFdlYktpdDo6TmV0d29ya0NhY2hlOjpHbG9iYWxGcmFtZUlEJiBz bG90KSB7IHJldHVybiBzbG90LndlYlBhZ2VJRC5pc0hhc2hUYWJsZURlbGV0ZWRWYWx1ZSgpOyB9 CiB9OwogCiB0ZW1wbGF0ZTw+IHN0cnVjdCBEZWZhdWx0SGFzaDxXZWJLaXQ6Ok5ldHdvcmtDYWNo ZTo6R2xvYmFsRnJhbWVJRD4gOiBHbG9iYWxGcmFtZUlESGFzaCB7IH07CmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViS2l0L1BsYXRmb3JtL0lQQy9TdHJpbmdSZWZlcmVuY2UuaCBiL1NvdXJjZS9XZWJL aXQvUGxhdGZvcm0vSVBDL1N0cmluZ1JlZmVyZW5jZS5oCmluZGV4IGRlNjA2ZDc5MWFhYjc1MGNi OWZiOTIwNmEzZGUxMmQ5N2I0YzllYzYuLjU2YjFkZDAwMWM2ZjE0NWViNjAwNTBhY2VmM2I2Yzgx MmQ5OTZmMGQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvUGxhdGZvcm0vSVBDL1N0cmluZ1Jl ZmVyZW5jZS5oCisrKyBiL1NvdXJjZS9XZWJLaXQvUGxhdGZvcm0vSVBDL1N0cmluZ1JlZmVyZW5j ZS5oCkBAIC03Myw2ICs3Myw4IEBAIHB1YmxpYzoKICAgICB9OwogCiBwcml2YXRlOgorICAgIGZy aWVuZCBzdHJ1Y3QgSGFzaFRyYWl0czxJUEM6OlN0cmluZ1JlZmVyZW5jZT47CisKICAgICBjb25z dCBjaGFyKiBtX2RhdGE7CiAgICAgc2l6ZV90IG1fc2l6ZTsKIH07CkBAIC0xMDEsNyArMTAzLDcg QEAgdGVtcGxhdGU8PiBzdHJ1Y3QgRGVmYXVsdEhhc2g8SVBDOjpTdHJpbmdSZWZlcmVuY2U+IDog SVBDOjpTdHJpbmdSZWZlcmVuY2U6Okhhc2gKIAogdGVtcGxhdGU8PiBzdHJ1Y3QgSGFzaFRyYWl0 czxJUEM6OlN0cmluZ1JlZmVyZW5jZT4gOiBHZW5lcmljSGFzaFRyYWl0czxJUEM6OlN0cmluZ1Jl ZmVyZW5jZT4gewogICAgIHN0YXRpYyBjb25zdCBib29sIGVtcHR5VmFsdWVJc1plcm8gPSAwOwot ICAgIHN0YXRpYyB2b2lkIGNvbnN0cnVjdERlbGV0ZWRWYWx1ZShJUEM6OlN0cmluZ1JlZmVyZW5j ZSYgc3RyaW5nUmVmZXJlbmNlKSB7IHN0cmluZ1JlZmVyZW5jZSA9IElQQzo6U3RyaW5nUmVmZXJl bmNlKDAsIHN0ZDo6bnVtZXJpY19saW1pdHM8c2l6ZV90Pjo6bWF4KCkpOyB9CisgICAgc3RhdGlj IHZvaWQgY29uc3RydWN0RGVsZXRlZFZhbHVlKElQQzo6U3RyaW5nUmVmZXJlbmNlJiBzdHJpbmdS ZWZlcmVuY2UpIHsgc3RyaW5nUmVmZXJlbmNlLm1fc2l6ZSA9IHN0ZDo6bnVtZXJpY19saW1pdHM8 c2l6ZV90Pjo6bWF4KCk7IH0KICAgICBzdGF0aWMgYm9vbCBpc0RlbGV0ZWRWYWx1ZShjb25zdCBJ UEM6OlN0cmluZ1JlZmVyZW5jZSYgc3RyaW5nUmVmZXJlbmNlKSB7IHJldHVybiBzdHJpbmdSZWZl cmVuY2Uuc2l6ZSgpID09IHN0ZDo6bnVtZXJpY19saW1pdHM8c2l6ZV90Pjo6bWF4KCk7IH0KIH07 CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvU2hhcmVkL0NhbGxiYWNrSUQuaCBiL1NvdXJj ZS9XZWJLaXQvU2hhcmVkL0NhbGxiYWNrSUQuaAppbmRleCAxNjM4Y2VkMzRmMTU2OWU1ZGIxMDFh ZThlMWRkZjliYWVkNzUxMThhLi4wNjMwNWM3ZmNkMGE1ODE0MmQ3MzY4OWI2YjMzOTM2MWU1YjU4 ODhiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1NoYXJlZC9DYWxsYmFja0lELmgKKysrIGIv U291cmNlL1dlYktpdC9TaGFyZWQvQ2FsbGJhY2tJRC5oCkBAIC0xMTgsOCArMTE4LDggQEAgc3Ry dWN0IENhbGxiYWNrSURIYXNoIHsKIH07CiB0ZW1wbGF0ZTw+IHN0cnVjdCBIYXNoVHJhaXRzPFdl YktpdDo6Q2FsbGJhY2tJRD4gOiBHZW5lcmljSGFzaFRyYWl0czxXZWJLaXQ6OkNhbGxiYWNrSUQ+ IHsKICAgICBzdGF0aWMgV2ViS2l0OjpDYWxsYmFja0lEIGVtcHR5VmFsdWUoKSB7IHJldHVybiBX ZWJLaXQ6OkNhbGxiYWNrSUQoKTsgfQotICAgIHN0YXRpYyB2b2lkIGNvbnN0cnVjdERlbGV0ZWRW YWx1ZShXZWJLaXQ6OkNhbGxiYWNrSUQmIHNsb3QpIHsgc2xvdCA9IFdlYktpdDo6Q2FsbGJhY2tJ RChzdGQ6Om51bWVyaWNfbGltaXRzPHVpbnQ2NF90Pjo6bWF4KCkpOyB9Ci0gICAgc3RhdGljIGJv b2wgaXNEZWxldGVkVmFsdWUoY29uc3QgV2ViS2l0OjpDYWxsYmFja0lEJiBzbG90KSB7IHJldHVy biBzbG90Lm1faWQgPT0gc3RkOjpudW1lcmljX2xpbWl0czx1aW50NjRfdD46Om1heCgpOyB9Cisg ICAgc3RhdGljIHZvaWQgY29uc3RydWN0RGVsZXRlZFZhbHVlKFdlYktpdDo6Q2FsbGJhY2tJRCYg c2xvdCkgeyBIYXNoVHJhaXRzPHVpbnQ2NF90Pjo6Y29uc3RydWN0RGVsZXRlZFZhbHVlKHNsb3Qu bV9pZCk7IH0KKyAgICBzdGF0aWMgYm9vbCBpc0RlbGV0ZWRWYWx1ZShjb25zdCBXZWJLaXQ6OkNh bGxiYWNrSUQmIHNsb3QpIHsgcmV0dXJuIEhhc2hUcmFpdHM8dWludDY0X3Q+Ojppc0RlbGV0ZWRW YWx1ZShzbG90Lm1faWQpOyB9CiB9OwogdGVtcGxhdGU8PiBzdHJ1Y3QgRGVmYXVsdEhhc2g8V2Vi S2l0OjpDYWxsYmFja0lEPiA6IENhbGxiYWNrSURIYXNoIHsgfTsKIApkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdExlZ2FjeS9tYWMvSGlzdG9yeS9CaW5hcnlQcm9wZXJ0eUxpc3QuY3BwIGIvU291 cmNlL1dlYktpdExlZ2FjeS9tYWMvSGlzdG9yeS9CaW5hcnlQcm9wZXJ0eUxpc3QuY3BwCmluZGV4 IDA0MjA1YjM3MmRhNDc5YmM5ZGI4ZTU2N2M3ZDYyMmU5ZjkyNGZlZDUuLjY5OTBhYTAwYzE2OTY4 MWY5NmIzMGViZDcxYzRmMzlkYTIwY2Y2MzUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXRMZWdh Y3kvbWFjL0hpc3RvcnkvQmluYXJ5UHJvcGVydHlMaXN0LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0 TGVnYWN5L21hYy9IaXN0b3J5L0JpbmFyeVByb3BlcnR5TGlzdC5jcHAKQEAgLTU1LDE1ICs1NSwx MyBAQCBwdWJsaWM6CiAgICAgSW50ZWdlckFycmF5KCkgOiBtX2ludGVnZXJzKDApLCBtX3NpemUo MCkgeyB9CiAgICAgSW50ZWdlckFycmF5KGNvbnN0IGludCogaW50ZWdlcnMsIHNpemVfdCBzaXpl KSA6IG1faW50ZWdlcnMoaW50ZWdlcnMpLCBtX3NpemUoc2l6ZSkgeyBBU1NFUlQoaW50ZWdlcnMp OyBBU1NFUlQoc2l6ZSk7IH0KIAotICAgIHZvaWQgbWFya0RlbGV0ZWQoKSB7IG1faW50ZWdlcnMg PSAwOyBtX3NpemUgPSBkZWxldGVkVmFsdWVTaXplKCk7IH0KLSAgICBib29sIGlzRGVsZXRlZFZh bHVlKCkgY29uc3QgeyByZXR1cm4gbV9zaXplID09IGRlbGV0ZWRWYWx1ZVNpemUoKTsgfQorICAg IGJvb2wgaXNEZWxldGVkVmFsdWUoKSBjb25zdCB7IHJldHVybiBIYXNoVHJhaXRzPHNpemVfdD46 OmlzRGVsZXRlZFZhbHVlKG1fc2l6ZSk7IH0KIAogICAgIGNvbnN0IGludCogaW50ZWdlcnMoKSBj b25zdCB7IEFTU0VSVCghaXNEZWxldGVkVmFsdWUoKSk7IHJldHVybiBtX2ludGVnZXJzOyB9CiAg ICAgc2l6ZV90IHNpemUoKSBjb25zdCB7IEFTU0VSVCghaXNEZWxldGVkVmFsdWUoKSk7IHJldHVy biBtX3NpemU7IH0KIAogcHJpdmF0ZToKLSAgICBzdGF0aWMgc2l6ZV90IGRlbGV0ZWRWYWx1ZVNp emUoKSB7IHJldHVybiBzdGQ6Om51bWVyaWNfbGltaXRzPHNpemVfdD46Om1heCgpOyB9Ci0KKyAg ICBmcmllbmQgc3RydWN0IEludGVnZXJBcnJheUhhc2hUcmFpdHM7CiAgICAgZnJpZW5kIGJvb2wg b3BlcmF0b3I9PShjb25zdCBJbnRlZ2VyQXJyYXkmLCBjb25zdCBJbnRlZ2VyQXJyYXkmKTsKIAog ICAgIGNvbnN0IGludCogbV9pbnRlZ2VyczsKQEAgLTc2LDggKzc0LDggQEAgaW5saW5lIGJvb2wg b3BlcmF0b3I9PShjb25zdCBJbnRlZ2VyQXJyYXkmIGEsIGNvbnN0IEludGVnZXJBcnJheSYgYikK IH0KIAogc3RydWN0IEludGVnZXJBcnJheUhhc2hUcmFpdHMgOiBIYXNoVHJhaXRzPEludGVnZXJB cnJheT4gewotICAgIHN0YXRpYyB2b2lkIGNvbnN0cnVjdERlbGV0ZWRWYWx1ZShJbnRlZ2VyQXJy YXkmIHNsb3QpIHsgc2xvdC5tYXJrRGVsZXRlZCgpOyB9Ci0gICAgc3RhdGljIGJvb2wgaXNEZWxl dGVkVmFsdWUoY29uc3QgSW50ZWdlckFycmF5JiBhcnJheSkgeyByZXR1cm4gYXJyYXkuaXNEZWxl dGVkVmFsdWUoKTsgfQorICAgIHN0YXRpYyB2b2lkIGNvbnN0cnVjdERlbGV0ZWRWYWx1ZShJbnRl Z2VyQXJyYXkmIHNsb3QpIHsgSGFzaFRyYWl0czxzaXplX3Q+Ojpjb25zdHJ1Y3REZWxldGVkVmFs dWUoc2xvdC5tX3NpemUpOyB9CisgICAgc3RhdGljIGJvb2wgaXNEZWxldGVkVmFsdWUoY29uc3Qg SW50ZWdlckFycmF5JiBzbG90KSB7IHJldHVybiBIYXNoVHJhaXRzPHNpemVfdD46OmlzRGVsZXRl ZFZhbHVlKHNsb3QubV9zaXplKTsgfQogfTsKIAogc3RydWN0IEludGVnZXJBcnJheUhhc2ggewo= 426745 2021-04-21 14:19:24 -0700 2021-04-21 14:19:43 -0700 Patch bug-224889-20210421141923.patch text/plain 2498 cdumez U3VidmVyc2lvbiBSZXZpc2lvbjogMjc2Mzg5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggN2Q5YmQyYjVlZGExZDJi YzQ4NDY1MTYwNDVmYWE1NjVmYWJiNjZiMC4uZGQwYzIzNTgwNzE2MDA3OWEzNTJiYzk3YWMwYjU0 OGY5ZWU5MjA4MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIxIEBACisyMDIxLTA0LTIxICBDaHJp cyBEdW1leiAgPGNkdW1lekBhcHBsZS5jb20+CisKKyAgICAgICAgSW1wcm92ZSBvdXIgY29uc3Ry dWN0RGVsZXRlZFZhbHVlKCkgdGVtcGxhdGUgc3BlY2lhbGl6YXRpb25zCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjQ4ODkKKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBUaGlzIHdhcyBhIHRocmVhZC1zYWZl dHkgaXNzdWUuIFRoZSBzdGF0aWMgc3RyaW5nIGluIHJlY29yZHNUYWJsZVNjaGVtYSgpIHdhcyBi ZWluZyB1c2VkCisgICAgICAgIGZyb20gc2V2ZXJhbCB0aHJlYWRzIHdpdGhvdXQgc3luY2hyb25p emF0aW9uLiBUaGUgcmVhc29uIGlzIHRoYXQgdGhlcmUgY2FuIGJlIHNldmVyYWwKKyAgICAgICAg UmVnaXN0cmF0aW9uRGF0YWJhc2UgdGhhdCBjby1leGlzdCAob25lIHBlciBTV1NlcnZlciwgbWVh bmluZyBvbmUgcGVyIHNlc3Npb25JRCkgYW5kIGVhY2gKKyAgICAgICAgUmVnaXN0cmF0aW9uRGF0 YWJhc2Ugd2FzIHVzaW5nIGl0cyBvd24gV29ya1F1ZXVlLgorCisgICAgICAgIFRvIGFkZHJlc3Mg dGhlIGlzc3VlLCBhbGwgUmVnaXN0cmF0aW9uRGF0YWJhc2Ugb2JqZWN0cyBub3cgc2hhcmUgdGhl IHNhbWUgV29ya1F1ZXVlLgorCisgICAgICAgICogd29ya2Vycy9zZXJ2aWNlL3NlcnZlci9SZWdp c3RyYXRpb25EYXRhYmFzZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpyZWdpc3RyYXRpb25EYXRh YmFzZVdvcmtRdWV1ZSk6CisgICAgICAgIChXZWJDb3JlOjpSZWdpc3RyYXRpb25EYXRhYmFzZTo6 UmVnaXN0cmF0aW9uRGF0YWJhc2UpOgorCiAyMDIxLTA0LTIxICBDaHJpcyBEdW1leiAgPGNkdW1l ekBhcHBsZS5jb20+CiAKICAgICAgICAgSW1wcm92ZSBvdXIgY29uc3RydWN0RGVsZXRlZFZhbHVl KCkgdGVtcGxhdGUgc3BlY2lhbGl6YXRpb25zCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS93 b3JrZXJzL3NlcnZpY2Uvc2VydmVyL1JlZ2lzdHJhdGlvbkRhdGFiYXNlLmNwcCBiL1NvdXJjZS9X ZWJDb3JlL3dvcmtlcnMvc2VydmljZS9zZXJ2ZXIvUmVnaXN0cmF0aW9uRGF0YWJhc2UuY3BwCmlu ZGV4IDU5ZTAyOGU5MjY1NDNjNDcxZGM3Yjc0ZWM3YWI3OTY1YTY3MjQ0ODQuLmFhMmY1ZTk5OTVh NGFkOTFlNDFkODRiZDNiMmIxNjJiZTFmZjc2OWUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L3dvcmtlcnMvc2VydmljZS9zZXJ2ZXIvUmVnaXN0cmF0aW9uRGF0YWJhc2UuY3BwCisrKyBiL1Nv dXJjZS9XZWJDb3JlL3dvcmtlcnMvc2VydmljZS9zZXJ2ZXIvUmVnaXN0cmF0aW9uRGF0YWJhc2Uu Y3BwCkBAIC0xNTcsOCArMTU3LDE4IEBAIHN0YXRpYyBIYXNoTWFwPFVSTCwgU2VydmljZVdvcmtl ckNvbnRleHREYXRhOjpJbXBvcnRlZFNjcmlwdD4gcG9wdWxhdGVTY3JpcHRTb3VyCiAgICAgcmV0 dXJuIGltcG9ydGVkU2NyaXB0czsKIH0KIAorc3RhdGljIFJlZjxXb3JrUXVldWU+IHJlZ2lzdHJh dGlvbkRhdGFiYXNlV29ya1F1ZXVlKCkKK3sKKyAgICBzdGF0aWMgTGF6eU5ldmVyRGVzdHJveWVk PFJlZjxXb3JrUXVldWU+PiB3b3JrUXVldWU7CisgICAgc3RhdGljIHN0ZDo6b25jZV9mbGFnIG9u Y2VLZXk7CisgICAgc3RkOjpjYWxsX29uY2Uob25jZUtleSwgWyZdIHsKKyAgICAgICAgd29ya1F1 ZXVlLmNvbnN0cnVjdChXb3JrUXVldWU6OmNyZWF0ZSgiU2VydmljZVdvcmtlciBJL08gVGhyZWFk IiwgV29ya1F1ZXVlOjpUeXBlOjpTZXJpYWwpKTsKKyAgICB9KTsKKyAgICByZXR1cm4gd29ya1F1 ZXVlOworfQorCiBSZWdpc3RyYXRpb25EYXRhYmFzZTo6UmVnaXN0cmF0aW9uRGF0YWJhc2UoUmVn aXN0cmF0aW9uU3RvcmUmIHN0b3JlLCBTdHJpbmcmJiBkYXRhYmFzZURpcmVjdG9yeSkKLSAgICA6 IG1fd29ya1F1ZXVlKFdvcmtRdWV1ZTo6Y3JlYXRlKCJTZXJ2aWNlV29ya2VyIEkvTyBUaHJlYWQi LCBXb3JrUXVldWU6OlR5cGU6OlNlcmlhbCkpCisgICAgOiBtX3dvcmtRdWV1ZShyZWdpc3RyYXRp b25EYXRhYmFzZVdvcmtRdWV1ZSgpKQogICAgICwgbV9zdG9yZShtYWtlV2Vha1B0cihzdG9yZSkp CiAgICAgLCBtX2RhdGFiYXNlRGlyZWN0b3J5KFdURk1vdmUoZGF0YWJhc2VEaXJlY3RvcnkpKQog ICAgICwgbV9kYXRhYmFzZUZpbGVQYXRoKEZpbGVTeXN0ZW06OnBhdGhCeUFwcGVuZGluZ0NvbXBv bmVudChtX2RhdGFiYXNlRGlyZWN0b3J5LCBkYXRhYmFzZUZpbGVuYW1lKCkpKQo=