181620 2018-01-12 16:08:55 -0800 Use a helper function for checked arithmetic in WebGL validation 2018-01-15 14:37:19 -0800 1 1 1 Unclassified WebKit New Bugs WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 181621 1 dino dino cdumez commit-queue darin eric.carlson esprehn+autocc ews-watchlist graouts gyuyoung.kim kondapallykalyan webkit-bug-importer oldest_to_newest 1388998 0 dino 2018-01-12 16:08:55 -0800 Use a helper function for checked arithmetic in WebGL validation 1389000 1 webkit-bug-importer 2018-01-12 16:10:13 -0800 <rdar://problem/36485879> 1389003 2 331250 dino 2018-01-12 16:11:50 -0800 Created attachment 331250 Patch 1389008 3 dino 2018-01-12 16:31:22 -0800 Committed r226927: <https://trac.webkit.org/changeset/226927> 1389016 4 commit-queue 2018-01-12 16:44:03 -0800 Re-opened since this is blocked by bug 181621 1389354 5 dino 2018-01-15 12:44:14 -0800 Committed r226953: <https://trac.webkit.org/changeset/226953> 1389383 6 331250 darin 2018-01-15 14:37:19 -0800 Comment on attachment 331250 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=331250&action=review > Source/WebCore/html/canvas/WebGL2RenderingContext.cpp:1830 > - Checked<unsigned, RecordOverflow> checkedNumElementsRequired = Checked<unsigned>(maxIndex.value()); > - checkedNumElementsRequired += 1; > - if (checkedNumElementsRequired.hasOverflowed()) > + auto checkedNumElementsRequired = checkedAddAndMultiply<unsigned>(maxIndex.value(), 1, 1); > + if (!checkedNumElementsRequired) > return false; > - numElementsRequired = checkedNumElementsRequired.unsafeGet(); > + numElementsRequired = checkedNumElementsRequired.value(); > + > return true; I am not sure the new helper function is so great here since we don’t have any multiplying to do. Idiomatic use of Checked would be simple. Like this: auto checkedNumElementsRequired = Checked<unsigned, RecordOverflow>(maxIndex.value()) + 1; if (checkedNumElementsRequired.hasOverflowed()) return false; numElementsRequired = checkedNumElementsRequired.unsafeGet(); return true; I don’t think the checkedAddAndMultiply version is better. > Source/WebCore/html/canvas/WebGLRenderingContext.cpp:727 > - // The number of required elements is one more than the maximum > - // index that will be accessed. > - Checked<unsigned, RecordOverflow> checkedNumElementsRequired = Checked<unsigned>(maxIndex.value()); > - checkedNumElementsRequired += 1; > - if (checkedNumElementsRequired.hasOverflowed()) > + // The number of required elements is one more than the maximum index that will be accessed. > + auto checkedNumElementsRequired = checkedAddAndMultiply<unsigned>(maxIndex.value(), 1, 1); > + if (!checkedNumElementsRequired) > return false; > - numElementsRequired = checkedNumElementsRequired.unsafeGet(); > + numElementsRequired = checkedNumElementsRequired.value(); > + > return true; Ditto. > Source/WebCore/html/canvas/WebGLRenderingContextBase.cpp:1851 > + Checked<T, RecordOverflow> checkedResult = Checked<T>(value); > + checkedResult += Checked<T>(add); > + checkedResult *= Checked<T>(multiply); If we decide to keep this: We don’t need so many typecasts here. Once something is Checked we can do arithmetic and everything stays checked. Also Checked<T> is not a good type to mix with Checked<T, RecordOverflow>. Here’s how I would write this: auto checkedResult = (Checked<GC3Dint, RecordOverflow>(value) + add) * multiply; The typecasts are not needed. When a value is Checked<>, you don’t need to convert the other values to Checked<> before doing math with them. Everything stays checked as long as one of the two arguments to each operator is checked and the right type. > Source/WebCore/html/canvas/WebGLRenderingContextBase.cpp:1911 > - Checked<unsigned, RecordOverflow> checkedNumElementsRequired = Checked<unsigned>(lastIndex); > - checkedNumElementsRequired += 1; > - if (checkedNumElementsRequired.hasOverflowed()) > + auto checkedNumElementsRequired = checkedAddAndMultiply<unsigned>(lastIndex, 1, 1); > + if (!checkedNumElementsRequired) > return false; > - numElementsRequired = checkedNumElementsRequired.unsafeGet(); > + numElementsRequired = checkedNumElementsRequired.value(); > return true; Another case where the multiplying doesn’t really come in handy. So same comment as the first two call sites. > Source/WebCore/html/canvas/WebGLRenderingContextBase.cpp:2024 > - Checked<GC3Dint, RecordOverflow> checkedFirst(first); > - Checked<GC3Dint, RecordOverflow> checkedCount(count); > - Checked<GC3Dint, RecordOverflow> checkedSum = checkedFirst + checkedCount; > + Checked<GC3Dint, RecordOverflow> checkedSum = Checked<GC3Dint, RecordOverflow>(first) + Checked<GC3Dint, RecordOverflow>(count); Don’t need so many typecasts here. This is a good way to write it: auto checkedSum = Checked<GC3Dint, RecordOverflow>(first) + count; > Source/WebCore/html/canvas/WebGLRenderingContextBase.cpp:5732 > - Checked<GC3Duint, RecordOverflow> bufferSize(numVertex); > - bufferSize += 1; > - bufferSize *= Checked<GC3Duint>(4); > - if (bufferSize.hasOverflowed()) > + auto bufferSize = checkedAddAndMultiply<GC3Duint>(numVertex, 1, 4); > + if (!bufferSize) > return false; > - Checked<GC3Dsizeiptr, RecordOverflow> bufferDataSize(bufferSize); > + > + Checked<GC3Dsizeiptr, RecordOverflow> bufferDataSize(bufferSize.value()); > bufferDataSize *= Checked<GC3Dsizeiptr>(sizeof(GC3Dfloat)); > return !bufferDataSize.hasOverflowed() && bufferDataSize.unsafeGet() > 0; I think this can be written more simply without the helper function: auto bufferSize = (Checked<GC3Duint, RecordOverflow>(numVertex) + 1) * 4; auto bufferDataSize = Checked<GC3Dsizeiptr, RecordOverflow>(bufferSize) * sizeof(GC3Dfloat); return !bufferDataSize.hasOverflowed() && bufferDataSize.unsafeGet() > 0; If bufferSize overflowed, then bufferDataSize will be set to overflowed also, so no extra code is needed to explicitly check that. > Source/WebCore/html/canvas/WebGLRenderingContextBase.h:832 > + template <typename T> static std::optional<T> checkedAddAndMultiply(T value, T add, T multiply); Not sure that std::optional<T> is a better return type than Checked<T, RecordOverflow>. The only difference for callers is that we need to check overflowed() instead of checking has_value() and use unsafeGet() instead of value(). Doesn’t seem much different. I don’t think this function made things better in any of the four places we used it. I think the real problem is that we are writing Checked<> code in an excessively complex way. All we need to do is cast one value to the appropriate Checked<> type and not specify explicit types for things after that, and the code ends up being pretty readable. 331250 2018-01-12 16:11:50 -0800 2018-01-12 16:22:34 -0800 Patch bug-181620-20180113111147.patch text/plain 10494 dino U3VidmVyc2lvbiBSZXZpc2lvbjogMjI2NTIxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMmVhMDJhNGIwZjA4NDAz MmMwNzEwNGI5YmRjMTMyNjdlNGM1NDdkNS4uNzA0MzNlNGJlODA4YWI5YmQ0ZmQ5MThlNTc3MDhk NWVhMjkzNGUxMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI2IEBACisyMDE4LTAxLTEyICBEZWFu IEphY2tzb24gIDxkaW5vQGFwcGxlLmNvbT4KKworICAgICAgICBVc2UgYSBoZWxwZXIgZnVuY3Rp b24gZm9yIGNoZWNrZWQgYXJpdGhtZXRpYyBpbiBXZWJHTCB2YWxpZGF0aW9uCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xODE2MjAKKyAgICAgICAgPHJk YXI6Ly9wcm9ibGVtLzM2NDg1ODc5PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIEVyaWMgcmVjb21tZW5kZWQgdXNpbmcgYSB0ZW1wbGF0ZWQgaGVscGVy IGZ1bmN0aW9uIHRvIGRvCisgICAgICAgIGEgY29tbW9uIGFyaXRobWV0aWMgY2hlY2sgaW4gV2Vi R0wgdmFsaWRhdGlvbi4KKworICAgICAgICAqIGh0bWwvY2FudmFzL1dlYkdMMlJlbmRlcmluZ0Nv bnRleHQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6V2ViR0wyUmVuZGVyaW5nQ29udGV4dDo6dmFs aWRhdGVJbmRleEFycmF5Q29uc2VydmF0aXZlKToKKyAgICAgICAgKiBodG1sL2NhbnZhcy9XZWJH TFJlbmRlcmluZ0NvbnRleHQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6V2ViR0xSZW5kZXJpbmdD b250ZXh0Ojp2YWxpZGF0ZUluZGV4QXJyYXlDb25zZXJ2YXRpdmUpOgorICAgICAgICAqIGh0bWwv Y2FudmFzL1dlYkdMUmVuZGVyaW5nQ29udGV4dEJhc2UuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 V2ViR0xSZW5kZXJpbmdDb250ZXh0QmFzZTo6Y2hlY2tlZEFkZEFuZE11bHRpcGx5KTogTmV3IGhl bHBlci4KKyAgICAgICAgKFdlYkNvcmU6OldlYkdMUmVuZGVyaW5nQ29udGV4dEJhc2U6OnZhbGlk YXRlSW5kZXhBcnJheVByZWNpc2UpOgorICAgICAgICAoV2ViQ29yZTo6V2ViR0xSZW5kZXJpbmdD b250ZXh0QmFzZTo6dmFsaWRhdGVEcmF3QXJyYXlzKToKKyAgICAgICAgKFdlYkNvcmU6OldlYkdM UmVuZGVyaW5nQ29udGV4dEJhc2U6OnZhbGlkYXRlU2ltdWxhdGVkVmVydGV4QXR0cmliMCk6Cisg ICAgICAgIChXZWJDb3JlOjpXZWJHTFJlbmRlcmluZ0NvbnRleHRCYXNlOjpzaW11bGF0ZVZlcnRl eEF0dHJpYjApOgorICAgICAgICAqIGh0bWwvY2FudmFzL1dlYkdMUmVuZGVyaW5nQ29udGV4dEJh c2UuaDoKKwogMjAxOC0wMS0xMSAgRGVhbiBKYWNrc29uICA8ZGlub0BhcHBsZS5jb20+CiAKICAg ICAgICAgW1dlYkdMXSBTaW11bGF0ZWQgdmVydGV4QXR0cmliMCBjYW4gc29tZXRpbWVzIGNhdXNl IE9VVF9PRl9NRU1PUlkgZXJyb3JzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL2Nh bnZhcy9XZWJHTDJSZW5kZXJpbmdDb250ZXh0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvY2Fu dmFzL1dlYkdMMlJlbmRlcmluZ0NvbnRleHQuY3BwCmluZGV4IDFlZTI2ODc0OTYxMmZlMDUyMjFh MTQ1Y2NiYjhhMDA0NWVkYWE3YWQuLmRkZDA5NDcyMmIyNTAwNTRhZmRhMGM2OGEyOGQ0ODExMTg0 YTQ2NTMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvY2FudmFzL1dlYkdMMlJlbmRl cmluZ0NvbnRleHQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvY2FudmFzL1dlYkdMMlJl bmRlcmluZ0NvbnRleHQuY3BwCkBAIC0xODIyLDExICsxODIyLDExIEBAIGJvb2wgV2ViR0wyUmVu ZGVyaW5nQ29udGV4dDo6dmFsaWRhdGVJbmRleEFycmF5Q29uc2VydmF0aXZlKEdDM0RlbnVtIHR5 cGUsIHVuc2lnCiAKICAgICAvLyBUaGUgbnVtYmVyIG9mIHJlcXVpcmVkIGVsZW1lbnRzIGlzIG9u ZSBtb3JlIHRoYW4gdGhlIG1heGltdW0KICAgICAvLyBpbmRleCB0aGF0IHdpbGwgYmUgYWNjZXNz ZWQuCi0gICAgQ2hlY2tlZDx1bnNpZ25lZCwgUmVjb3JkT3ZlcmZsb3c+IGNoZWNrZWROdW1FbGVt ZW50c1JlcXVpcmVkID0gQ2hlY2tlZDx1bnNpZ25lZD4obWF4SW5kZXgudmFsdWUoKSk7Ci0gICAg Y2hlY2tlZE51bUVsZW1lbnRzUmVxdWlyZWQgKz0gMTsKLSAgICBpZiAoY2hlY2tlZE51bUVsZW1l bnRzUmVxdWlyZWQuaGFzT3ZlcmZsb3dlZCgpKQorICAgIGF1dG8gY2hlY2tlZE51bUVsZW1lbnRz UmVxdWlyZWQgPSBjaGVja2VkQWRkQW5kTXVsdGlwbHk8dW5zaWduZWQ+KG1heEluZGV4LnZhbHVl KCksIDEsIDEpOworICAgIGlmICghY2hlY2tlZE51bUVsZW1lbnRzUmVxdWlyZWQpCiAgICAgICAg IHJldHVybiBmYWxzZTsKLSAgICBudW1FbGVtZW50c1JlcXVpcmVkID0gY2hlY2tlZE51bUVsZW1l bnRzUmVxdWlyZWQudW5zYWZlR2V0KCk7CisgICAgbnVtRWxlbWVudHNSZXF1aXJlZCA9IGNoZWNr ZWROdW1FbGVtZW50c1JlcXVpcmVkLnZhbHVlKCk7CisKICAgICByZXR1cm4gdHJ1ZTsKIH0KIApk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9jYW52YXMvV2ViR0xSZW5kZXJpbmdDb250 ZXh0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvY2FudmFzL1dlYkdMUmVuZGVyaW5nQ29udGV4 dC5jcHAKaW5kZXggZDY5M2EyNmJmOGNlOTg5ZThkY2E0ZTQ2NTYyMzJkYjE1Y2UwOGIzOC4uYjEw MWIxNjFmYzU2NjNkNDA1NjlkOTZjMGRmZTI2YWI1NGNlYTM5MCAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvaHRtbC9jYW52YXMvV2ViR0xSZW5kZXJpbmdDb250ZXh0LmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9odG1sL2NhbnZhcy9XZWJHTFJlbmRlcmluZ0NvbnRleHQuY3BwCkBAIC03MTgs MTMgKzcxOCwxMiBAQCBib29sIFdlYkdMUmVuZGVyaW5nQ29udGV4dDo6dmFsaWRhdGVJbmRleEFy cmF5Q29uc2VydmF0aXZlKEdDM0RlbnVtIHR5cGUsIHVuc2lnbgogICAgIGlmICghbWF4SW5kZXgp CiAgICAgICAgIHJldHVybiBmYWxzZTsKIAotICAgIC8vIFRoZSBudW1iZXIgb2YgcmVxdWlyZWQg ZWxlbWVudHMgaXMgb25lIG1vcmUgdGhhbiB0aGUgbWF4aW11bQotICAgIC8vIGluZGV4IHRoYXQg d2lsbCBiZSBhY2Nlc3NlZC4KLSAgICBDaGVja2VkPHVuc2lnbmVkLCBSZWNvcmRPdmVyZmxvdz4g Y2hlY2tlZE51bUVsZW1lbnRzUmVxdWlyZWQgPSBDaGVja2VkPHVuc2lnbmVkPihtYXhJbmRleC52 YWx1ZSgpKTsKLSAgICBjaGVja2VkTnVtRWxlbWVudHNSZXF1aXJlZCArPSAxOwotICAgIGlmIChj aGVja2VkTnVtRWxlbWVudHNSZXF1aXJlZC5oYXNPdmVyZmxvd2VkKCkpCisgICAgLy8gVGhlIG51 bWJlciBvZiByZXF1aXJlZCBlbGVtZW50cyBpcyBvbmUgbW9yZSB0aGFuIHRoZSBtYXhpbXVtIGlu ZGV4IHRoYXQgd2lsbCBiZSBhY2Nlc3NlZC4KKyAgICBhdXRvIGNoZWNrZWROdW1FbGVtZW50c1Jl cXVpcmVkID0gY2hlY2tlZEFkZEFuZE11bHRpcGx5PHVuc2lnbmVkPihtYXhJbmRleC52YWx1ZSgp LCAxLCAxKTsKKyAgICBpZiAoIWNoZWNrZWROdW1FbGVtZW50c1JlcXVpcmVkKQogICAgICAgICBy ZXR1cm4gZmFsc2U7Ci0gICAgbnVtRWxlbWVudHNSZXF1aXJlZCA9IGNoZWNrZWROdW1FbGVtZW50 c1JlcXVpcmVkLnVuc2FmZUdldCgpOworICAgIG51bUVsZW1lbnRzUmVxdWlyZWQgPSBjaGVja2Vk TnVtRWxlbWVudHNSZXF1aXJlZC52YWx1ZSgpOworCiAgICAgcmV0dXJuIHRydWU7CiB9CiAKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvY2FudmFzL1dlYkdMUmVuZGVyaW5nQ29udGV4 dEJhc2UuY3BwIGIvU291cmNlL1dlYkNvcmUvaHRtbC9jYW52YXMvV2ViR0xSZW5kZXJpbmdDb250 ZXh0QmFzZS5jcHAKaW5kZXggNmQ3ZjgyOTA2YjU3MjUzZjRkOGNmZjJlN2QwZGIwZTdmZDg5ZTkz MS4uYzMxZGQ5MzY2MjllOWU2MDlkYmM2YzE4MTdjYzE3OGJmYTRlZTZjYSAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvaHRtbC9jYW52YXMvV2ViR0xSZW5kZXJpbmdDb250ZXh0QmFzZS5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9jYW52YXMvV2ViR0xSZW5kZXJpbmdDb250ZXh0QmFz ZS5jcHAKQEAgLTE4NDMsNiArMTg0MywxOCBAQCBib29sIFdlYkdMUmVuZGVyaW5nQ29udGV4dEJh c2U6OnZhbGlkYXRlRWxlbWVudEFycmF5U2l6ZShHQzNEc2l6ZWkgY291bnQsIEdDM0RlbgogICAg IHJldHVybiB0cnVlOwogfQogCit0ZW1wbGF0ZSA8dHlwZW5hbWUgVD4KK3N0ZDo6b3B0aW9uYWw8 VD4gV2ViR0xSZW5kZXJpbmdDb250ZXh0QmFzZTo6Y2hlY2tlZEFkZEFuZE11bHRpcGx5KFQgdmFs dWUsIFQgYWRkLCBUIG11bHRpcGx5KQoreworICAgIENoZWNrZWQ8VCwgUmVjb3JkT3ZlcmZsb3c+ IGNoZWNrZWRSZXN1bHQgPSBDaGVja2VkPFQ+KHZhbHVlKTsKKyAgICBjaGVja2VkUmVzdWx0ICs9 IENoZWNrZWQ8VD4oYWRkKTsKKyAgICBjaGVja2VkUmVzdWx0ICo9IENoZWNrZWQ8VD4obXVsdGlw bHkpOworICAgIGlmIChjaGVja2VkUmVzdWx0Lmhhc092ZXJmbG93ZWQoKSkKKyAgICAgICAgcmV0 dXJuIHN0ZDo6bnVsbG9wdDsKKworICAgIHJldHVybiBjaGVja2VkUmVzdWx0LnVuc2FmZUdldCgp OworfQorCiBib29sIFdlYkdMUmVuZGVyaW5nQ29udGV4dEJhc2U6OnZhbGlkYXRlSW5kZXhBcnJh eVByZWNpc2UoR0MzRHNpemVpIGNvdW50LCBHQzNEZW51bSB0eXBlLCBHQzNEaW50cHRyIG9mZnNl dCwgdW5zaWduZWQmIG51bUVsZW1lbnRzUmVxdWlyZWQpCiB7CiAgICAgQVNTRVJUKGNvdW50ID49 IDAgJiYgb2Zmc2V0ID49IDApOwpAQCAtMTg5MiwxMSArMTkwNCwxMCBAQCBib29sIFdlYkdMUmVu ZGVyaW5nQ29udGV4dEJhc2U6OnZhbGlkYXRlSW5kZXhBcnJheVByZWNpc2UoR0MzRHNpemVpIGNv dW50LCBHQzNEZQogICAgIH0KIAogICAgIC8vIFRoZW4gc2V0IHRoZSBsYXN0IGluZGV4IGluIHRo ZSBpbmRleCBhcnJheSBhbmQgbWFrZSBzdXJlIGl0IGlzIHZhbGlkLgotICAgIENoZWNrZWQ8dW5z aWduZWQsIFJlY29yZE92ZXJmbG93PiBjaGVja2VkTnVtRWxlbWVudHNSZXF1aXJlZCA9IENoZWNr ZWQ8dW5zaWduZWQ+KGxhc3RJbmRleCk7Ci0gICAgY2hlY2tlZE51bUVsZW1lbnRzUmVxdWlyZWQg Kz0gMTsKLSAgICBpZiAoY2hlY2tlZE51bUVsZW1lbnRzUmVxdWlyZWQuaGFzT3ZlcmZsb3dlZCgp KQorICAgIGF1dG8gY2hlY2tlZE51bUVsZW1lbnRzUmVxdWlyZWQgPSBjaGVja2VkQWRkQW5kTXVs dGlwbHk8dW5zaWduZWQ+KGxhc3RJbmRleCwgMSwgMSk7CisgICAgaWYgKCFjaGVja2VkTnVtRWxl bWVudHNSZXF1aXJlZCkKICAgICAgICAgcmV0dXJuIGZhbHNlOwotICAgIG51bUVsZW1lbnRzUmVx dWlyZWQgPSBjaGVja2VkTnVtRWxlbWVudHNSZXF1aXJlZC51bnNhZmVHZXQoKTsKKyAgICBudW1F bGVtZW50c1JlcXVpcmVkID0gY2hlY2tlZE51bUVsZW1lbnRzUmVxdWlyZWQudmFsdWUoKTsKICAg ICByZXR1cm4gdHJ1ZTsKIH0KIApAQCAtMjAxMCw5ICsyMDIxLDcgQEAgYm9vbCBXZWJHTFJlbmRl cmluZ0NvbnRleHRCYXNlOjp2YWxpZGF0ZURyYXdBcnJheXMoY29uc3QgY2hhciogZnVuY3Rpb25O YW1lLCBHQzMKICAgICB9CiAKICAgICAvLyBFbnN1cmUgd2UgaGF2ZSBhIHZhbGlkIHJlbmRlcmlu ZyBzdGF0ZS4KLSAgICBDaGVja2VkPEdDM0RpbnQsIFJlY29yZE92ZXJmbG93PiBjaGVja2VkRmly c3QoZmlyc3QpOwotICAgIENoZWNrZWQ8R0MzRGludCwgUmVjb3JkT3ZlcmZsb3c+IGNoZWNrZWRD b3VudChjb3VudCk7Ci0gICAgQ2hlY2tlZDxHQzNEaW50LCBSZWNvcmRPdmVyZmxvdz4gY2hlY2tl ZFN1bSA9IGNoZWNrZWRGaXJzdCArIGNoZWNrZWRDb3VudDsKKyAgICBDaGVja2VkPEdDM0RpbnQs IFJlY29yZE92ZXJmbG93PiBjaGVja2VkU3VtID0gQ2hlY2tlZDxHQzNEaW50LCBSZWNvcmRPdmVy Zmxvdz4oZmlyc3QpICsgQ2hlY2tlZDxHQzNEaW50LCBSZWNvcmRPdmVyZmxvdz4oY291bnQpOwog ICAgIENoZWNrZWQ8R0MzRGludCwgUmVjb3JkT3ZlcmZsb3c+IGNoZWNrZWRQcmltaXRpdmVDb3Vu dChwcmltaXRpdmVDb3VudCk7CiAgICAgaWYgKGNoZWNrZWRTdW0uaGFzT3ZlcmZsb3dlZCgpIHx8 IGNoZWNrZWRQcmltaXRpdmVDb3VudC5oYXNPdmVyZmxvd2VkKCkgfHwgIXZhbGlkYXRlVmVydGV4 QXR0cmlidXRlcyhjaGVja2VkU3VtLnVuc2FmZUdldCgpLCBjaGVja2VkUHJpbWl0aXZlQ291bnQu dW5zYWZlR2V0KCkpKSB7CiAgICAgICAgIHN5bnRoZXNpemVHTEVycm9yKEdyYXBoaWNzQ29udGV4 dDNEOjpJTlZBTElEX09QRVJBVElPTiwgZnVuY3Rpb25OYW1lLCAiYXR0ZW1wdCB0byBhY2Nlc3Mg b3V0IG9mIGJvdW5kcyBhcnJheXMiKTsKQEAgLTU3MTQsMTIgKzU3MjMsMTEgQEAgYm9vbCBXZWJH TFJlbmRlcmluZ0NvbnRleHRCYXNlOjp2YWxpZGF0ZVNpbXVsYXRlZFZlcnRleEF0dHJpYjAoR0Mz RHVpbnQgbnVtVmVydGUKICAgICBpZiAoc3RhdGUuZW5hYmxlZCkKICAgICAgICAgcmV0dXJuIHRy dWU7CiAKLSAgICBDaGVja2VkPEdDM0R1aW50LCBSZWNvcmRPdmVyZmxvdz4gYnVmZmVyU2l6ZShu dW1WZXJ0ZXgpOwotICAgIGJ1ZmZlclNpemUgKz0gMTsKLSAgICBidWZmZXJTaXplICo9IENoZWNr ZWQ8R0MzRHVpbnQ+KDQpOwotICAgIGlmIChidWZmZXJTaXplLmhhc092ZXJmbG93ZWQoKSkKKyAg ICBhdXRvIGJ1ZmZlclNpemUgPSBjaGVja2VkQWRkQW5kTXVsdGlwbHk8R0MzRHVpbnQ+KG51bVZl cnRleCwgMSwgNCk7CisgICAgaWYgKCFidWZmZXJTaXplKQogICAgICAgICByZXR1cm4gZmFsc2U7 Ci0gICAgQ2hlY2tlZDxHQzNEc2l6ZWlwdHIsIFJlY29yZE92ZXJmbG93PiBidWZmZXJEYXRhU2l6 ZShidWZmZXJTaXplKTsKKworICAgIENoZWNrZWQ8R0MzRHNpemVpcHRyLCBSZWNvcmRPdmVyZmxv dz4gYnVmZmVyRGF0YVNpemUoYnVmZmVyU2l6ZS52YWx1ZSgpKTsKICAgICBidWZmZXJEYXRhU2l6 ZSAqPSBDaGVja2VkPEdDM0RzaXplaXB0cj4oc2l6ZW9mKEdDM0RmbG9hdCkpOwogICAgIHJldHVy biAhYnVmZmVyRGF0YVNpemUuaGFzT3ZlcmZsb3dlZCgpICYmIGJ1ZmZlckRhdGFTaXplLnVuc2Fm ZUdldCgpID4gMDsKIH0KQEAgLTU3NDAsMjIgKzU3NDgsMTkgQEAgc3RkOjpvcHRpb25hbDxib29s PiBXZWJHTFJlbmRlcmluZ0NvbnRleHRCYXNlOjpzaW11bGF0ZVZlcnRleEF0dHJpYjAoR0MzRHVp bnQgbnUKICAgICBtX3ZlcnRleEF0dHJpYjBVc2VkQmVmb3JlID0gdHJ1ZTsKICAgICBtX2NvbnRl eHQtPmJpbmRCdWZmZXIoR3JhcGhpY3NDb250ZXh0M0Q6OkFSUkFZX0JVRkZFUiwgbV92ZXJ0ZXhB dHRyaWIwQnVmZmVyLT5vYmplY3QoKSk7CiAKLSAgICBDaGVja2VkPEdDM0R1aW50PiBidWZmZXJT aXplKG51bVZlcnRleCk7Ci0gICAgYnVmZmVyU2l6ZSArPSAxOwotICAgIGJ1ZmZlclNpemUgKj0g Q2hlY2tlZDxHQzNEdWludD4oNCk7Ci0KLSAgICBDaGVja2VkPEdDM0RzaXplaXB0cj4gYnVmZmVy RGF0YVNpemUoYnVmZmVyU2l6ZSk7Ci0gICAgYnVmZmVyRGF0YVNpemUgKj0gQ2hlY2tlZDxHQzNE c2l6ZWlwdHI+KHNpemVvZihHQzNEZmxvYXQpKTsKKyAgICAvLyBXZSBrbm93IGJ1ZmZlclNpemUg YW5kIGJ1ZmZlckRhdGFTaXplIHdvbid0IG92ZXJmbG93IG9yIGdvIG5lZ2F0aXZlLCB0aGFua3Mg dG8gdmFsaWRhdGVTaW11bGF0ZWRWZXJ0ZXhBdHRyaWIwCisgICAgR0MzRHVpbnQgYnVmZmVyU2l6 ZSA9IChudW1WZXJ0ZXggKyAxKSAqIDQ7CisgICAgR0MzRHNpemVpcHRyIGJ1ZmZlckRhdGFTaXpl ID0gYnVmZmVyU2l6ZSAqIHNpemVvZihHQzNEZmxvYXQpOwogCi0gICAgaWYgKGJ1ZmZlckRhdGFT aXplLnVuc2FmZUdldCgpID4gbV92ZXJ0ZXhBdHRyaWIwQnVmZmVyU2l6ZSkgeworICAgIGlmIChi dWZmZXJEYXRhU2l6ZSA+IG1fdmVydGV4QXR0cmliMEJ1ZmZlclNpemUpIHsKICAgICAgICAgbV9j b250ZXh0LT5tb3ZlRXJyb3JzVG9TeW50aGV0aWNFcnJvckxpc3QoKTsKLSAgICAgICAgbV9jb250 ZXh0LT5idWZmZXJEYXRhKEdyYXBoaWNzQ29udGV4dDNEOjpBUlJBWV9CVUZGRVIsIGJ1ZmZlckRh dGFTaXplLnVuc2FmZUdldCgpLCAwLCBHcmFwaGljc0NvbnRleHQzRDo6RFlOQU1JQ19EUkFXKTsK KyAgICAgICAgbV9jb250ZXh0LT5idWZmZXJEYXRhKEdyYXBoaWNzQ29udGV4dDNEOjpBUlJBWV9C VUZGRVIsIGJ1ZmZlckRhdGFTaXplLCAwLCBHcmFwaGljc0NvbnRleHQzRDo6RFlOQU1JQ19EUkFX KTsKICAgICAgICAgaWYgKG1fY29udGV4dC0+Z2V0RXJyb3IoKSAhPSBHcmFwaGljc0NvbnRleHQz RDo6Tk9fRVJST1IpIHsKICAgICAgICAgICAgIC8vIFdlIHdlcmUgdW5hYmxlIHRvIGNyZWF0ZSBh IGJ1ZmZlci4KICAgICAgICAgICAgIG1fdmVydGV4QXR0cmliMFVzZWRCZWZvcmUgPSBmYWxzZTsK ICAgICAgICAgICAgIHJldHVybiBzdGQ6Om51bGxvcHQ7CiAgICAgICAgIH0KLSAgICAgICAgbV92 ZXJ0ZXhBdHRyaWIwQnVmZmVyU2l6ZSA9IGJ1ZmZlckRhdGFTaXplLnVuc2FmZUdldCgpOworICAg ICAgICBtX3ZlcnRleEF0dHJpYjBCdWZmZXJTaXplID0gYnVmZmVyRGF0YVNpemU7CiAgICAgICAg IG1fZm9yY2VBdHRyaWIwQnVmZmVyUmVmaWxsID0gdHJ1ZTsKICAgICB9CiAKQEAgLTU3NjgsNyAr NTc3Myw3IEBAIHN0ZDo6b3B0aW9uYWw8Ym9vbD4gV2ViR0xSZW5kZXJpbmdDb250ZXh0QmFzZTo6 c2ltdWxhdGVWZXJ0ZXhBdHRyaWIwKEdDM0R1aW50IG51CiAgICAgICAgICAgICB8fCBhdHRyaWJW YWx1ZS52YWx1ZVsyXSAhPSBtX3ZlcnRleEF0dHJpYjBCdWZmZXJWYWx1ZVsyXQogICAgICAgICAg ICAgfHwgYXR0cmliVmFsdWUudmFsdWVbM10gIT0gbV92ZXJ0ZXhBdHRyaWIwQnVmZmVyVmFsdWVb M10pKSB7CiAKLSAgICAgICAgYXV0byBidWZmZXJEYXRhID0gc3RkOjptYWtlX3VuaXF1ZTxHQzNE ZmxvYXRbXT4oYnVmZmVyU2l6ZS51bnNhZmVHZXQoKSk7CisgICAgICAgIGF1dG8gYnVmZmVyRGF0 YSA9IHN0ZDo6bWFrZV91bmlxdWU8R0MzRGZsb2F0W10+KGJ1ZmZlclNpemUpOwogICAgICAgICBm b3IgKEdDM0R1aW50IGlpID0gMDsgaWkgPCBudW1WZXJ0ZXggKyAxOyArK2lpKSB7CiAgICAgICAg ICAgICBidWZmZXJEYXRhW2lpICogNF0gPSBhdHRyaWJWYWx1ZS52YWx1ZVswXTsKICAgICAgICAg ICAgIGJ1ZmZlckRhdGFbaWkgKiA0ICsgMV0gPSBhdHRyaWJWYWx1ZS52YWx1ZVsxXTsKQEAgLTU3 ODAsNyArNTc4NSw3IEBAIHN0ZDo6b3B0aW9uYWw8Ym9vbD4gV2ViR0xSZW5kZXJpbmdDb250ZXh0 QmFzZTo6c2ltdWxhdGVWZXJ0ZXhBdHRyaWIwKEdDM0R1aW50IG51CiAgICAgICAgIG1fdmVydGV4 QXR0cmliMEJ1ZmZlclZhbHVlWzJdID0gYXR0cmliVmFsdWUudmFsdWVbMl07CiAgICAgICAgIG1f dmVydGV4QXR0cmliMEJ1ZmZlclZhbHVlWzNdID0gYXR0cmliVmFsdWUudmFsdWVbM107CiAgICAg ICAgIG1fZm9yY2VBdHRyaWIwQnVmZmVyUmVmaWxsID0gZmFsc2U7Ci0gICAgICAgIG1fY29udGV4 dC0+YnVmZmVyU3ViRGF0YShHcmFwaGljc0NvbnRleHQzRDo6QVJSQVlfQlVGRkVSLCAwLCBidWZm ZXJEYXRhU2l6ZS51bnNhZmVHZXQoKSwgYnVmZmVyRGF0YS5nZXQoKSk7CisgICAgICAgIG1fY29u dGV4dC0+YnVmZmVyU3ViRGF0YShHcmFwaGljc0NvbnRleHQzRDo6QVJSQVlfQlVGRkVSLCAwLCBi dWZmZXJEYXRhU2l6ZSwgYnVmZmVyRGF0YS5nZXQoKSk7CiAgICAgfQogICAgIG1fY29udGV4dC0+ dmVydGV4QXR0cmliUG9pbnRlcigwLCA0LCBHcmFwaGljc0NvbnRleHQzRDo6RkxPQVQsIDAsIDAs IDApOwogICAgIHJldHVybiB0cnVlOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9j YW52YXMvV2ViR0xSZW5kZXJpbmdDb250ZXh0QmFzZS5oIGIvU291cmNlL1dlYkNvcmUvaHRtbC9j YW52YXMvV2ViR0xSZW5kZXJpbmdDb250ZXh0QmFzZS5oCmluZGV4IDFlYmRkYmFhOTRjYmNlNjY2 MWU0NmQ2ZTUxMGFkNmJlOTU0MjE1NmIuLmFkM2I0MGFmZjk4ZjJmMTg0MjVjMTcxZjUwNWIyNWM2 Mzc4YTZmNGUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvY2FudmFzL1dlYkdMUmVu ZGVyaW5nQ29udGV4dEJhc2UuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL2NhbnZhcy9XZWJH TFJlbmRlcmluZ0NvbnRleHRCYXNlLmgKQEAgLTgyOSw2ICs4MjksOCBAQCBwcm90ZWN0ZWQ6CiAg ICAgSFRNTENhbnZhc0VsZW1lbnQqIGh0bWxDYW52YXMoKTsKICAgICBPZmZzY3JlZW5DYW52YXMq IG9mZnNjcmVlbkNhbnZhcygpOwogCisgICAgdGVtcGxhdGUgPHR5cGVuYW1lIFQ+IHN0YXRpYyBz dGQ6Om9wdGlvbmFsPFQ+IGNoZWNrZWRBZGRBbmRNdWx0aXBseShUIHZhbHVlLCBUIGFkZCwgVCBt dWx0aXBseSk7CisKIHByaXZhdGU6CiAgICAgYm9vbCB2YWxpZGF0ZUFycmF5QnVmZmVyVHlwZShj b25zdCBjaGFyKiBmdW5jdGlvbk5hbWUsIEdDM0RlbnVtIHR5cGUsIHN0ZDo6b3B0aW9uYWw8SlND OjpUeXBlZEFycmF5VHlwZT4pOwogICAgIHZvaWQgcmVnaXN0ZXJXaXRoV2ViR0xTdGF0ZVRyYWNr ZXIoKTsK