163748 2016-10-20 12:24:56 -0700 [JSC] crash via `new Function("}{")` 2016-10-21 10:52:20 -0700 1 1 1 Unclassified WebKit JavaScriptCore Other Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 caitp caitp andre.bargull bfulgham commit-queue darin keith_miller mark.lam mcatanzaro msaboff saam webkit-bug-importer oldest_to_newest 1242523 0 caitp 2016-10-20 12:24:56 -0700 Currently, the FunctionConstructor generates a source string in the form: "{function anonymous() { <source body parameter> } }", which eventually reaches getFunctionExecutableFromGlobalCode(). getFunctionExecutableFromGlobalCode() asserts that the resulting AST contains a Block with a single statement (a function declaration). However, it is possible to fail this assertion and crash the browser tab. There is no real guarantee that the source code will produce the expected AST, and it shouldn't fire assertions about the structure of the AST. 1242527 1 caitp 2016-10-20 12:37:34 -0700 /CC some folks who might be interested in a fix for that (feel free to mark as a sec critical bug if needed --- I don't tend to consider assertion failures to be exploitable, so I felt there was no need). 1242615 2 mcatanzaro 2016-10-20 15:25:37 -0700 Looks like denial of service to me. 1242616 3 webkit-bug-importer 2016-10-20 15:26:00 -0700 <rdar://problem/28879157> 1242692 4 darin 2016-10-20 17:47:35 -0700 If you are saying that every crash that a webpage can trigger in WebKit is a security bug because they are all "denial of service", then I think that’s wrong. 1242720 5 mcatanzaro 2016-10-20 18:26:02 -0700 (In reply to comment #4) > If you are saying that every crash that a webpage can trigger in WebKit is a > security bug because they are all "denial of service", then I think that’s > wrong. OK, I don't know what your policies are for such issues. 1242724 6 darin 2016-10-20 18:31:10 -0700 It’s not so much policy but simply a practical consideration. There are *lots* of crashing bugs and I don’t think we treat them all as sensitive security bugs. I believe we try to distinguish exploitable crashes from ones that are simply an inconvenience. 1242773 7 bfulgham 2016-10-20 22:32:12 -0700 (In reply to comment #6) > It’s not so much policy but simply a practical consideration. There are > *lots* of crashing bugs and I don’t think we treat them all as sensitive > security bugs. I believe we try to distinguish exploitable crashes from ones > that are simply an inconvenience. Exactly. We try to handle bugs that we judge to allow true "exploits" under our more severe 'Security' classification. While crashes and "eat CPU spinning in a loop" bugs are super annoying, and are things we want to mitigate where possible, they don't rise to quite the same level for our purposes. 1242847 8 andre.bargull 2016-10-21 04:56:27 -0700 Another bug report for this issue (bug 106160) is publicly visible for more than three years, so there's probably no reason to hide this report. 1242849 9 mcatanzaro 2016-10-21 05:13:47 -0700 OK, it looks like a duplicate and there's more discussion there. *** This bug has been marked as a duplicate of bug 106160 *** 1242861 10 caitp 2016-10-21 06:42:10 -0700 Reopening to attach new patch. 1242862 11 292345 caitp 2016-10-21 06:42:13 -0700 Created attachment 292345 Patch 1242921 12 292345 mark.lam 2016-10-21 09:39:26 -0700 Comment on attachment 292345 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=292345&action=review Can you also add regression test(s) (in JSTests/stress) for these changes? > Source/JavaScriptCore/runtime/CodeCache.cpp:189 > + if (!statement) { > + statement = program->firstStatement(); > + isError = true; > + } It looks like what you're doing here is just stuffing "statement" with a value that will pass the assertions below. Is that right? Why not do the equivalent of your isError check here and just return early? I think it is misleading to stuff "statement" with another statement that doesn't meet the singleStatement requirement. Am I mistaken? > Source/JavaScriptCore/runtime/CodeCache.cpp:200 > + if (!funcDecl) { > + funcDecl = static_cast<BlockNode*>(statement)->firstStatement(); > + isError = true; > + } Ditto. Why not return early here? 1242923 13 292345 caitp 2016-10-21 09:42:15 -0700 Comment on attachment 292345 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=292345&action=review >> Source/JavaScriptCore/runtime/CodeCache.cpp:189 >> + } > > It looks like what you're doing here is just stuffing "statement" with a value that will pass the assertions below. Is that right? Why not do the equivalent of your isError check here and just return early? I think it is misleading to stuff "statement" with another statement that doesn't meet the singleStatement requirement. Am I mistaken? I wanted to share the error reporting code, but yes, I've considered this and it is simpler, so I'll do that instead. 1242936 14 292360 caitp 2016-10-21 09:58:59 -0700 Created attachment 292360 Patch 1242940 15 292360 mark.lam 2016-10-21 10:04:04 -0700 Comment on attachment 292360 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=292360&action=review Please fix the outstanding issue with the !statement->isBlock() check. Thanks. > Source/JavaScriptCore/runtime/CodeCache.cpp:185 > + if (!statement) { nit: You can make this: if (UNLIKELY(!statement)) { > Source/JavaScriptCore/runtime/CodeCache.cpp:190 > ASSERT(statement); You can remove this assert since it can never happen thanks to the new if statement above. > Source/JavaScriptCore/runtime/CodeCache.cpp:-188 > - if (!statement || !statement->isBlock()) > - return nullptr; Is it true that we don't need the !statement->isBlock() check anymore? You need to either: 1. reinstate the !statement->isBlock() check, or 2. add the check to your if (!statement) check above, and remove the ASSERT(statement->isBlock()); > Source/JavaScriptCore/runtime/CodeCache.cpp:194 > + if (!funcDecl) { nit: use UNLIKELY(). > Source/JavaScriptCore/runtime/CodeCache.cpp:199 > ASSERT(funcDecl); Ditto. Remove because this is not needed anymore. > Source/JavaScriptCore/runtime/CodeCache.cpp:-194 > - if (!funcDecl || !funcDecl->isFuncDeclNode()) > - return nullptr; Ditto. 1242943 16 292362 caitp 2016-10-21 10:07:34 -0700 Created attachment 292362 Remove redundant ASSERT()s and add branch prediction hints 1242944 17 292360 caitp 2016-10-21 10:10:54 -0700 Comment on attachment 292360 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=292360&action=review >> Source/JavaScriptCore/runtime/CodeCache.cpp:-188 >> - return nullptr; > > Is it true that we don't need the !statement->isBlock() check anymore? You need to either: > 1. reinstate the !statement->isBlock() check, or > 2. add the check to your if (!statement) check above, and remove the ASSERT(statement->isBlock()); I believe it's impossible for the first statement in the program to be anything BUT a Block, so long as the source string is formatted the way it is in FunctionConstructor (which appears to be the only caller of this). Similarly, I believe it's impossible for the funcDecl to be anything BUT a function declaration, for the same reaason. If it's the only statement, it must be a funcDecl, unless the FunctionConstructor is doing something wrong (in which case, the ASSERT is helpful). 1242947 18 292362 mark.lam 2016-10-21 10:13:08 -0700 Comment on attachment 292362 Remove redundant ASSERT()s and add branch prediction hints r=me. Please add your explanation for why it's safe to remove the !statement->isBlock() and !funcDecl->isFuncDeclNode() to the ChangeLog. Thanks. 1242951 19 292362 caitp 2016-10-21 10:20:00 -0700 Comment on attachment 292362 Remove redundant ASSERT()s and add branch prediction hints >Subversion Revision: 207677 >diff --git a/Source/JavaScriptCore/ChangeLog b/Source/JavaScriptCore/ChangeLog >index 4c1164f4416dea3ba1c4d3e701f51d4ed15e98b1..e38b1d64a256cec38271eafc92e1da89ec92d434 100644 >--- a/Source/JavaScriptCore/ChangeLog >+++ b/Source/JavaScriptCore/ChangeLog >@@ -1,3 +1,13 @@ >+2016-10-21 Caitlin Potter <caitp@igalia.com> >+ >+ [JSC] don't crash when arguments to `new Function()` produce unexpected AST >+ https://bugs.webkit.org/show_bug.cgi?id=163748 >+ >+ Reviewed by NOBODY (OOPS!). >+ >+ The ASSERT(statement); and ASSERT(funcDecl); lines are removed, replaced with blocks >+ to report a generic Parser error message. These lines are only possible to be reached >+ if the input string produced an unexpected AST, which previously could be used to crash >+ the process via ASSERT failure. >+ >+ The node type assertions are left in the tree, as it should be impossible for a top-level >+ `{` to produce anything other than a Block node. If the node turns out not to be a Block, >+ it indicates that the (C++) caller of this function (E.g in FunctionConstructor.cpp), is >+ doing something incorrect. Similarly, it should be impossible for the `funcDecl` node to >+ be anything other than a function declaration given the conventions of the caller of this >+ function. >+ >+ * runtime/CodeCache.cpp: >+ (JSC::CodeCache::getFunctionExecutableFromGlobalCode): >+ > 2016-10-20 Keith Miller <keith_miller@apple.com> > > Add support for WASM calls >diff --git a/Source/JavaScriptCore/runtime/CodeCache.cpp b/Source/JavaScriptCore/runtime/CodeCache.cpp >index 73efab1684b026308c160544c0be116496561f75..cc7a7f8dd1e6f1f0fe102a010a0bf80a9cc38910 100644 >--- a/Source/JavaScriptCore/runtime/CodeCache.cpp >+++ b/Source/JavaScriptCore/runtime/CodeCache.cpp >@@ -182,16 +182,20 @@ UnlinkedFunctionExecutable* CodeCache::getFunctionExecutableFromGlobalCode(VM& v > > // This function assumes an input string that would result in a single function declaration. > StatementNode* statement = program->singleStatement(); >- ASSERT(statement); >- ASSERT(statement->isBlock()); >- if (!statement || !statement->isBlock()) >+ if (UNLIKELY(!statement)) { >+ JSToken token; >+ error = ParserError(ParserError::SyntaxError, ParserError::SyntaxErrorIrrecoverable, token, "Parser error", -1); > return nullptr; >+ } >+ ASSERT(statement->isBlock()); > > StatementNode* funcDecl = static_cast<BlockNode*>(statement)->singleStatement(); >- ASSERT(funcDecl); >- ASSERT(funcDecl->isFuncDeclNode()); >- if (!funcDecl || !funcDecl->isFuncDeclNode()) >+ if (UNLIKELY(!funcDecl)) { >+ JSToken token; >+ error = ParserError(ParserError::SyntaxError, ParserError::SyntaxErrorIrrecoverable, token, "Parser error", -1); > return nullptr; >+ } >+ ASSERT(funcDecl->isFuncDeclNode()); > > FunctionMetadataNode* metadata = static_cast<FuncDeclNode*>(funcDecl)->metadata(); > ASSERT(metadata); >diff --git a/JSTests/ChangeLog b/JSTests/ChangeLog >index ed1fbb8265cc3cca386c2d6000c116af3535f113..3c21fe8c9b4feca33a5d47e1b54d4a9cb3fcbda2 100644 >--- a/JSTests/ChangeLog >+++ b/JSTests/ChangeLog >@@ -1,3 +1,15 @@ >+2016-10-21 Caitlin Potter <caitp@igalia.com> >+ >+ [JSC] don't crash when arguments to `new Function()` produce unexpected AST >+ https://bugs.webkit.org/show_bug.cgi?id=163748 >+ >+ Reviewed by NOBODY (OOPS!). >+ >+ * stress/regress-163748.js: Added. >+ (assert): >+ (shouldThrowSyntaxError): >+ (GeneratorFunction): >+ > 2016-10-20 Keith Miller <keith_miller@apple.com> > > Add support for WASM calls >diff --git a/JSTests/stress/regress-163748.js b/JSTests/stress/regress-163748.js >new file mode 100644 >index 0000000000000000000000000000000000000000..807798af81e7ef1d92ba4f99ce6bb48d292d9d06 >--- /dev/null >+++ b/JSTests/stress/regress-163748.js >@@ -0,0 +1,24 @@ >+function assert(cond, msg = "") { >+ if (!cond) >+ throw new Error(msg); >+} >+noInline(assert); >+ >+function shouldThrowSyntaxError(str) { >+ var hadError = false; >+ try { >+ eval(str); >+ } catch (e) { >+ if (e instanceof SyntaxError) >+ hadError = true; >+ } >+ assert(hadError, "Did not throw syntax error"); >+} >+noInline(shouldThrowSyntaxError); >+ >+shouldThrowSyntaxError("var f = new Function('}{')"); >+shouldThrowSyntaxError("var f = new Function('}}{{')"); >+ >+var GeneratorFunction = function*(){}.constructor; >+shouldThrowSyntaxError("var f = new GeneratorFunction('}{')"); >+shouldThrowSyntaxError("var f = new GeneratorFunction('}}{{')"); 1242958 20 292362 caitp 2016-10-21 10:25:15 -0700 Comment on attachment 292362 Remove redundant ASSERT()s and add branch prediction hints Er, "edit attachment as comment" didn't do what I expected it to do, I don't think. It was worth a try, anyways. 1242961 21 292366 caitp 2016-10-21 10:27:17 -0700 Created attachment 292366 fix the changelog 1242986 22 292366 commit-queue 2016-10-21 10:52:15 -0700 Comment on attachment 292366 fix the changelog Clearing flags on attachment: 292366 Committed r207684: <http://trac.webkit.org/changeset/207684> 1242987 23 commit-queue 2016-10-21 10:52:20 -0700 All reviewed patches have been landed. Closing bug. 292345 2016-10-21 06:42:13 -0700 2016-10-21 09:58:55 -0700 Patch bug-163748-20161021093834.patch text/plain 5556 caitp U3VidmVyc2lvbiBSZXZpc2lvbjogMjA3NjQzCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCBh NTQxYWRjZGIyNzEyNTNlZmZlZWRlN2I0OTJjNjExYWQ5NDE3OWMzLi45MTM1MTQ2ODJiOWFlOTdi ZDhmNTI5NWM3MGUzNjc0NDhlYTVhMzA1IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwxOCBAQAorMjAxNi0xMC0yMSAgQ2FpdGxpbiBQb3R0ZXIgIDxjYWl0cEBpZ2FsaWEuY29t PgorCisgICAgICAgIFtKU0NdIGRvbid0IGNyYXNoIHdoZW4gYXJndW1lbnRzIHRvIGBuZXcgRnVu Y3Rpb24oKWAgcHJvZHVjZSB1bmV4cGVjdGVkIEFTVAorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTYzNzQ4CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9C T0RZIChPT1BTISkuCisKKyAgICAgICAgKiBwYXJzZXIvTm9kZXMuY3BwOgorICAgICAgICAoSlND OjpTb3VyY2VFbGVtZW50czo6Zmlyc3RTdGF0ZW1lbnQpOgorICAgICAgICAoSlNDOjpCbG9ja05v ZGU6OmZpcnN0U3RhdGVtZW50KToKKyAgICAgICAgKEpTQzo6U2NvcGVOb2RlOjpmaXJzdFN0YXRl bWVudCk6CisgICAgICAgICogcGFyc2VyL05vZGVzLmg6CisgICAgICAgICogcnVudGltZS9Db2Rl Q2FjaGUuY3BwOgorICAgICAgICAoSlNDOjpDb2RlQ2FjaGU6OmdldEZ1bmN0aW9uRXhlY3V0YWJs ZUZyb21HbG9iYWxDb2RlKToKKwogMjAxNi0xMC0xOSAgTXlsZXMgQy4gTWF4ZmllbGQgIDxtbWF4 ZmllbGRAYXBwbGUuY29tPgogCiAgICAgICAgIFttYWNPU10gW2lPU10gRGlzYWJsZSB2YXJpYXRp b24gZm9udHMgb24gbWFjT1MgRWwgQ2FwaXRhbiBhbmQgaU9TIDkKZGlmZiAtLWdpdCBhL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS9wYXJzZXIvTm9kZXMuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3Jl L3BhcnNlci9Ob2Rlcy5jcHAKaW5kZXggODBjNjU3ZWM1Yjg3YjM5YzViMDQ0YzVjOWViNGNjZWZm ZWRlNzhiNi4uYmE1ZDQ1MDE4OTc4ZGYzMWU0NmU3NmQ1MmQ0NzVhZGM2ZTAwY2E0ZCAxMDA2NDQK LS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3BhcnNlci9Ob2Rlcy5jcHAKKysrIGIvU291cmNl L0phdmFTY3JpcHRDb3JlL3BhcnNlci9Ob2Rlcy5jcHAKQEAgLTY1LDYgKzY1LDE4IEBAIFN0YXRl bWVudE5vZGUqIFNvdXJjZUVsZW1lbnRzOjpzaW5nbGVTdGF0ZW1lbnQoKSBjb25zdAogICAgIHJl dHVybiBtX2hlYWQgPT0gbV90YWlsID8gbV9oZWFkIDogbnVsbHB0cjsKIH0KIAorU3RhdGVtZW50 Tm9kZSogU291cmNlRWxlbWVudHM6OmZpcnN0U3RhdGVtZW50KCkgY29uc3QKK3sKKyAgICByZXR1 cm4gbV9oZWFkOworfQorCisvLyAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gQmxvY2tO b2RlIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisKK1N0YXRlbWVudE5vZGUqIEJsb2Nr Tm9kZTo6Zmlyc3RTdGF0ZW1lbnQoKSBjb25zdAoreworICAgIHJldHVybiBtX3N0YXRlbWVudHMg PyBtX3N0YXRlbWVudHMtPmZpcnN0U3RhdGVtZW50KCkgOiAwOworfQorCiAvLyAtLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0gU2NvcGVOb2RlIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tCiAKIFNjb3BlTm9kZTo6U2NvcGVOb2RlKFBhcnNlckFyZW5hJiBwYXJzZXJBcmVuYSwgY29u c3QgSlNUb2tlbkxvY2F0aW9uJiBzdGFydExvY2F0aW9uLCBjb25zdCBKU1Rva2VuTG9jYXRpb24m IGVuZExvY2F0aW9uLCBib29sIGluU3RyaWN0Q29udGV4dCkKQEAgLTEwMiw2ICsxMTQsMTEgQEAg U3RhdGVtZW50Tm9kZSogU2NvcGVOb2RlOjpzaW5nbGVTdGF0ZW1lbnQoKSBjb25zdAogICAgIHJl dHVybiBtX3N0YXRlbWVudHMgPyBtX3N0YXRlbWVudHMtPnNpbmdsZVN0YXRlbWVudCgpIDogMDsK IH0KIAorU3RhdGVtZW50Tm9kZSogU2NvcGVOb2RlOjpmaXJzdFN0YXRlbWVudCgpIGNvbnN0Cit7 CisgICAgcmV0dXJuIG1fc3RhdGVtZW50cyA/IG1fc3RhdGVtZW50cy0+Zmlyc3RTdGF0ZW1lbnQo KSA6IDA7Cit9CisKIC8vIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSBQcm9ncmFtTm9k ZSAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogCiBQcm9ncmFtTm9kZTo6UHJvZ3JhbU5v ZGUoUGFyc2VyQXJlbmEmIHBhcnNlckFyZW5hLCBjb25zdCBKU1Rva2VuTG9jYXRpb24mIHN0YXJ0 TG9jYXRpb24sIGNvbnN0IEpTVG9rZW5Mb2NhdGlvbiYgZW5kTG9jYXRpb24sIHVuc2lnbmVkIHN0 YXJ0Q29sdW1uLCB1bnNpZ25lZCBlbmRDb2x1bW4sIFNvdXJjZUVsZW1lbnRzKiBjaGlsZHJlbiwg VmFyaWFibGVFbnZpcm9ubWVudCYgdmFyRW52aXJvbm1lbnQsIEZ1bmN0aW9uU3RhY2smJiBmdW5j U3RhY2ssIFZhcmlhYmxlRW52aXJvbm1lbnQmIGxleGljYWxWYXJpYWJsZXMsIFVuaXF1ZWRTdHJp bmdJbXBsUHRyU2V0JiYgc2xvcHB5TW9kZUhvaXN0ZWRGdW5jdGlvbnMsIEZ1bmN0aW9uUGFyYW1l dGVycyosIGNvbnN0IFNvdXJjZUNvZGUmIHNvdXJjZSwgQ29kZUZlYXR1cmVzIGZlYXR1cmVzLCBJ bm5lckFycm93RnVuY3Rpb25Db2RlRmVhdHVyZXMgaW5uZXJBcnJvd0Z1bmN0aW9uQ29kZUZlYXR1 cmVzLCBpbnQgbnVtQ29uc3RhbnRzLCBSZWZQdHI8TW9kdWxlU2NvcGVEYXRhPiYmKQpkaWZmIC0t Z2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3BhcnNlci9Ob2Rlcy5oIGIvU291cmNlL0phdmFT Y3JpcHRDb3JlL3BhcnNlci9Ob2Rlcy5oCmluZGV4IGZiNDUzZTgyZWZkYjdjNmUxYWMwZTBhMTQz ODYzYjJmYjA2YjU3NTAuLjhlNmE5Mjc1MWIzOGM1ZmQ0NTE5YzYwMThiODA4OTlkMWYzNWYwNWYg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9wYXJzZXIvTm9kZXMuaAorKysgYi9T b3VyY2UvSmF2YVNjcmlwdENvcmUvcGFyc2VyL05vZGVzLmgKQEAgLTEzMjMsNiArMTMyMyw3IEBA IG5hbWVzcGFjZSBKU0MgewogICAgICAgICB2b2lkIGFwcGVuZChTdGF0ZW1lbnROb2RlKik7CiAK ICAgICAgICAgU3RhdGVtZW50Tm9kZSogc2luZ2xlU3RhdGVtZW50KCkgY29uc3Q7CisgICAgICAg IFN0YXRlbWVudE5vZGUqIGZpcnN0U3RhdGVtZW50KCkgY29uc3Q7CiAgICAgICAgIFN0YXRlbWVu dE5vZGUqIGxhc3RTdGF0ZW1lbnQoKSBjb25zdDsKIAogICAgICAgICB2b2lkIGVtaXRCeXRlY29k ZShCeXRlY29kZUdlbmVyYXRvciYsIFJlZ2lzdGVySUQqIGRlc3RpbmF0aW9uKTsKQEAgLTEzNDAs NiArMTM0MSw3IEBAIG5hbWVzcGFjZSBKU0MgewogICAgICAgICBCbG9ja05vZGUoY29uc3QgSlNU b2tlbkxvY2F0aW9uJiwgU291cmNlRWxlbWVudHMqLCBWYXJpYWJsZUVudmlyb25tZW50JiwgRnVu Y3Rpb25TdGFjayYmKTsKIAogICAgICAgICBTdGF0ZW1lbnROb2RlKiBzaW5nbGVTdGF0ZW1lbnQo KSBjb25zdDsKKyAgICAgICAgU3RhdGVtZW50Tm9kZSogZmlyc3RTdGF0ZW1lbnQoKSBjb25zdDsK ICAgICAgICAgU3RhdGVtZW50Tm9kZSogbGFzdFN0YXRlbWVudCgpIGNvbnN0OwogCiAgICAgcHJp dmF0ZToKQEAgLTE2NDIsNiArMTY0NCw3IEBAIG5hbWVzcGFjZSBKU0MgewogICAgICAgICB9CiAK ICAgICAgICAgU3RhdGVtZW50Tm9kZSogc2luZ2xlU3RhdGVtZW50KCkgY29uc3Q7CisgICAgICAg IFN0YXRlbWVudE5vZGUqIGZpcnN0U3RhdGVtZW50KCkgY29uc3Q7CiAKICAgICAgICAgdm9pZCBl bWl0U3RhdGVtZW50c0J5dGVjb2RlKEJ5dGVjb2RlR2VuZXJhdG9yJiwgUmVnaXN0ZXJJRCogZGVz dGluYXRpb24pOwogICAgICAgICAKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9y dW50aW1lL0NvZGVDYWNoZS5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9Db2Rl Q2FjaGUuY3BwCmluZGV4IDczZWZhYjE2ODRiMDI2MzA4YzE2MDU0NGMwYmUxMTY0OTY1NjFmNzUu LmMzMTFjZmJhMGFjODRhNjk3ZDYyOTJiMzc5ZjQ2NDQ5MGY1Mzc1ZDMgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0NvZGVDYWNoZS5jcHAKKysrIGIvU291cmNlL0ph dmFTY3JpcHRDb3JlL3J1bnRpbWUvQ29kZUNhY2hlLmNwcApAQCAtMTgxLDE4ICsxODEsMzcgQEAg VW5saW5rZWRGdW5jdGlvbkV4ZWN1dGFibGUqIENvZGVDYWNoZTo6Z2V0RnVuY3Rpb25FeGVjdXRh YmxlRnJvbUdsb2JhbENvZGUoVk0mIHYKICAgICB9CiAKICAgICAvLyBUaGlzIGZ1bmN0aW9uIGFz c3VtZXMgYW4gaW5wdXQgc3RyaW5nIHRoYXQgd291bGQgcmVzdWx0IGluIGEgc2luZ2xlIGZ1bmN0 aW9uIGRlY2xhcmF0aW9uLgorICAgIGJvb2wgaXNFcnJvciA9IGZhbHNlOwogICAgIFN0YXRlbWVu dE5vZGUqIHN0YXRlbWVudCA9IHByb2dyYW0tPnNpbmdsZVN0YXRlbWVudCgpOworICAgIGlmICgh c3RhdGVtZW50KSB7CisgICAgICAgIHN0YXRlbWVudCA9IHByb2dyYW0tPmZpcnN0U3RhdGVtZW50 KCk7CisgICAgICAgIGlzRXJyb3IgPSB0cnVlOworICAgIH0KKwogICAgIEFTU0VSVChzdGF0ZW1l bnQpOwogICAgIEFTU0VSVChzdGF0ZW1lbnQtPmlzQmxvY2soKSk7CiAgICAgaWYgKCFzdGF0ZW1l bnQgfHwgIXN0YXRlbWVudC0+aXNCbG9jaygpKQogICAgICAgICByZXR1cm4gbnVsbHB0cjsKIAog ICAgIFN0YXRlbWVudE5vZGUqIGZ1bmNEZWNsID0gc3RhdGljX2Nhc3Q8QmxvY2tOb2RlKj4oc3Rh dGVtZW50KS0+c2luZ2xlU3RhdGVtZW50KCk7CisgICAgaWYgKCFmdW5jRGVjbCkgeworICAgICAg ICBmdW5jRGVjbCA9IHN0YXRpY19jYXN0PEJsb2NrTm9kZSo+KHN0YXRlbWVudCktPmZpcnN0U3Rh dGVtZW50KCk7CisgICAgICAgIGlzRXJyb3IgPSB0cnVlOworICAgIH0KKwogICAgIEFTU0VSVChm dW5jRGVjbCk7CiAgICAgQVNTRVJUKGZ1bmNEZWNsLT5pc0Z1bmNEZWNsTm9kZSgpKTsKICAgICBp ZiAoIWZ1bmNEZWNsIHx8ICFmdW5jRGVjbC0+aXNGdW5jRGVjbE5vZGUoKSkKICAgICAgICAgcmV0 dXJuIG51bGxwdHI7CiAKKyAgICBpZiAoaXNFcnJvcikgeworICAgICAgICAvLyBVc2VyLXByb3Zp ZGVkIERhdGEgZG9lcyBub3QgcHJvZHVjZSB0aGUgZXhwZWN0ZWQgQVNULiBSYXRoZXIgdGhhbiBy ZS1wYXJzaW5nIHRoZSBTb3VyY2VFbGVtZW50cyBvZiB0aGUgYm9keSwKKyAgICAgICAgLy8gaW50 cm9kdWNpbmcgdW5kdWUgY29tcGxleGl0eSwgc2ltcGx5IHJlcG9ydCB0aGUgU3ludGF4RXJyb3Iu CisgICAgICAgIEpTVG9rZW4gdG9rZW47CisgICAgICAgIGVycm9yID0gUGFyc2VyRXJyb3IoUGFy c2VyRXJyb3I6OlN5bnRheEVycm9yLCBQYXJzZXJFcnJvcjo6U3ludGF4RXJyb3JJcnJlY292ZXJh YmxlLCB0b2tlbiwgIlBhcnNlciBlcnJvciIsIC0xKTsKKyAgICAgICAgcmV0dXJuIG51bGxwdHI7 CisgICAgfQorCiAgICAgRnVuY3Rpb25NZXRhZGF0YU5vZGUqIG1ldGFkYXRhID0gc3RhdGljX2Nh c3Q8RnVuY0RlY2xOb2RlKj4oZnVuY0RlY2wpLT5tZXRhZGF0YSgpOwogICAgIEFTU0VSVChtZXRh ZGF0YSk7CiAgICAgaWYgKCFtZXRhZGF0YSkK 292360 2016-10-21 09:58:59 -0700 2016-10-21 10:07:28 -0700 Patch bug-163748-20161021125520.patch text/plain 3765 caitp U3VidmVyc2lvbiBSZXZpc2lvbjogMjA3Njc3CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCA0 YzExNjRmNDQxNmRlYTNiYTFjNGQzZTcwMWY1MWQ0ZWQxNWU5OGIxLi5lMzhiMWQ2NGEyNTZjZWMz ODI3MWVhZmM5MmUxZGE4OWVjOTJkNDM0IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwxMyBAQAorMjAxNi0xMC0yMSAgQ2FpdGxpbiBQb3R0ZXIgIDxjYWl0cEBpZ2FsaWEuY29t PgorCisgICAgICAgIFtKU0NdIGRvbid0IGNyYXNoIHdoZW4gYXJndW1lbnRzIHRvIGBuZXcgRnVu Y3Rpb24oKWAgcHJvZHVjZSB1bmV4cGVjdGVkIEFTVAorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTYzNzQ4CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9C T0RZIChPT1BTISkuCisKKyAgICAgICAgKiBydW50aW1lL0NvZGVDYWNoZS5jcHA6CisgICAgICAg IChKU0M6OkNvZGVDYWNoZTo6Z2V0RnVuY3Rpb25FeGVjdXRhYmxlRnJvbUdsb2JhbENvZGUpOgor CiAyMDE2LTEwLTIwICBLZWl0aCBNaWxsZXIgIDxrZWl0aF9taWxsZXJAYXBwbGUuY29tPgogCiAg ICAgICAgIEFkZCBzdXBwb3J0IGZvciBXQVNNIGNhbGxzCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvcnVudGltZS9Db2RlQ2FjaGUuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3Jl L3J1bnRpbWUvQ29kZUNhY2hlLmNwcAppbmRleCA3M2VmYWIxNjg0YjAyNjMwOGMxNjA1NDRjMGJl MTE2NDk2NTYxZjc1Li5mODFkZDJmNTgwMTc1YWRjMGIzNGMyYzQ0N2Q4NzY1YjU2OWZiOTRiIDEw MDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9Db2RlQ2FjaGUuY3BwCisr KyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0NvZGVDYWNoZS5jcHAKQEAgLTE4Miwx NiArMTgyLDIyIEBAIFVubGlua2VkRnVuY3Rpb25FeGVjdXRhYmxlKiBDb2RlQ2FjaGU6OmdldEZ1 bmN0aW9uRXhlY3V0YWJsZUZyb21HbG9iYWxDb2RlKFZNJiB2CiAKICAgICAvLyBUaGlzIGZ1bmN0 aW9uIGFzc3VtZXMgYW4gaW5wdXQgc3RyaW5nIHRoYXQgd291bGQgcmVzdWx0IGluIGEgc2luZ2xl IGZ1bmN0aW9uIGRlY2xhcmF0aW9uLgogICAgIFN0YXRlbWVudE5vZGUqIHN0YXRlbWVudCA9IHBy b2dyYW0tPnNpbmdsZVN0YXRlbWVudCgpOworICAgIGlmICghc3RhdGVtZW50KSB7CisgICAgICAg IEpTVG9rZW4gdG9rZW47CisgICAgICAgIGVycm9yID0gUGFyc2VyRXJyb3IoUGFyc2VyRXJyb3I6 OlN5bnRheEVycm9yLCBQYXJzZXJFcnJvcjo6U3ludGF4RXJyb3JJcnJlY292ZXJhYmxlLCB0b2tl biwgIlBhcnNlciBlcnJvciIsIC0xKTsKKyAgICAgICAgcmV0dXJuIG51bGxwdHI7CisgICAgfQog ICAgIEFTU0VSVChzdGF0ZW1lbnQpOwogICAgIEFTU0VSVChzdGF0ZW1lbnQtPmlzQmxvY2soKSk7 Ci0gICAgaWYgKCFzdGF0ZW1lbnQgfHwgIXN0YXRlbWVudC0+aXNCbG9jaygpKQotICAgICAgICBy ZXR1cm4gbnVsbHB0cjsKIAogICAgIFN0YXRlbWVudE5vZGUqIGZ1bmNEZWNsID0gc3RhdGljX2Nh c3Q8QmxvY2tOb2RlKj4oc3RhdGVtZW50KS0+c2luZ2xlU3RhdGVtZW50KCk7CisgICAgaWYgKCFm dW5jRGVjbCkgeworICAgICAgICBKU1Rva2VuIHRva2VuOworICAgICAgICBlcnJvciA9IFBhcnNl ckVycm9yKFBhcnNlckVycm9yOjpTeW50YXhFcnJvciwgUGFyc2VyRXJyb3I6OlN5bnRheEVycm9y SXJyZWNvdmVyYWJsZSwgdG9rZW4sICJQYXJzZXIgZXJyb3IiLCAtMSk7CisgICAgICAgIHJldHVy biBudWxscHRyOworICAgIH0KICAgICBBU1NFUlQoZnVuY0RlY2wpOwogICAgIEFTU0VSVChmdW5j RGVjbC0+aXNGdW5jRGVjbE5vZGUoKSk7Ci0gICAgaWYgKCFmdW5jRGVjbCB8fCAhZnVuY0RlY2wt PmlzRnVuY0RlY2xOb2RlKCkpCi0gICAgICAgIHJldHVybiBudWxscHRyOwogCiAgICAgRnVuY3Rp b25NZXRhZGF0YU5vZGUqIG1ldGFkYXRhID0gc3RhdGljX2Nhc3Q8RnVuY0RlY2xOb2RlKj4oZnVu Y0RlY2wpLT5tZXRhZGF0YSgpOwogICAgIEFTU0VSVChtZXRhZGF0YSk7CmRpZmYgLS1naXQgYS9K U1Rlc3RzL0NoYW5nZUxvZyBiL0pTVGVzdHMvQ2hhbmdlTG9nCmluZGV4IGVkMWZiYjgyNjVjYzNj Y2EzODZjMmQ2MDAwYzExNmFmMzUzNWYxMTMuLjNjMjFmZThjOWI0ZmVjYTMzYTVkNDdlMWI1NGQ0 YTljYjNmY2JkYTIgMTAwNjQ0Ci0tLSBhL0pTVGVzdHMvQ2hhbmdlTG9nCisrKyBiL0pTVGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMTYtMTAtMjEgIENhaXRsaW4gUG90dGVyICA8 Y2FpdHBAaWdhbGlhLmNvbT4KKworICAgICAgICBbSlNDXSBkb24ndCBjcmFzaCB3aGVuIGFyZ3Vt ZW50cyB0byBgbmV3IEZ1bmN0aW9uKClgIHByb2R1Y2UgdW5leHBlY3RlZCBBU1QKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2Mzc0OAorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogc3RyZXNzL3JlZ3Jlc3Mt MTYzNzQ4LmpzOiBBZGRlZC4KKyAgICAgICAgKGFzc2VydCk6CisgICAgICAgIChzaG91bGRUaHJv d1N5bnRheEVycm9yKToKKyAgICAgICAgKEdlbmVyYXRvckZ1bmN0aW9uKToKKwogMjAxNi0xMC0y MCAgS2VpdGggTWlsbGVyICA8a2VpdGhfbWlsbGVyQGFwcGxlLmNvbT4KIAogICAgICAgICBBZGQg c3VwcG9ydCBmb3IgV0FTTSBjYWxscwpkaWZmIC0tZ2l0IGEvSlNUZXN0cy9zdHJlc3MvcmVncmVz cy0xNjM3NDguanMgYi9KU1Rlc3RzL3N0cmVzcy9yZWdyZXNzLTE2Mzc0OC5qcwpuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw Li44MDc3OThhZjgxZTdlZjFkOTJiYTRmOTljZTZiYjQ4ZDI5MmQ5ZDA2Ci0tLSAvZGV2L251bGwK KysrIGIvSlNUZXN0cy9zdHJlc3MvcmVncmVzcy0xNjM3NDguanMKQEAgLTAsMCArMSwyNCBAQAor ZnVuY3Rpb24gYXNzZXJ0KGNvbmQsIG1zZyA9ICIiKSB7CisgICAgaWYgKCFjb25kKQorICAgICAg ICB0aHJvdyBuZXcgRXJyb3IobXNnKTsKK30KK25vSW5saW5lKGFzc2VydCk7CisKK2Z1bmN0aW9u IHNob3VsZFRocm93U3ludGF4RXJyb3Ioc3RyKSB7CisgICAgdmFyIGhhZEVycm9yID0gZmFsc2U7 CisgICAgdHJ5IHsKKyAgICAgICAgZXZhbChzdHIpOworICAgIH0gY2F0Y2ggKGUpIHsKKyAgICAg ICAgaWYgKGUgaW5zdGFuY2VvZiBTeW50YXhFcnJvcikKKyAgICAgICAgICAgIGhhZEVycm9yID0g dHJ1ZTsKKyAgICB9CisgICAgYXNzZXJ0KGhhZEVycm9yLCAiRGlkIG5vdCB0aHJvdyBzeW50YXgg ZXJyb3IiKTsKK30KK25vSW5saW5lKHNob3VsZFRocm93U3ludGF4RXJyb3IpOworCitzaG91bGRU aHJvd1N5bnRheEVycm9yKCJ2YXIgZiA9IG5ldyBGdW5jdGlvbignfXsnKSIpOworc2hvdWxkVGhy b3dTeW50YXhFcnJvcigidmFyIGYgPSBuZXcgRnVuY3Rpb24oJ319e3snKSIpOworCit2YXIgR2Vu ZXJhdG9yRnVuY3Rpb24gPSBmdW5jdGlvbiooKXt9LmNvbnN0cnVjdG9yOworc2hvdWxkVGhyb3dT eW50YXhFcnJvcigidmFyIGYgPSBuZXcgR2VuZXJhdG9yRnVuY3Rpb24oJ317JykiKTsKK3Nob3Vs ZFRocm93U3ludGF4RXJyb3IoInZhciBmID0gbmV3IEdlbmVyYXRvckZ1bmN0aW9uKCd9fXt7Jyki KTsK 292362 2016-10-21 10:07:34 -0700 2016-10-21 10:27:11 -0700 Remove redundant ASSERT()s and add branch prediction hints bug-163748-20161021130354.patch text/plain 3811 caitp U3VidmVyc2lvbiBSZXZpc2lvbjogMjA3Njc3CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCA0 YzExNjRmNDQxNmRlYTNiYTFjNGQzZTcwMWY1MWQ0ZWQxNWU5OGIxLi5lMzhiMWQ2NGEyNTZjZWMz ODI3MWVhZmM5MmUxZGE4OWVjOTJkNDM0IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwxMyBAQAorMjAxNi0xMC0yMSAgQ2FpdGxpbiBQb3R0ZXIgIDxjYWl0cEBpZ2FsaWEuY29t PgorCisgICAgICAgIFtKU0NdIGRvbid0IGNyYXNoIHdoZW4gYXJndW1lbnRzIHRvIGBuZXcgRnVu Y3Rpb24oKWAgcHJvZHVjZSB1bmV4cGVjdGVkIEFTVAorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTYzNzQ4CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9C T0RZIChPT1BTISkuCisKKyAgICAgICAgKiBydW50aW1lL0NvZGVDYWNoZS5jcHA6CisgICAgICAg IChKU0M6OkNvZGVDYWNoZTo6Z2V0RnVuY3Rpb25FeGVjdXRhYmxlRnJvbUdsb2JhbENvZGUpOgor CiAyMDE2LTEwLTIwICBLZWl0aCBNaWxsZXIgIDxrZWl0aF9taWxsZXJAYXBwbGUuY29tPgogCiAg ICAgICAgIEFkZCBzdXBwb3J0IGZvciBXQVNNIGNhbGxzCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvcnVudGltZS9Db2RlQ2FjaGUuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3Jl L3J1bnRpbWUvQ29kZUNhY2hlLmNwcAppbmRleCA3M2VmYWIxNjg0YjAyNjMwOGMxNjA1NDRjMGJl MTE2NDk2NTYxZjc1Li5jYzdhN2Y4ZGQxZTZmMWYwZmUxMDJhMDEwYTBiZjgwYTljYzM4OTEwIDEw MDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9Db2RlQ2FjaGUuY3BwCisr KyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0NvZGVDYWNoZS5jcHAKQEAgLTE4Miwx NiArMTgyLDIwIEBAIFVubGlua2VkRnVuY3Rpb25FeGVjdXRhYmxlKiBDb2RlQ2FjaGU6OmdldEZ1 bmN0aW9uRXhlY3V0YWJsZUZyb21HbG9iYWxDb2RlKFZNJiB2CiAKICAgICAvLyBUaGlzIGZ1bmN0 aW9uIGFzc3VtZXMgYW4gaW5wdXQgc3RyaW5nIHRoYXQgd291bGQgcmVzdWx0IGluIGEgc2luZ2xl IGZ1bmN0aW9uIGRlY2xhcmF0aW9uLgogICAgIFN0YXRlbWVudE5vZGUqIHN0YXRlbWVudCA9IHBy b2dyYW0tPnNpbmdsZVN0YXRlbWVudCgpOwotICAgIEFTU0VSVChzdGF0ZW1lbnQpOwotICAgIEFT U0VSVChzdGF0ZW1lbnQtPmlzQmxvY2soKSk7Ci0gICAgaWYgKCFzdGF0ZW1lbnQgfHwgIXN0YXRl bWVudC0+aXNCbG9jaygpKQorICAgIGlmIChVTkxJS0VMWSghc3RhdGVtZW50KSkgeworICAgICAg ICBKU1Rva2VuIHRva2VuOworICAgICAgICBlcnJvciA9IFBhcnNlckVycm9yKFBhcnNlckVycm9y OjpTeW50YXhFcnJvciwgUGFyc2VyRXJyb3I6OlN5bnRheEVycm9ySXJyZWNvdmVyYWJsZSwgdG9r ZW4sICJQYXJzZXIgZXJyb3IiLCAtMSk7CiAgICAgICAgIHJldHVybiBudWxscHRyOworICAgIH0K KyAgICBBU1NFUlQoc3RhdGVtZW50LT5pc0Jsb2NrKCkpOwogCiAgICAgU3RhdGVtZW50Tm9kZSog ZnVuY0RlY2wgPSBzdGF0aWNfY2FzdDxCbG9ja05vZGUqPihzdGF0ZW1lbnQpLT5zaW5nbGVTdGF0 ZW1lbnQoKTsKLSAgICBBU1NFUlQoZnVuY0RlY2wpOwotICAgIEFTU0VSVChmdW5jRGVjbC0+aXNG dW5jRGVjbE5vZGUoKSk7Ci0gICAgaWYgKCFmdW5jRGVjbCB8fCAhZnVuY0RlY2wtPmlzRnVuY0Rl Y2xOb2RlKCkpCisgICAgaWYgKFVOTElLRUxZKCFmdW5jRGVjbCkpIHsKKyAgICAgICAgSlNUb2tl biB0b2tlbjsKKyAgICAgICAgZXJyb3IgPSBQYXJzZXJFcnJvcihQYXJzZXJFcnJvcjo6U3ludGF4 RXJyb3IsIFBhcnNlckVycm9yOjpTeW50YXhFcnJvcklycmVjb3ZlcmFibGUsIHRva2VuLCAiUGFy c2VyIGVycm9yIiwgLTEpOwogICAgICAgICByZXR1cm4gbnVsbHB0cjsKKyAgICB9CisgICAgQVNT RVJUKGZ1bmNEZWNsLT5pc0Z1bmNEZWNsTm9kZSgpKTsKIAogICAgIEZ1bmN0aW9uTWV0YWRhdGFO b2RlKiBtZXRhZGF0YSA9IHN0YXRpY19jYXN0PEZ1bmNEZWNsTm9kZSo+KGZ1bmNEZWNsKS0+bWV0 YWRhdGEoKTsKICAgICBBU1NFUlQobWV0YWRhdGEpOwpkaWZmIC0tZ2l0IGEvSlNUZXN0cy9DaGFu Z2VMb2cgYi9KU1Rlc3RzL0NoYW5nZUxvZwppbmRleCBlZDFmYmI4MjY1Y2MzY2NhMzg2YzJkNjAw MGMxMTZhZjM1MzVmMTEzLi4zYzIxZmU4YzliNGZlY2EzM2E1ZDQ3ZTFiNTRkNGE5Y2IzZmNiZGEy IDEwMDY0NAotLS0gYS9KU1Rlc3RzL0NoYW5nZUxvZworKysgYi9KU1Rlc3RzL0NoYW5nZUxvZwpA QCAtMSwzICsxLDE1IEBACisyMDE2LTEwLTIxICBDYWl0bGluIFBvdHRlciAgPGNhaXRwQGlnYWxp YS5jb20+CisKKyAgICAgICAgW0pTQ10gZG9uJ3QgY3Jhc2ggd2hlbiBhcmd1bWVudHMgdG8gYG5l dyBGdW5jdGlvbigpYCBwcm9kdWNlIHVuZXhwZWN0ZWQgQVNUCisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjM3NDgKKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIHN0cmVzcy9yZWdyZXNzLTE2Mzc0OC5qczog QWRkZWQuCisgICAgICAgIChhc3NlcnQpOgorICAgICAgICAoc2hvdWxkVGhyb3dTeW50YXhFcnJv cik6CisgICAgICAgIChHZW5lcmF0b3JGdW5jdGlvbik6CisKIDIwMTYtMTAtMjAgIEtlaXRoIE1p bGxlciAgPGtlaXRoX21pbGxlckBhcHBsZS5jb20+CiAKICAgICAgICAgQWRkIHN1cHBvcnQgZm9y IFdBU00gY2FsbHMKZGlmZiAtLWdpdCBhL0pTVGVzdHMvc3RyZXNzL3JlZ3Jlc3MtMTYzNzQ4Lmpz IGIvSlNUZXN0cy9zdHJlc3MvcmVncmVzcy0xNjM3NDguanMKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uODA3Nzk4YWY4 MWU3ZWYxZDkyYmE0Zjk5Y2U2YmI0OGQyOTJkOWQwNgotLS0gL2Rldi9udWxsCisrKyBiL0pTVGVz dHMvc3RyZXNzL3JlZ3Jlc3MtMTYzNzQ4LmpzCkBAIC0wLDAgKzEsMjQgQEAKK2Z1bmN0aW9uIGFz c2VydChjb25kLCBtc2cgPSAiIikgeworICAgIGlmICghY29uZCkKKyAgICAgICAgdGhyb3cgbmV3 IEVycm9yKG1zZyk7Cit9Citub0lubGluZShhc3NlcnQpOworCitmdW5jdGlvbiBzaG91bGRUaHJv d1N5bnRheEVycm9yKHN0cikgeworICAgIHZhciBoYWRFcnJvciA9IGZhbHNlOworICAgIHRyeSB7 CisgICAgICAgIGV2YWwoc3RyKTsKKyAgICB9IGNhdGNoIChlKSB7CisgICAgICAgIGlmIChlIGlu c3RhbmNlb2YgU3ludGF4RXJyb3IpCisgICAgICAgICAgICBoYWRFcnJvciA9IHRydWU7CisgICAg fQorICAgIGFzc2VydChoYWRFcnJvciwgIkRpZCBub3QgdGhyb3cgc3ludGF4IGVycm9yIik7Cit9 Citub0lubGluZShzaG91bGRUaHJvd1N5bnRheEVycm9yKTsKKworc2hvdWxkVGhyb3dTeW50YXhF cnJvcigidmFyIGYgPSBuZXcgRnVuY3Rpb24oJ317JykiKTsKK3Nob3VsZFRocm93U3ludGF4RXJy b3IoInZhciBmID0gbmV3IEZ1bmN0aW9uKCd9fXt7JykiKTsKKwordmFyIEdlbmVyYXRvckZ1bmN0 aW9uID0gZnVuY3Rpb24qKCl7fS5jb25zdHJ1Y3RvcjsKK3Nob3VsZFRocm93U3ludGF4RXJyb3Io InZhciBmID0gbmV3IEdlbmVyYXRvckZ1bmN0aW9uKCd9eycpIik7CitzaG91bGRUaHJvd1N5bnRh eEVycm9yKCJ2YXIgZiA9IG5ldyBHZW5lcmF0b3JGdW5jdGlvbignfX17eycpIik7Cg== 292366 2016-10-21 10:27:17 -0700 2016-10-21 10:52:15 -0700 fix the changelog bug-163748-20161021132338.patch text/plain 4642 caitp U3VidmVyc2lvbiBSZXZpc2lvbjogMjA3Njc3CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCA0 YzExNjRmNDQxNmRlYTNiYTFjNGQzZTcwMWY1MWQ0ZWQxNWU5OGIxLi5jMjJmMzUxMGMwZWNkMGMy NWUwMDUxMWQyYjgxNmZmOTRlOGQ1NjE2IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwyNSBAQAorMjAxNi0xMC0yMSAgQ2FpdGxpbiBQb3R0ZXIgIDxjYWl0cEBpZ2FsaWEuY29t PgorCisgICAgICAgIFtKU0NdIGRvbid0IGNyYXNoIHdoZW4gYXJndW1lbnRzIHRvIGBuZXcgRnVu Y3Rpb24oKWAgcHJvZHVjZSB1bmV4cGVjdGVkIEFTVAorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTYzNzQ4CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTWFy ayBMYW0uCisKKyAgICAgICAgVGhlIEFTU0VSVChzdGF0ZW1lbnQpOyBhbmQgQVNTRVJUKGZ1bmNE ZWNsKTsgbGluZXMgYXJlIHJlbW92ZWQsIHJlcGxhY2VkIHdpdGggYmxvY2tzCisgICAgICAgIHRv IHJlcG9ydCBhIGdlbmVyaWMgUGFyc2VyIGVycm9yIG1lc3NhZ2UuIFRoZXNlIGxpbmVzIGFyZSBv bmx5IHBvc3NpYmxlIHRvIGJlIHJlYWNoZWQKKyAgICAgICAgaWYgdGhlIGlucHV0IHN0cmluZyBw cm9kdWNlZCBhbiB1bmV4cGVjdGVkIEFTVCwgd2hpY2ggcHJldmlvdXNseSBjb3VsZCBiZSB1c2Vk IHRvIGNyYXNoCisgICAgICAgIHRoZSBwcm9jZXNzIHZpYSBBU1NFUlQgZmFpbHVyZS4KKworICAg ICAgICBUaGUgbm9kZSB0eXBlIGFzc2VydGlvbnMgYXJlIGxlZnQgaW4gdGhlIHRyZWUsIGFzIGl0 IHNob3VsZCBiZSBpbXBvc3NpYmxlIGZvciBhIHRvcC1sZXZlbAorICAgICAgICBge2AgdG8gcHJv ZHVjZSBhbnl0aGluZyBvdGhlciB0aGFuIGEgQmxvY2sgbm9kZS4gSWYgdGhlIG5vZGUgdHVybnMg b3V0IG5vdCB0byBiZSBhIEJsb2NrLAorICAgICAgICBpdCBpbmRpY2F0ZXMgdGhhdCB0aGUgKEMr KykgY2FsbGVyIG9mIHRoaXMgZnVuY3Rpb24gKEUuZyBpbiBGdW5jdGlvbkNvbnN0cnVjdG9yLmNw cCksIGlzCisgICAgICAgIGRvaW5nIHNvbWV0aGluZyBpbmNvcnJlY3QuIFNpbWlsYXJseSwgaXQg c2hvdWxkIGJlIGltcG9zc2libGUgZm9yIHRoZSBgZnVuY0RlY2xgIG5vZGUgdG8KKyAgICAgICAg YmUgYW55dGhpbmcgb3RoZXIgdGhhbiBhIGZ1bmN0aW9uIGRlY2xhcmF0aW9uIGdpdmVuIHRoZSBj b252ZW50aW9ucyBvZiB0aGUgY2FsbGVyIG9mIHRoaXMKKyAgICAgICAgZnVuY3Rpb24uCisKKyAg ICAgICAgKiBydW50aW1lL0NvZGVDYWNoZS5jcHA6CisgICAgICAgIChKU0M6OkNvZGVDYWNoZTo6 Z2V0RnVuY3Rpb25FeGVjdXRhYmxlRnJvbUdsb2JhbENvZGUpOgorCiAyMDE2LTEwLTIwICBLZWl0 aCBNaWxsZXIgIDxrZWl0aF9taWxsZXJAYXBwbGUuY29tPgogCiAgICAgICAgIEFkZCBzdXBwb3J0 IGZvciBXQVNNIGNhbGxzCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGlt ZS9Db2RlQ2FjaGUuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvQ29kZUNhY2hl LmNwcAppbmRleCA3M2VmYWIxNjg0YjAyNjMwOGMxNjA1NDRjMGJlMTE2NDk2NTYxZjc1Li5jYzdh N2Y4ZGQxZTZmMWYwZmUxMDJhMDEwYTBiZjgwYTljYzM4OTEwIDEwMDY0NAotLS0gYS9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvcnVudGltZS9Db2RlQ2FjaGUuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS9ydW50aW1lL0NvZGVDYWNoZS5jcHAKQEAgLTE4MiwxNiArMTgyLDIwIEBAIFVubGlu a2VkRnVuY3Rpb25FeGVjdXRhYmxlKiBDb2RlQ2FjaGU6OmdldEZ1bmN0aW9uRXhlY3V0YWJsZUZy b21HbG9iYWxDb2RlKFZNJiB2CiAKICAgICAvLyBUaGlzIGZ1bmN0aW9uIGFzc3VtZXMgYW4gaW5w dXQgc3RyaW5nIHRoYXQgd291bGQgcmVzdWx0IGluIGEgc2luZ2xlIGZ1bmN0aW9uIGRlY2xhcmF0 aW9uLgogICAgIFN0YXRlbWVudE5vZGUqIHN0YXRlbWVudCA9IHByb2dyYW0tPnNpbmdsZVN0YXRl bWVudCgpOwotICAgIEFTU0VSVChzdGF0ZW1lbnQpOwotICAgIEFTU0VSVChzdGF0ZW1lbnQtPmlz QmxvY2soKSk7Ci0gICAgaWYgKCFzdGF0ZW1lbnQgfHwgIXN0YXRlbWVudC0+aXNCbG9jaygpKQor ICAgIGlmIChVTkxJS0VMWSghc3RhdGVtZW50KSkgeworICAgICAgICBKU1Rva2VuIHRva2VuOwor ICAgICAgICBlcnJvciA9IFBhcnNlckVycm9yKFBhcnNlckVycm9yOjpTeW50YXhFcnJvciwgUGFy c2VyRXJyb3I6OlN5bnRheEVycm9ySXJyZWNvdmVyYWJsZSwgdG9rZW4sICJQYXJzZXIgZXJyb3Ii LCAtMSk7CiAgICAgICAgIHJldHVybiBudWxscHRyOworICAgIH0KKyAgICBBU1NFUlQoc3RhdGVt ZW50LT5pc0Jsb2NrKCkpOwogCiAgICAgU3RhdGVtZW50Tm9kZSogZnVuY0RlY2wgPSBzdGF0aWNf Y2FzdDxCbG9ja05vZGUqPihzdGF0ZW1lbnQpLT5zaW5nbGVTdGF0ZW1lbnQoKTsKLSAgICBBU1NF UlQoZnVuY0RlY2wpOwotICAgIEFTU0VSVChmdW5jRGVjbC0+aXNGdW5jRGVjbE5vZGUoKSk7Ci0g ICAgaWYgKCFmdW5jRGVjbCB8fCAhZnVuY0RlY2wtPmlzRnVuY0RlY2xOb2RlKCkpCisgICAgaWYg KFVOTElLRUxZKCFmdW5jRGVjbCkpIHsKKyAgICAgICAgSlNUb2tlbiB0b2tlbjsKKyAgICAgICAg ZXJyb3IgPSBQYXJzZXJFcnJvcihQYXJzZXJFcnJvcjo6U3ludGF4RXJyb3IsIFBhcnNlckVycm9y OjpTeW50YXhFcnJvcklycmVjb3ZlcmFibGUsIHRva2VuLCAiUGFyc2VyIGVycm9yIiwgLTEpOwog ICAgICAgICByZXR1cm4gbnVsbHB0cjsKKyAgICB9CisgICAgQVNTRVJUKGZ1bmNEZWNsLT5pc0Z1 bmNEZWNsTm9kZSgpKTsKIAogICAgIEZ1bmN0aW9uTWV0YWRhdGFOb2RlKiBtZXRhZGF0YSA9IHN0 YXRpY19jYXN0PEZ1bmNEZWNsTm9kZSo+KGZ1bmNEZWNsKS0+bWV0YWRhdGEoKTsKICAgICBBU1NF UlQobWV0YWRhdGEpOwpkaWZmIC0tZ2l0IGEvSlNUZXN0cy9DaGFuZ2VMb2cgYi9KU1Rlc3RzL0No YW5nZUxvZwppbmRleCBlZDFmYmI4MjY1Y2MzY2NhMzg2YzJkNjAwMGMxMTZhZjM1MzVmMTEzLi44 Nzg5NDQ1NzUzM2Q0YWVjMGMxOTFiN2ZkMTA3YWY1NWViNmNmMmQzIDEwMDY0NAotLS0gYS9KU1Rl c3RzL0NoYW5nZUxvZworKysgYi9KU1Rlc3RzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisy MDE2LTEwLTIxICBDYWl0bGluIFBvdHRlciAgPGNhaXRwQGlnYWxpYS5jb20+CisKKyAgICAgICAg W0pTQ10gZG9uJ3QgY3Jhc2ggd2hlbiBhcmd1bWVudHMgdG8gYG5ldyBGdW5jdGlvbigpYCBwcm9k dWNlIHVuZXhwZWN0ZWQgQVNUCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD0xNjM3NDgKKworICAgICAgICBSZXZpZXdlZCBieSBNYXJrIExhbS4KKworICAg ICAgICAqIHN0cmVzcy9yZWdyZXNzLTE2Mzc0OC5qczogQWRkZWQuCisgICAgICAgIChhc3NlcnQp OgorICAgICAgICAoc2hvdWxkVGhyb3dTeW50YXhFcnJvcik6CisgICAgICAgIChHZW5lcmF0b3JG dW5jdGlvbik6CisKIDIwMTYtMTAtMjAgIEtlaXRoIE1pbGxlciAgPGtlaXRoX21pbGxlckBhcHBs ZS5jb20+CiAKICAgICAgICAgQWRkIHN1cHBvcnQgZm9yIFdBU00gY2FsbHMKZGlmZiAtLWdpdCBh L0pTVGVzdHMvc3RyZXNzL3JlZ3Jlc3MtMTYzNzQ4LmpzIGIvSlNUZXN0cy9zdHJlc3MvcmVncmVz cy0xNjM3NDguanMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uODA3Nzk4YWY4MWU3ZWYxZDkyYmE0Zjk5Y2U2YmI0OGQy OTJkOWQwNgotLS0gL2Rldi9udWxsCisrKyBiL0pTVGVzdHMvc3RyZXNzL3JlZ3Jlc3MtMTYzNzQ4 LmpzCkBAIC0wLDAgKzEsMjQgQEAKK2Z1bmN0aW9uIGFzc2VydChjb25kLCBtc2cgPSAiIikgewor ICAgIGlmICghY29uZCkKKyAgICAgICAgdGhyb3cgbmV3IEVycm9yKG1zZyk7Cit9Citub0lubGlu ZShhc3NlcnQpOworCitmdW5jdGlvbiBzaG91bGRUaHJvd1N5bnRheEVycm9yKHN0cikgeworICAg IHZhciBoYWRFcnJvciA9IGZhbHNlOworICAgIHRyeSB7CisgICAgICAgIGV2YWwoc3RyKTsKKyAg ICB9IGNhdGNoIChlKSB7CisgICAgICAgIGlmIChlIGluc3RhbmNlb2YgU3ludGF4RXJyb3IpCisg ICAgICAgICAgICBoYWRFcnJvciA9IHRydWU7CisgICAgfQorICAgIGFzc2VydChoYWRFcnJvciwg IkRpZCBub3QgdGhyb3cgc3ludGF4IGVycm9yIik7Cit9Citub0lubGluZShzaG91bGRUaHJvd1N5 bnRheEVycm9yKTsKKworc2hvdWxkVGhyb3dTeW50YXhFcnJvcigidmFyIGYgPSBuZXcgRnVuY3Rp b24oJ317JykiKTsKK3Nob3VsZFRocm93U3ludGF4RXJyb3IoInZhciBmID0gbmV3IEZ1bmN0aW9u KCd9fXt7JykiKTsKKwordmFyIEdlbmVyYXRvckZ1bmN0aW9uID0gZnVuY3Rpb24qKCl7fS5jb25z dHJ1Y3RvcjsKK3Nob3VsZFRocm93U3ludGF4RXJyb3IoInZhciBmID0gbmV3IEdlbmVyYXRvckZ1 bmN0aW9uKCd9eycpIik7CitzaG91bGRUaHJvd1N5bnRheEVycm9yKCJ2YXIgZiA9IG5ldyBHZW5l cmF0b3JGdW5jdGlvbignfX17eycpIik7Cg==