42785 2010-07-21 14:01:09 -0700 Crash in WebKit2WebProcess in WaitForMultipleObjects beneath WorkQueue::workQueueThreadBody when running tests that produce a lot of output 2010-07-28 12:59:07 -0700 1 1 1 Unclassified WebKit WebKit2 528+ (Nightly build) PC Windows XP RESOLVED FIXED InRadar, PlatformOnly P2 Normal --- 1 aroben webkit-unassigned andersca mjs zoltan oldest_to_newest 254505 0 aroben 2010-07-21 14:01:09 -0700 To reproduce: 1. run-webkit-tests --webkit-test-runner WebKit2WebProcess.exe crashes when WebKitTestRunner exits. It's crashing due to a null dereference inside WaitForMultipleObjects. Here's the backtrace: 00000000() 0236ff10() kernel32.dll!_WaitForMultipleObjects@16() + 0x18 bytes > WebKit.dll!WorkQueue::workQueueThreadBody() Line 63 + 0x1e bytes C++ WebKit.dll!WorkQueue::workQueueThreadBody(void * context=0x01d90a8c) Line 46 C++ JavaScriptCore.dll!WTF::threadEntryPoint(void * contextData=0x01d90c18) Line 65 + 0x9 bytes C++ JavaScriptCore.dll!WTF::wtfThreadEntryPoint(void * param=0x01d90c48) Line 202 + 0x9 bytes C++ msvcr80.dll!_callthreadstartex() Line 348 + 0x6 bytes C msvcr80.dll!_threadstartex(void * ptd=0x01d90c58) Line 326 + 0x5 bytes C kernel32.dll!_BaseThreadStart@8() + 0x37 bytes 254507 1 aroben 2010-07-21 14:02:13 -0700 MSDN says: If one of these handles is closed while the wait is still pending, the function's behavior is undefined. <http://msdn.microsoft.com/en-us/library/ms687025(VS.85).aspx> My guess is this is the situation we're running into. 254508 2 aroben 2010-07-21 14:02:39 -0700 <rdar://problem/8218522> 254514 3 andersca 2010-07-21 14:12:25 -0700 (In reply to comment #1) > MSDN says: > > If one of these handles is closed while the wait is still pending, the function's behavior is undefined. > <http://msdn.microsoft.com/en-us/library/ms687025(VS.85).aspx> > > My guess is this is the situation we're running into. Yeah probably. We need to add a way to unregister handles on a Work Queue. 254537 4 aroben 2010-07-21 14:52:36 -0700 I thought about using a WorkItem to close the handle. Doing it this way guarantees that we're not waiting on the handle at the time we close it, because WorkItems are only processed when WaitForMultipleObjects is not being called. However, if the WorkQueue is invalidated before we process one of these close-the-handle WorkItems, the handle will be leaked. And this doesn't help us close the WorkQueue's m_performWorkEvent itself. 254539 5 aroben 2010-07-21 14:53:48 -0700 If we changed WorkQueue to always call performWork(), even when m_performWorkEvent is not the handle that was signaled, we could still use the WorkItem approach described in comment 4, as we'd be guaranteed that all WorkItems would be processed before the queue stops. 254544 6 aroben 2010-07-21 14:59:08 -0700 It looks like Mac doesn't process any more WorkItems once a WorkQueue is invalidated. On Windows, we might still process some more WorkItems once a WorkQueue is invalidated. We should fix Windows to work like Mac. This means that my idea in comment 5 won't work. 254546 7 andersca 2010-07-21 15:04:16 -0700 (In reply to comment #6) > It looks like Mac doesn't process any more WorkItems once a WorkQueue is invalidated. On Windows, we might still process some more WorkItems once a WorkQueue is invalidated. We should fix Windows to work like Mac. This means that my idea in comment 5 won't work. Agreed. We should also free all work items when a work queue is invalidated. 254759 8 aroben 2010-07-22 06:33:59 -0700 I think using a pair of events will work. The first event will be used to tell the work queue thread to stop waiting. The second event will be used to tell the main thread that waiting has stopped. 254762 9 aroben 2010-07-22 06:45:59 -0700 It looks like Connection::invalidate is never being called in the UI process. I don't see any code that would do this. It looks like the right place to do it would be in WebProcessProxy. Connection::invalidate is also not called in the web process before the crash happens. 254809 10 aroben 2010-07-22 08:29:13 -0700 I've done some more investigation and identified 3 issues that are probably contributing to this bug. The first is the low-level issue identified in comment 1: Bug 42826: Crash in WaitForMultipleObjects in WorkQueue because WorkQueue keeps waiting on closed HANDLEs However, due to what I discovered in comment 9, it's not entirely clear that this is the immediate cause of the bug, since it looks like HANDLEs aren't getting closed at all. HANDLEs aren't getting closed because of the combination of these two bugs: Bug 42825: WebKitTestRunner never destroys its main PlatformWebView (and thus its WKView[Ref]) Bug 42828: WebKit2 fails to shut down the web process if some WKPages still exist when the UI process exits If we fix one or both of those, it's possible the crash will go away. Or maybe then we'll *really* start running into bug 42826. I'm going to mark this bug as blocked by the above three bugs, even though we might be able to fix the crash by fixing just one of the above bugs, and we aren't totally sure that bug 42826 is even an issue in this case. I'll work on the above three bugs and then see if this crash still happens. 256178 11 aroben 2010-07-26 12:44:21 -0700 (In reply to comment #6) > It looks like Mac doesn't process any more WorkItems once a WorkQueue is invalidated. On Windows, we might still process some more WorkItems once a WorkQueue is invalidated. Specifically, WorkItems added by registerHandle might still be processed. Those added by scheduleWork will not be processed, due to checking done in performWork. 256190 12 aroben 2010-07-26 12:58:33 -0700 Strangely, turning on full page heap makes the crash go away. 256220 13 aroben 2010-07-26 13:58:41 -0700 Fixing both bug 42826 and bug 42825 does not fix this crash. At the time the crash happens, no Connection or WorkQueue has been destroyed or invalidated. The crash seems to happen soon after the InjectedBundle sends the render tree dump to the UI process. 256237 14 aroben 2010-07-26 14:30:38 -0700 This command does not crash: run-webkit-tests --webkit-test-runner fast/js/parseFloat.html Maybe the crash has to do with the amount of data being sent in the dump? 256353 15 mjs 2010-07-26 17:34:37 -0700 (In reply to comment #14) > This command does not crash: > > run-webkit-tests --webkit-test-runner fast/js/parseFloat.html > > Maybe the crash has to do with the amount of data being sent in the dump? Maybe large messages get split in some way? (Or need to be but aren't?) 256559 16 aroben 2010-07-27 07:13:45 -0700 > (In reply to comment #14) > > This command does not crash: > > > > run-webkit-tests --webkit-test-runner fast/js/parseFloat.html > > > > Maybe the crash has to do with the amount of data being sent in the dump? > > Maybe large messages get split in some way? (Or need to be but aren't?) <http://trac.webkit.org/changeset/63852> supposedly made CoreIPC able to read large messages. But maybe there's a bug in there somewhere, or something else we have to do.(In reply to comment #15) 257153 17 aroben 2010-07-28 08:14:43 -0700 As an experiment, I modified InjectedBundle to send strings of a certain length in InjectedBundle::done, rather than sending the test output. Sending a string of 2023 characters crashes almost every time. This turns into a 4074-byte message. It looks like there are usually two 20-byte messages that get sent with it, for a total of 4114 bytes. This is just a little bit over the 4096-byte buffer size we specify to ::CreateNamedPipe. Increasing the buffer size we specify to ::CreateNamedPipe to 8192 bytes fixes the crash in this experiment. So it looks like we have a problem with sending messages larger than the pipe's buffer size. 257162 18 aroben 2010-07-28 08:20:04 -0700 MSDN says: The input and output buffer sizes are advisory. The actual buffer size reserved for each end of the named pipe is either the system default, the system minimum or maximum, or the specified size rounded up to the next allocation boundary. The buffer size specified should be small enough that your process will not run out of nonpaged pool, but large enough to accommodate typical requests. Whenever a pipe write operation occurs, the system first tries to charge the memory against the pipe write quota. If the remaining pipe write quota is enough to fulfill the request, the write operation completes immediately. If the remaining pipe write quota is too small to fulfill the request, the system will try to expand the buffers to accommodate the data using nonpaged pool reserved for the process. The write operation will block until the data is read from the pipe so that the additional buffer quota can be released. Therefore, if your specified buffer size is too small, the system will grow the buffer as needed, but the downside is that the operation will block. If the operation is overlapped, a system thread is blocked; otherwise, the application thread is blocked. http://msdn.microsoft.com/en-us/library/aa365150(VS.85).aspx 257163 19 aroben 2010-07-28 08:21:43 -0700 Maybe the ArgumentEncoder is being destroyed before ::WriteFile has finished accessing its data? 257164 20 aroben 2010-07-28 08:22:45 -0700 (In reply to comment #19) > Maybe the ArgumentEncoder is being destroyed before ::WriteFile has finished accessing its data? The docs for ::WriteFile say: Accessing the output buffer while a write operation is using the buffer may lead to corruption of the data written from that buffer. Applications must not write to, reallocate, or free the output buffer that a write operation is using until the write operation completes. This can be particularly problematic when using an asynchronous file handle. Additional information regarding synchronous versus asynchronous file handles can be found later in the Synchronization and File Position section and Synchronous and Asynchronous I/O. http://msdn.microsoft.com/en-us/library/aa365747(VS.85).aspx This seems to make my theory more plausible. 257167 21 aroben 2010-07-28 08:24:29 -0700 The docs also say: Because the write operation starts at the offset that is specified in the OVERLAPPED structure, and WriteFile may return before the system-level write operation is complete (write pending), neither the offset nor any other part of the structure should be modified, freed, or reused by the application until the event is signaled (that is, the write completes). http://msdn.microsoft.com/en-us/library/aa365747(VS.85).aspx So, I think <http://trac.webkit.org/changeset/63852> was buggy. We need to wait for ::WriteFile to complete before destroying the ArgumentEncoder. 257173 22 aroben 2010-07-28 08:31:06 -0700 One way I think we could fix this is: 1) Allocate an event and set it as the overlapped.hEvent member before passing the overlapped structure to ::WriteFile 2) If ::WriteFile succeeds, destroy the event 3) If ::WriteFile fails with ERROR_IO_PENDING, call ::RegisterWaitForSingleObject, passing overlapped.hEvent as the object to wait on and a newly-heap-allocated structure that holds the event and the ArgumentEncoder as the context pointer 4) When the wait callback function is called, destroy the ArgumentEncoder and the event 257177 23 aroben 2010-07-28 08:38:01 -0700 (In reply to comment #22) > One way I think we could fix this is: > > 1) Allocate an event and set it as the overlapped.hEvent member before passing the overlapped structure to ::WriteFile > 2) If ::WriteFile succeeds, destroy the event > 3) If ::WriteFile fails with ERROR_IO_PENDING, call ::RegisterWaitForSingleObject, passing overlapped.hEvent as the object to wait on and a newly-heap-allocated structure that holds the event and the ArgumentEncoder as the context pointer > 4) When the wait callback function is called, destroy the ArgumentEncoder and the event Anders pointed out that this strategy will likely create too many events if many large messages are sent. He suggested having a single write event (like we have a single read event), and changing sendOutgoingMessages to be able to send only some messages, and then resume later. 257264 24 62850 aroben 2010-07-28 11:33:43 -0700 Created attachment 62850 Patch 257314 25 aroben 2010-07-28 12:59:07 -0700 Committed r64223: <http://trac.webkit.org/changeset/64223> 62850 2010-07-28 11:33:43 -0700 2010-07-28 12:32:16 -0700 Patch bug-42785-20100728143353.patch text/plain 15288 aroben ZGlmZiAtLWdpdCBhL1dlYktpdDIvQ2hhbmdlTG9nIGIvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXgg MzdiMzljZWFlYTJjMmU5MDU0ODA0YWY1YWU5NzcwNmRmMjVkOWM1NS4uN2U2MmM5MzI3MGQyNDY4 ZWE4MWZlYTNkODU2Nzk5Njg0NjliMGI5ZiAxMDA2NDQKLS0tIGEvV2ViS2l0Mi9DaGFuZ2VMb2cK KysrIGIvV2ViS2l0Mi9DaGFuZ2VMb2cKQEAgLTEsNSArMSw4NyBAQAogMjAxMC0wNy0yOCAgQWRh bSBSb2JlbiAgPGFyb2JlbkBhcHBsZS5jb20+CiAKKyAgICAgICAgVGVhY2ggQ29yZUlQQyB0aGUg cmlnaHQgd2F5IHRvIHNlbmQgbGFyZ2UgbWVzc2FnZXMgb24gV2luZG93cworCisgICAgICAgIHI2 Mzc3NiBhZGRlZCBzdXBwb3J0IGZvciA6OldyaXRlRmlsZSBmYWlsaW5nIHdpdGggRVJST1JfSU9f UEVORElORywKKyAgICAgICAgYnV0IGl0IGhhZCBhIG1ham9yIGZsYXc6IHdlIGRpZG4ndCBlbnN1 cmUgdGhhdCB0aGUgZGF0YSBiZWluZyBzZW50CisgICAgICAgICh3aGljaCBpcyBvd25lZCBieSB0 aGUgQXJndW1lbnRFbmNvZGVyKSBzdGF5ZWQgYXJvdW5kIHVudGlsIHRoZSB3cml0ZQorICAgICAg ICBmaW5pc2hlZC4gV2UnZCBkZXN0cm95IHRoZSBkYXRhIGltbWVkaWF0ZWx5LCBsZWFkaW5nIHRv IDo6V3JpdGVGaWxlCisgICAgICAgIGFjY2Vzc2luZyB0aGF0IGZyZWVkIG1lbW9yeSBsYXRlci4g VGhpcyBzZWVtZWQgdG8gYWx3YXlzIG1hbmlmZXN0CisgICAgICAgIGl0c2VsZiBhcyBhIGNyYXNo IGluIDo6V2FpdEZvck11bHRpcGxlT2JqZWN0cy4KKworICAgICAgICBUaGUgY29ycmVjdCBzb2x1 dGlvbiAoYXMgaGludGVkIGFib3ZlKSBpcyB0byBtYWtlIHN1cmUgdGhhdCB0aGUgZGF0YQorICAg ICAgICBiZWluZyB3cml0dGVuIGlzIG5vdCBkZXN0cm95ZWQgdW50aWwgdGhlIHdyaXRlIGNvbXBs ZXRlcy4gV2hlbgorICAgICAgICA6OldyaXRlRmlsZSBmYWlscyB3aXRoIEVSUk9SX0lPX1BFTkRJ TkcsIHdlIHN0b3JlIHRoZSBkYXRhIGJlaW5nIHNlbnQKKyAgICAgICAgaW4gQ29ubmVjdGlvbjo6 bV9wZW5kaW5nV3JpdGVBcmd1bWVudHMsIGFuZCBkb24ndCBzZW5kIGFueSBtb3JlCisgICAgICAg IG1lc3NhZ2VzIHVudGlsIHRoYXQgd3JpdGUgY29tcGxldGVzLiBXZSB1c2UgYW4gZXZlbnQgaW4g dGhlIE9WRVJMQVBQRUQKKyAgICAgICAgc3RydWN0dXJlIHBhc3NlZCB0byA6OldyaXRlRmlsZSB0 byBkZXRlY3Qgd2hlbiB0aGUgd3JpdGUgaGFzIGNvbXBsZXRlZAorICAgICAgICAoc2ltaWxhciB0 byB3aGF0IHdlIGRvIGZvciByZWFkcykuCisKKyAgICAgICAgRml4ZXMgPGh0dHA6Ly93ZWJraXQu b3JnL2IvNDI3ODU+IDxyZGFyOi8vcHJvYmxlbS84MjE4NTIyPiBDcmFzaCBpbgorICAgICAgICBX ZWJLaXQyV2ViUHJvY2VzcyBpbiBXYWl0Rm9yTXVsdGlwbGVPYmplY3RzIGJlbmVhdGgKKyAgICAg ICAgV29ya1F1ZXVlOjp3b3JrUXVldWVUaHJlYWRCb2R5IHdoZW4gcnVubmluZyB0ZXN0cyB0aGF0 IHByb2R1Y2UgYSBsb3QKKyAgICAgICAgb2Ygb3V0cHV0CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBQbGF0Zm9ybS9Db3JlSVBDL0Nvbm5lY3Rpb24u Y3BwOgorICAgICAgICAoQ29yZUlQQzo6Q29ubmVjdGlvbjo6Y2FuU2VuZE91dGdvaW5nTWVzc2Fn ZXMpOiBBZGRlZC4gVGhpcyBjYWxscyBvdXQKKyAgICAgICAgdG8gYSBwbGF0Zm9ybS1zcGVjaWZp YyBmdW5jdGlvbiB0byBhbGxvdyBlYWNoIHBsYXRmb3JtIHRvIGhhdmUgaXRzIG93bgorICAgICAg ICBwb2xpY3kgZm9yIHdoZW4gbWVzc2FnZXMgY2FuIGFuZCBjYW4ndCBiZSBzZW50LgorICAgICAg ICAoQ29yZUlQQzo6Q29ubmVjdGlvbjo6c2VuZE91dGdvaW5nTWVzc2FnZXMpOiBVc2UgdGhlIG5l dworICAgICAgICBjYW5TZW5kT3V0Z29pbmdNZXNzYWdlcyB0byBkZXRlcm1pbmUgd2hldGhlciB3 ZSBjYW4gc2VuZCBhbnkgbWVzc2FnZXMKKyAgICAgICAgcmlnaHQgbm93LiBXZSBub3cgcmVtb3Zl IG9uZSBtZXNzYWdlIGF0IGEgdGltZSBmcm9tIG1fb3V0Z29pbmdNZXNzYWdlcworICAgICAgICBh bmQgc2VuZCBpdC4gV2Ugc3RvcCBzZW5kaW5nIG1lc3NhZ2VzIHdoZW4gc2VuZE91dGdvaW5nTWVz c2FnZSByZXR1cm5zCisgICAgICAgIGZhbHNlLgorCisgICAgICAgICogUGxhdGZvcm0vQ29yZUlQ Qy9Db25uZWN0aW9uLmg6IEFkZGVkIG1fcGVuZGluZ1dyaXRlQXJndW1lbnRzIGFuZAorICAgICAg ICBtX3dyaXRlU3RhdGUgb24gV2luZG93cy4KKyAgICAgICAgKENvcmVJUEM6OkNvbm5lY3Rpb246 Ok1lc3NhZ2U6Ok1lc3NhZ2UpOiBBZGRlZCB0aGlzIGRlZmF1bHQKKyAgICAgICAgY29uc3RydWN0 b3IuCisKKyAgICAgICAgKiBQbGF0Zm9ybS9Db3JlSVBDL01lc3NhZ2VJRC5oOgorICAgICAgICAo Q29yZUlQQzo6TWVzc2FnZUlEOjpNZXNzYWdlSUQpOiBNYWRlIHRoZSBkZWZhdWx0IGNvbnN0cnVj dG9yIHB1YmxpYworICAgICAgICBmb3IgTWVzc2FnZSdzIGJlbmVmaXQuCisKKyAgICAgICAgKiBQ bGF0Zm9ybS9Db3JlSVBDL21hYy9Db25uZWN0aW9uTWFjLmNwcDoKKyAgICAgICAgKENvcmVJUEM6 OkNvbm5lY3Rpb246OnBsYXRmb3JtQ2FuU2VuZE91dGdvaW5nTWVzc2FnZXMpOiBBZGRlZC4gQWx3 YXlzCisgICAgICAgIHJldHVybnMgdHJ1ZS4KKyAgICAgICAgKENvcmVJUEM6OkNvbm5lY3Rpb246 OnNlbmRPdXRnb2luZ01lc3NhZ2UpOiBDaGFuZ2VkIHRvIHJldHVybiBhCisgICAgICAgIGJvb2xl YW4gaW5kaWNhdGluZyB3aGV0aGVyIG1vcmUgbWVzc2FnZXMgY2FuIGJlIHNlbnQgYXQgdGhpcyB0 aW1lLgorCisgICAgICAgICogUGxhdGZvcm0vQ29yZUlQQy9xdC9Db25uZWN0aW9uUXQuY3BwOgor ICAgICAgICAoQ29yZUlQQzo6Q29ubmVjdGlvbjo6cGxhdGZvcm1DYW5TZW5kT3V0Z29pbmdNZXNz YWdlcyk6IEFkZGVkLiBSZXR1cm5zCisgICAgICAgIHRydWUgaWYgd2UgaGF2ZSBhIHNvY2tldC4K KyAgICAgICAgKENvcmVJUEM6OkNvbm5lY3Rpb246OnNlbmRPdXRnb2luZ01lc3NhZ2UpOiBDaGFu Z2VkIGEgbnVsbC1jaGVjayBvZgorICAgICAgICBtX3NvY2tldCB0byBhbiBhc3NlcnRpb24gc2lu Y2UgaXQgc2hvdWxkIGJlIGNoZWNrZWQgZm9yIG51bGwgaW4KKyAgICAgICAgcGxhdGZvcm1DYW5T ZW5kT3V0Z29pbmdNZXNzYWdlcy4gQ2hhbmdlZCB0byByZXR1cm4gYSBib29sZWFuCisgICAgICAg IGluZGljYXRpbmcgd2hldGhlciBtb3JlIG1lc3NhZ2VzIGNhbiBiZSBzZW50IGF0IHRoaXMgdGlt ZS4KKworICAgICAgICAqIFBsYXRmb3JtL0NvcmVJUEMvd2luL0Nvbm5lY3Rpb25XaW4uY3BwOgor ICAgICAgICAoQ29yZUlQQzo6Q29ubmVjdGlvbjo6cGxhdGZvcm1Jbml0aWFsaXplKTogQWRkZWQg aW5pdGlhbGl6YXRpb24gb2YKKyAgICAgICAgbV93cml0ZVN0YXRlLgorICAgICAgICAoQ29yZUlQ Qzo6Q29ubmVjdGlvbjo6cGxhdGZvcm1JbnZhbGlkYXRlKTogQ2xvc2UgbV93cml0ZVN0YXRlJ3Mg ZXZlbnQKKyAgICAgICAgaGFuZGxlLgorICAgICAgICAoQ29yZUlQQzo6Q29ubmVjdGlvbjo6d3Jp dGVFdmVudEhhbmRsZXIpOiBBZGRlZC4gQ2hlY2tzIGlmIHRoZSBwZW5kaW5nCisgICAgICAgIHdy aXRlIGhhcyBjb21wbGV0ZWQsIGNsZWFucyB1cCBvdXIgcGVuZGluZyB3cml0ZSBzdGF0ZSwgYW5k IHNlbmRzIGFueQorICAgICAgICByZW1haW5pbmcgbWVzc2FnZXMuCisgICAgICAgIChDb3JlSVBD OjpDb25uZWN0aW9uOjpvcGVuKTogUmVnaXN0ZXIgb3VyIHdyaXRlIGV2ZW50IHdpdGggdGhlCisg ICAgICAgIFdvcmtRdWV1ZSBzbyB0aGF0IHdyaXRlRXZlbnRIYW5kbGVyIHdpbGwgYmUgY2FsbGVk IHdoZW4gdGhlIGV2ZW50IGlzCisgICAgICAgIHNpZ25hbGVkLgorICAgICAgICAoQ29yZUlQQzo6 Q29ubmVjdGlvbjo6cGxhdGZvcm1DYW5TZW5kT3V0Z29pbmdNZXNzYWdlcyk6IEFkZGVkLiBXZSBj YW4KKyAgICAgICAgb25seSBzZW5kIG1lc3NhZ2VzIGlmIHRoZXJlIGlzbid0IGEgd3JpdGUgcGVu ZGluZy4KKyAgICAgICAgKENvcmVJUEM6OkNvbm5lY3Rpb246OnNlbmRPdXRnb2luZ01lc3NhZ2Up OiBDaGFuZ2VkIHRvIHJldHVybiBhCisgICAgICAgIGJvb2xlYW4gaW5kaWNhdGluZyB3aGV0aGVy IG1vcmUgbWVzc2FnZXMgY2FuIGJlIHNlbnQgYXQgdGhpcyB0aW1lLiBXZQorICAgICAgICBub3cg cGFzcyBtX3dyaXRlU3RhdGUgdG8gOjpXcml0ZUZpbGUgaW5zdGVhZCBvZiBhbiBlbXB0eSBPVkVS TEFQUEVECisgICAgICAgIHN0cnVjdCBzbyB0aGF0IG91ciB3cml0ZSBldmVudCB3aWxsIGJlIHNp Z25hbGVkIHdoZW4gdGhlIHdyaXRlCisgICAgICAgIGNvbXBsZXRlcy4gV2UgYWxzbyBubyBsb25n ZXIgcGFzcyBhIHBvaW50ZXIgdG8gcmVjZWl2ZSBob3cgbWFueSBieXRlcworICAgICAgICB3ZXJl IHdyaXR0ZW4sIGFzIHJlY29tbWVuZGVkIGJ5IE1TRE4uIElmIDo6V3JpdGVGaWxlIGZhaWxzIHdp dGgKKyAgICAgICAgRVJST1JfSU9fUEVORElORywgd2Ugc2F2ZSB0aGUgQXJndW1lbnRFbmNvZGVy IGZvciB0aGlzIG1lc3NhZ2UgYW5kCisgICAgICAgIHJldHVybiBmYWxzZSB0byBpbmRpY2F0ZSB0 aGF0IG5vIG1vcmUgbWVzc2FnZXMgY2FuIGJlIHNlbnQgYXQgdGhpcworICAgICAgICB0aW1lLgor CisyMDEwLTA3LTI4ICBBZGFtIFJvYmVuICA8YXJvYmVuQGFwcGxlLmNvbT4KKwogICAgICAgICBT dG9wIGxlYWtpbmcgQ29ubmVjdGlvbjo6bV9yZWFkU3RhdGUuaEV2ZW50IG9uIFdpbmRvd3MKIAog ICAgICAgICBGaXhlcyA8aHR0cDovL3dlYmtpdC5vcmcvYi80MzEyOT4gQ29yZUlQQzo6Q29ubmVj dGlvbiBsZWFrcyBpdHMgcmVhZApkaWZmIC0tZ2l0IGEvV2ViS2l0Mi9QbGF0Zm9ybS9Db3JlSVBD L0Nvbm5lY3Rpb24uY3BwIGIvV2ViS2l0Mi9QbGF0Zm9ybS9Db3JlSVBDL0Nvbm5lY3Rpb24uY3Bw CmluZGV4IDAyODM3NmY2ZGMzNTgzMmZiNmVlYmNmNzhkMjUxYzg5NWFlMzI3ZDUuLmUxZDAwOWVj ODQxMjU2ZTNiOGQ5NTgzMzUwYzJhNjFjM2ZhZmRjOGQgMTAwNjQ0Ci0tLSBhL1dlYktpdDIvUGxh dGZvcm0vQ29yZUlQQy9Db25uZWN0aW9uLmNwcAorKysgYi9XZWJLaXQyL1BsYXRmb3JtL0NvcmVJ UEMvQ29ubmVjdGlvbi5jcHAKQEAgLTIwNywyMSArMjA3LDI4IEBAIHZvaWQgQ29ubmVjdGlvbjo6 ZGlzcGF0Y2hDb25uZWN0aW9uRGlkQ2xvc2UoKQogICAgIG1fY2xpZW50ID0gMDsKIH0KIAorYm9v bCBDb25uZWN0aW9uOjpjYW5TZW5kT3V0Z29pbmdNZXNzYWdlcygpIGNvbnN0Cit7CisgICAgcmV0 dXJuIG1faXNDb25uZWN0ZWQgJiYgcGxhdGZvcm1DYW5TZW5kT3V0Z29pbmdNZXNzYWdlcygpOwor fQorCiB2b2lkIENvbm5lY3Rpb246OnNlbmRPdXRnb2luZ01lc3NhZ2VzKCkKIHsKLSAgICBpZiAo IW1faXNDb25uZWN0ZWQpCisgICAgaWYgKCFjYW5TZW5kT3V0Z29pbmdNZXNzYWdlcygpKQogICAg ICAgICByZXR1cm47CiAKLSAgICBWZWN0b3I8T3V0Z29pbmdNZXNzYWdlPiBvdXRnb2luZ01lc3Nh Z2VzOworICAgIHdoaWxlICh0cnVlKSB7CisgICAgICAgIE91dGdvaW5nTWVzc2FnZSBtZXNzYWdl OworICAgICAgICB7CisgICAgICAgICAgICBNdXRleExvY2tlciBsb2NrZXIobV9vdXRnb2luZ01l c3NhZ2VzTG9jayk7CisgICAgICAgICAgICBpZiAobV9vdXRnb2luZ01lc3NhZ2VzLmlzRW1wdHko KSkKKyAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgIG1lc3NhZ2UgPSBtX291dGdv aW5nTWVzc2FnZXMudGFrZUZpcnN0KCk7CisgICAgICAgIH0KIAotICAgIHsKLSAgICAgICAgTXV0 ZXhMb2NrZXIgbG9ja2VyKG1fb3V0Z29pbmdNZXNzYWdlc0xvY2spOwotICAgICAgICBtX291dGdv aW5nTWVzc2FnZXMuc3dhcChvdXRnb2luZ01lc3NhZ2VzKTsKKyAgICAgICAgaWYgKCFzZW5kT3V0 Z29pbmdNZXNzYWdlKG1lc3NhZ2UubWVzc2FnZUlEKCksIGFkb3B0UHRyKG1lc3NhZ2UuYXJndW1l bnRzKCkpKSkKKyAgICAgICAgICAgIGJyZWFrOwogICAgIH0KLQotICAgIC8vIFNlbmQgbWVzc2Fn ZXMuCi0gICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBvdXRnb2luZ01lc3NhZ2VzLnNpemUoKTsg KytpKQotICAgICAgICBzZW5kT3V0Z29pbmdNZXNzYWdlKG91dGdvaW5nTWVzc2FnZXNbaV0ubWVz c2FnZUlEKCksIGFkb3B0UHRyKG91dGdvaW5nTWVzc2FnZXNbaV0uYXJndW1lbnRzKCkpKTsKIH0K IAogdm9pZCBDb25uZWN0aW9uOjpkaXNwYXRjaE1lc3NhZ2VzKCkKZGlmZiAtLWdpdCBhL1dlYktp dDIvUGxhdGZvcm0vQ29yZUlQQy9Db25uZWN0aW9uLmggYi9XZWJLaXQyL1BsYXRmb3JtL0NvcmVJ UEMvQ29ubmVjdGlvbi5oCmluZGV4IGVhY2U2ZTk5N2JhNDUxM2RmZDI1ODkwNzJlOGRjYWEwOWE0 ZjJhMTEuLjNkY2Q3NjNhYWJhOGMxODZmYTYzNDIxNzY2NWEwMTYwZTJkYjZlNjYgMTAwNjQ0Ci0t LSBhL1dlYktpdDIvUGxhdGZvcm0vQ29yZUlQQy9Db25uZWN0aW9uLmgKKysrIGIvV2ViS2l0Mi9Q bGF0Zm9ybS9Db3JlSVBDL0Nvbm5lY3Rpb24uaApAQCAtOTIsNiArOTIsMTEgQEAgcHVibGljOgog cHJpdmF0ZToKICAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBUPiBjbGFzcyBNZXNzYWdlIHsKICAgICBw dWJsaWM6CisgICAgICAgIE1lc3NhZ2UoKQorICAgICAgICAgICAgOiBtX2FyZ3VtZW50cygwKQor ICAgICAgICB7CisgICAgICAgIH0KKwogICAgICAgICBNZXNzYWdlKE1lc3NhZ2VJRCBtZXNzYWdl SUQsIFBhc3NPd25QdHI8VD4gYXJndW1lbnRzKQogICAgICAgICAgICAgOiBtX21lc3NhZ2VJRCht ZXNzYWdlSUQpCiAgICAgICAgICAgICAsIG1fYXJndW1lbnRzKGFyZ3VtZW50cy5sZWFrUHRyKCkp CkBAIC0xMjYsOCArMTMxLDEwIEBAIHByaXZhdGU6CiAgICAgCiAgICAgLy8gQ2FsbGVkIG9uIHRo ZSBjb25uZWN0aW9uIHdvcmsgcXVldWUuCiAgICAgdm9pZCBwcm9jZXNzSW5jb21pbmdNZXNzYWdl KE1lc3NhZ2VJRCwgUGFzc093blB0cjxBcmd1bWVudERlY29kZXI+KTsKKyAgICBib29sIGNhblNl bmRPdXRnb2luZ01lc3NhZ2VzKCkgY29uc3Q7CisgICAgYm9vbCBwbGF0Zm9ybUNhblNlbmRPdXRn b2luZ01lc3NhZ2VzKCkgY29uc3Q7CiAgICAgdm9pZCBzZW5kT3V0Z29pbmdNZXNzYWdlcygpOwot ICAgIHZvaWQgc2VuZE91dGdvaW5nTWVzc2FnZShNZXNzYWdlSUQsIFBhc3NPd25QdHI8QXJndW1l bnRFbmNvZGVyPik7CisgICAgYm9vbCBzZW5kT3V0Z29pbmdNZXNzYWdlKE1lc3NhZ2VJRCwgUGFz c093blB0cjxBcmd1bWVudEVuY29kZXI+KTsKICAgICB2b2lkIGNvbm5lY3Rpb25EaWRDbG9zZSgp OwogICAgIAogICAgIC8vIENhbGxlZCBvbiB0aGUgbGlzdGVuZXIgdGhyZWFkLgpAQCAtMTUwLDcg KzE1Nyw3IEBAIHByaXZhdGU6CiAKICAgICAvLyBPdXRnb2luZyBtZXNzYWdlcy4KICAgICBNdXRl eCBtX291dGdvaW5nTWVzc2FnZXNMb2NrOwotICAgIFZlY3RvcjxPdXRnb2luZ01lc3NhZ2U+IG1f b3V0Z29pbmdNZXNzYWdlczsKKyAgICBEZXF1ZTxPdXRnb2luZ01lc3NhZ2U+IG1fb3V0Z29pbmdN ZXNzYWdlczsKICAgICAKICAgICBUaHJlYWRDb25kaXRpb24gbV93YWl0Rm9yTWVzc2FnZUNvbmRp dGlvbjsKICAgICBNdXRleCBtX3dhaXRGb3JNZXNzYWdlTXV0ZXg7CkBAIC0xNjYsOSArMTczLDEy IEBAIHByaXZhdGU6CiAjZWxpZiBQTEFURk9STShXSU4pCiAgICAgLy8gQ2FsbGVkIG9uIHRoZSBj b25uZWN0aW9uIHF1ZXVlLgogICAgIHZvaWQgcmVhZEV2ZW50SGFuZGxlcigpOworICAgIHZvaWQg d3JpdGVFdmVudEhhbmRsZXIoKTsKIAogICAgIFZlY3Rvcjx1aW50OF90PiBtX3JlYWRCdWZmZXI7 CiAgICAgT1ZFUkxBUFBFRCBtX3JlYWRTdGF0ZTsKKyAgICBPd25QdHI8QXJndW1lbnRFbmNvZGVy PiBtX3BlbmRpbmdXcml0ZUFyZ3VtZW50czsKKyAgICBPVkVSTEFQUEVEIG1fd3JpdGVTdGF0ZTsK ICAgICBIQU5ETEUgbV9jb25uZWN0aW9uUGlwZTsKICNlbGlmIFBMQVRGT1JNKFFUKQogICAgIC8v IENhbGxlZCBvbiB0aGUgY29ubmVjdGlvbiBxdWV1ZS4KZGlmZiAtLWdpdCBhL1dlYktpdDIvUGxh dGZvcm0vQ29yZUlQQy9NZXNzYWdlSUQuaCBiL1dlYktpdDIvUGxhdGZvcm0vQ29yZUlQQy9NZXNz YWdlSUQuaAppbmRleCA5YzdhOGZmZGIyNjQ3ZDk0NDE5NDExNjU3N2FkMTg2ODU5MWFlYmFmLi4z ZTRiZDI2OTY0ZmI4YWY4ODVjOGI0MWE2NzQwOTA0NmNlZjUyZDNkIDEwMDY0NAotLS0gYS9XZWJL aXQyL1BsYXRmb3JtL0NvcmVJUEMvTWVzc2FnZUlELmgKKysrIGIvV2ViS2l0Mi9QbGF0Zm9ybS9D b3JlSVBDL01lc3NhZ2VJRC5oCkBAIC02Nyw2ICs2NywxMSBAQCBwdWJsaWM6CiAgICAgICAgIFN5 bmNNZXNzYWdlID0gMSA8PCAwLAogICAgIH07CiAKKyAgICBNZXNzYWdlSUQoKQorICAgICAgICA6 IG1fbWVzc2FnZUlEKDApCisgICAgeworICAgIH0KKwogICAgIHRlbXBsYXRlIDx0eXBlbmFtZSBF bnVtVHlwZT4KICAgICBleHBsaWNpdCBNZXNzYWdlSUQoRW51bVR5cGUgbWVzc2FnZUtpbmQsIHVu c2lnbmVkIGNoYXIgZmxhZ3MgPSAwKQogICAgICAgICA6IG1fbWVzc2FnZUlEKHN0cmlwTW9zdFNp Z25pZmljYW50Qml0KGZsYWdzIDw8IDI0IHwgKE1lc3NhZ2VLaW5kVHJhaXRzPEVudW1UeXBlPjo6 bWVzc2FnZUNsYXNzKSA8PCAxNiB8IG1lc3NhZ2VLaW5kKSkKQEAgLTExMywxMSArMTE4LDYgQEAg cHJpdmF0ZToKICAgICB1bnNpZ25lZCBjaGFyIGdldEZsYWdzKCkgY29uc3QgeyByZXR1cm4gKG1f bWVzc2FnZUlEICYgMHhmZjAwMDAwMCkgPj4gMjQ7IH0KICAgICB1bnNpZ25lZCBjaGFyIGdldENs YXNzKCkgY29uc3QgeyByZXR1cm4gKG1fbWVzc2FnZUlEICYgMHgwMGZmMDAwMCkgPj4gMTY7IH0K IAotICAgIE1lc3NhZ2VJRCgpCi0gICAgICAgIDogbV9tZXNzYWdlSUQoMCkKLSAgICB7Ci0gICAg fQotCiAgICAgdW5zaWduZWQgbV9tZXNzYWdlSUQ7CiB9OwogCmRpZmYgLS1naXQgYS9XZWJLaXQy L1BsYXRmb3JtL0NvcmVJUEMvbWFjL0Nvbm5lY3Rpb25NYWMuY3BwIGIvV2ViS2l0Mi9QbGF0Zm9y bS9Db3JlSVBDL21hYy9Db25uZWN0aW9uTWFjLmNwcAppbmRleCA5YjlkZmQ5YmFlNjA1NDIzYzZm ODNkNDAwMGZiZWQ5ZmZjN2IxMmUxLi5lZjUzNzY0OTIzMDg3OWI5YTU0NDhiNzFkZmMzZDIxODQw NzFjMDk1IDEwMDY0NAotLS0gYS9XZWJLaXQyL1BsYXRmb3JtL0NvcmVJUEMvbWFjL0Nvbm5lY3Rp b25NYWMuY3BwCisrKyBiL1dlYktpdDIvUGxhdGZvcm0vQ29yZUlQQy9tYWMvQ29ubmVjdGlvbk1h Yy5jcHAKQEAgLTExNSw3ICsxMTUsMTIgQEAgc3RhdGljIGlubGluZSBzaXplX3QgbWFjaE1lc3Nh Z2VTaXplKHNpemVfdCBib2R5U2l6ZSwgc2l6ZV90IG51bWJlck9mUG9ydERlc2NyaXAKICAgICBy ZXR1cm4gcm91bmRfbXNnKHNpemUpOwogfQogCi12b2lkIENvbm5lY3Rpb246OnNlbmRPdXRnb2lu Z01lc3NhZ2UoTWVzc2FnZUlEIG1lc3NhZ2VJRCwgUGFzc093blB0cjxBcmd1bWVudEVuY29kZXI+ IGFyZ3VtZW50cykKK2Jvb2wgQ29ubmVjdGlvbjo6cGxhdGZvcm1DYW5TZW5kT3V0Z29pbmdNZXNz YWdlcygpIGNvbnN0Cit7CisgICAgcmV0dXJuIHRydWU7Cit9CisKK2Jvb2wgQ29ubmVjdGlvbjo6 c2VuZE91dGdvaW5nTWVzc2FnZShNZXNzYWdlSUQgbWVzc2FnZUlELCBQYXNzT3duUHRyPEFyZ3Vt ZW50RW5jb2Rlcj4gYXJndW1lbnRzKQogewogICAgIFZlY3RvcjxBdHRhY2htZW50PiBhdHRhY2ht ZW50cyA9IGFyZ3VtZW50cy0+cmVsZWFzZUF0dGFjaG1lbnRzKCk7CiAgICAgCkBAIC0xOTksOCAr MjA0LDkgQEAgdm9pZCBDb25uZWN0aW9uOjpzZW5kT3V0Z29pbmdNZXNzYWdlKE1lc3NhZ2VJRCBt ZXNzYWdlSUQsIFBhc3NPd25QdHI8QXJndW1lbnRFbmMKICAgICBrZXJuX3JldHVybl90IGtyID0g bWFjaF9tc2coaGVhZGVyLCBNQUNIX1NFTkRfTVNHLCBtZXNzYWdlU2l6ZSwgMCwgTUFDSF9QT1JU X05VTEwsIE1BQ0hfTVNHX1RJTUVPVVRfTk9ORSwgTUFDSF9QT1JUX05VTEwpOwogICAgIGlmIChr ciAhPSBLRVJOX1NVQ0NFU1MpIHsKICAgICAgICAgLy8gRklYTUU6IFdoYXQgc2hvdWxkIHdlIGRv IGhlcmU/Ci0gICAgICAgIHJldHVybjsKICAgICB9CisKKyAgICByZXR1cm4gdHJ1ZTsKIH0KIAog dm9pZCBDb25uZWN0aW9uOjppbml0aWFsaXplRGVhZE5hbWVTb3VyY2UoKQpkaWZmIC0tZ2l0IGEv V2ViS2l0Mi9QbGF0Zm9ybS9Db3JlSVBDL3F0L0Nvbm5lY3Rpb25RdC5jcHAgYi9XZWJLaXQyL1Bs YXRmb3JtL0NvcmVJUEMvcXQvQ29ubmVjdGlvblF0LmNwcAppbmRleCAyZWUyMGJjNmUxMmVmMTY1 ZmJkYWEwMzAzNzZiZGU5N2ZjMDBlYzc2Li42OTQ0M2U5OWQ0MGVlNGVjNmZlZTQ5NjEyYTE1ODUz NmU4NzM5MDhkIDEwMDY0NAotLS0gYS9XZWJLaXQyL1BsYXRmb3JtL0NvcmVJUEMvcXQvQ29ubmVj dGlvblF0LmNwcAorKysgYi9XZWJLaXQyL1BsYXRmb3JtL0NvcmVJUEMvcXQvQ29ubmVjdGlvblF0 LmNwcApAQCAtMTA0LDEwICsxMDQsMTQgQEAgYm9vbCBDb25uZWN0aW9uOjpvcGVuKCkKICAgICBy ZXR1cm4gbV9pc0Nvbm5lY3RlZDsKIH0KIAotdm9pZCBDb25uZWN0aW9uOjpzZW5kT3V0Z29pbmdN ZXNzYWdlKE1lc3NhZ2VJRCBtZXNzYWdlSUQsIFBhc3NPd25QdHI8QXJndW1lbnRFbmNvZGVyPiBh cmd1bWVudHMpCitib29sIENvbm5lY3Rpb246OnBsYXRmb3JtQ2FuU2VuZE91dGdvaW5nTWVzc2Fn ZXMoKSBjb25zdAogewotICAgIGlmICghbV9zb2NrZXQpCi0gICAgICAgIHJldHVybjsKKyAgICBy ZXR1cm4gbV9zb2NrZXQ7Cit9CisKK2Jvb2wgQ29ubmVjdGlvbjo6c2VuZE91dGdvaW5nTWVzc2Fn ZShNZXNzYWdlSUQgbWVzc2FnZUlELCBQYXNzT3duUHRyPEFyZ3VtZW50RW5jb2Rlcj4gYXJndW1l bnRzKQoreworICAgIEFTU0VSVChtX3NvY2tldCk7CiAKICAgICAvLyBXZSBwdXQgdGhlIG1lc3Nh Z2UgSUQgbGFzdC4KICAgICBhcmd1bWVudHMtPmVuY29kZVVJbnQzMihtZXNzYWdlSUQudG9JbnQo KSk7CkBAIC0xMjEsNiArMTI1LDcgQEAgdm9pZCBDb25uZWN0aW9uOjpzZW5kT3V0Z29pbmdNZXNz YWdlKE1lc3NhZ2VJRCBtZXNzYWdlSUQsIFBhc3NPd25QdHI8QXJndW1lbnRFbmMKICAgICBxaW50 NjQgYnl0ZXNXcml0dGVuID0gbV9zb2NrZXQtPndyaXRlKHJlaW50ZXJwcmV0X2Nhc3Q8Y2hhcio+ KGFyZ3VtZW50cy0+YnVmZmVyKCkpLCBhcmd1bWVudHMtPmJ1ZmZlclNpemUoKSk7CiAKICAgICBB U1NFUlQoYnl0ZXNXcml0dGVuID09IGFyZ3VtZW50cy0+YnVmZmVyU2l6ZSgpKTsKKyAgICByZXR1 cm4gdHJ1ZTsKIH0KIAogfSAvLyBuYW1lc3BhY2UgQ29yZUlQQwpkaWZmIC0tZ2l0IGEvV2ViS2l0 Mi9QbGF0Zm9ybS9Db3JlSVBDL3dpbi9Db25uZWN0aW9uV2luLmNwcCBiL1dlYktpdDIvUGxhdGZv cm0vQ29yZUlQQy93aW4vQ29ubmVjdGlvbldpbi5jcHAKaW5kZXggNDdiNmIzMWE5MTE1ZTQxZDM3 MTQwZDlkNjJiZmY5NGU1NWUwZTg0Yy4uNzMxNTlhZWM2OTFlM2QwODQzZDhiYzUyODc1MWUyZTZm YmNiNmU2MiAxMDA2NDQKLS0tIGEvV2ViS2l0Mi9QbGF0Zm9ybS9Db3JlSVBDL3dpbi9Db25uZWN0 aW9uV2luLmNwcAorKysgYi9XZWJLaXQyL1BsYXRmb3JtL0NvcmVJUEMvd2luL0Nvbm5lY3Rpb25X aW4uY3BwCkBAIC04Miw3ICs4MiwxMCBAQCBib29sIENvbm5lY3Rpb246OmNyZWF0ZVNlcnZlckFu ZENsaWVudElkZW50aWZpZXJzKEhBTkRMRSYgc2VydmVySWRlbnRpZmllciwgSEFORAogdm9pZCBD b25uZWN0aW9uOjpwbGF0Zm9ybUluaXRpYWxpemUoSWRlbnRpZmllciBpZGVudGlmaWVyKQogewog ICAgIG1lbXNldCgmbV9yZWFkU3RhdGUsIDAsIHNpemVvZihtX3JlYWRTdGF0ZSkpOwotICAgIG1f cmVhZFN0YXRlLmhFdmVudCA9IDo6Q3JlYXRlRXZlbnRXKDAsIGZhbHNlLCBmYWxzZSwgMCk7Cisg ICAgbV9yZWFkU3RhdGUuaEV2ZW50ID0gOjpDcmVhdGVFdmVudFcoMCwgRkFMU0UsIEZBTFNFLCAw KTsKKworICAgIG1lbXNldCgmbV93cml0ZVN0YXRlLCAwLCBzaXplb2YobV93cml0ZVN0YXRlKSk7 CisgICAgbV93cml0ZVN0YXRlLmhFdmVudCA9IDo6Q3JlYXRlRXZlbnRXKDAsIEZBTFNFLCBGQUxT RSwgMCk7CiAKICAgICBtX2Nvbm5lY3Rpb25QaXBlID0gaWRlbnRpZmllcjsKIH0KQEAgLTk3LDYg KzEwMCw5IEBAIHZvaWQgQ29ubmVjdGlvbjo6cGxhdGZvcm1JbnZhbGlkYXRlKCkKICAgICA6OkNs b3NlSGFuZGxlKG1fcmVhZFN0YXRlLmhFdmVudCk7CiAgICAgbV9yZWFkU3RhdGUuaEV2ZW50ID0g MDsKIAorICAgIDo6Q2xvc2VIYW5kbGUobV93cml0ZVN0YXRlLmhFdmVudCk7CisgICAgbV93cml0 ZVN0YXRlLmhFdmVudCA9IDA7CisKICAgICA6OkNsb3NlSGFuZGxlKG1fY29ubmVjdGlvblBpcGUp OwogICAgIG1fY29ubmVjdGlvblBpcGUgPSBJTlZBTElEX0hBTkRMRV9WQUxVRTsKIH0KQEAgLTIy NywxMCArMjMzLDI3IEBAIHZvaWQgQ29ubmVjdGlvbjo6cmVhZEV2ZW50SGFuZGxlcigpCiAgICAg fQogfQogCit2b2lkIENvbm5lY3Rpb246OndyaXRlRXZlbnRIYW5kbGVyKCkKK3sKKyAgICBEV09S RCBudW1iZXJPZkJ5dGVzV3JpdHRlbiA9IDA7CisgICAgaWYgKCE6OkdldE92ZXJsYXBwZWRSZXN1 bHQobV9jb25uZWN0aW9uUGlwZSwgJm1fd3JpdGVTdGF0ZSwgJm51bWJlck9mQnl0ZXNXcml0dGVu LCBGQUxTRSkpIHsKKyAgICAgICAgRFdPUkQgZXJyb3IgPSA6OkdldExhc3RFcnJvcigpOworICAg ICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICB9CisKKyAgICAvLyBUaGUgcGVuZGluZyB3 cml0ZSBoYXMgZmluaXNoZWQsIHNvIHdlIGFyZSBub3cgZG9uZSB3aXRoIGl0cyBhcmd1bWVudHMu IENsZWFyaW5nIHRoaXMgbWVtYmVyCisgICAgLy8gd2lsbCBhbGxvdyB1cyB0byBzZW5kIG1lc3Nh Z2VzIGFnYWluLgorICAgIG1fcGVuZGluZ1dyaXRlQXJndW1lbnRzID0gMDsKKworICAgIC8vIE5v dyB0aGF0IHRoZSBwZW5kaW5nIHdyaXRlIGhhcyBmaW5pc2hlZCwgd2UgY2FuIHRyeSB0byBzZW5k IGEgbmV3IG1lc3NhZ2UuCisgICAgc2VuZE91dGdvaW5nTWVzc2FnZXMoKTsKK30KKwogYm9vbCBD b25uZWN0aW9uOjpvcGVuKCkKIHsKLSAgICAvLyBTdGFydCBsaXN0ZW5pbmcgZm9yIHJlYWQgc3Rh dGUgZXZlbnRzLgorICAgIC8vIFN0YXJ0IGxpc3RlbmluZyBmb3IgcmVhZCBhbmQgd3JpdGUgc3Rh dGUgZXZlbnRzLgogICAgIG1fY29ubmVjdGlvblF1ZXVlLnJlZ2lzdGVySGFuZGxlKG1fcmVhZFN0 YXRlLmhFdmVudCwgV29ya0l0ZW06OmNyZWF0ZSh0aGlzLCAmQ29ubmVjdGlvbjo6cmVhZEV2ZW50 SGFuZGxlcikpOworICAgIG1fY29ubmVjdGlvblF1ZXVlLnJlZ2lzdGVySGFuZGxlKG1fd3JpdGVT dGF0ZS5oRXZlbnQsIFdvcmtJdGVtOjpjcmVhdGUodGhpcywgJkNvbm5lY3Rpb246OndyaXRlRXZl bnRIYW5kbGVyKSk7CiAKICAgICBpZiAobV9pc1NlcnZlcikgewogICAgICAgICAvLyBXYWl0IGZv ciBhIGNvbm5lY3Rpb24uCkBAIC0yNjEsMzEgKzI4NCw0NCBAQCBib29sIENvbm5lY3Rpb246Om9w ZW4oKQogICAgIHJldHVybiB0cnVlOwogfQogCi12b2lkIENvbm5lY3Rpb246OnNlbmRPdXRnb2lu Z01lc3NhZ2UoTWVzc2FnZUlEIG1lc3NhZ2VJRCwgUGFzc093blB0cjxBcmd1bWVudEVuY29kZXI+ IGFyZ3VtZW50cykKK2Jvb2wgQ29ubmVjdGlvbjo6cGxhdGZvcm1DYW5TZW5kT3V0Z29pbmdNZXNz YWdlcygpIGNvbnN0CiB7CisgICAgLy8gV2Ugb25seSBhbGxvdyBzZW5kaW5nIG9uZSBhc3luY2hy b25vdXMgbWVzc2FnZSBhdCBhIHRpbWUuIElmIHdlIHdhbnRlZCB0byBzZW5kIG1vcmUgdGhhbiBv bmUKKyAgICAvLyBhdCBvbmNlLCB3ZSdkIGhhdmUgdG8gdXNlIG11bHRpcGxlIE9WRVJMQVBQRUQg c3RydWN0dXJlcyBhbmQgaG9sZCBvbnRvIG11bHRpcGxlIHBlbmRpbmcKKyAgICAvLyBBcmd1bWVu dEVuY29kZXJzIChvbmUgb2YgZWFjaCBmb3IgZWFjaCBzaW11bHRhbmVvdXMgYXN5bmNocm9ub3Vz IG1lc3NhZ2UpLgorICAgIHJldHVybiAhbV9wZW5kaW5nV3JpdGVBcmd1bWVudHM7Cit9CisKK2Jv b2wgQ29ubmVjdGlvbjo6c2VuZE91dGdvaW5nTWVzc2FnZShNZXNzYWdlSUQgbWVzc2FnZUlELCBQ YXNzT3duUHRyPEFyZ3VtZW50RW5jb2Rlcj4gYXJndW1lbnRzKQoreworICAgIEFTU0VSVCghbV9w ZW5kaW5nV3JpdGVBcmd1bWVudHMpOworCiAgICAgLy8gSnVzdCBiYWlsIGlmIHRoZSBoYW5kbGUg aGFzIGJlZW4gY2xvc2VkLgogICAgIGlmIChtX2Nvbm5lY3Rpb25QaXBlID09IElOVkFMSURfSEFO RExFX1ZBTFVFKQotICAgICAgICByZXR1cm47CisgICAgICAgIHJldHVybiBmYWxzZTsKIAogICAg IC8vIFdlIHB1dCB0aGUgbWVzc2FnZSBJRCBsYXN0LgogICAgIGFyZ3VtZW50cy0+ZW5jb2RlVUlu dDMyKG1lc3NhZ2VJRC50b0ludCgpKTsKIAogICAgIC8vIFdyaXRlIHRoZSBvdXRnb2luZyBtZXNz YWdlLgotICAgIE9WRVJMQVBQRUQgb3ZlcmxhcHBlZCA9IHsgMCB9OwogCi0gICAgRFdPUkQgYnl0 ZXNXcml0dGVuOwotICAgIGlmICg6OldyaXRlRmlsZShtX2Nvbm5lY3Rpb25QaXBlLCBhcmd1bWVu dHMtPmJ1ZmZlcigpLCBhcmd1bWVudHMtPmJ1ZmZlclNpemUoKSwgJmJ5dGVzV3JpdHRlbiwgJm92 ZXJsYXBwZWQpKSB7CisgICAgaWYgKDo6V3JpdGVGaWxlKG1fY29ubmVjdGlvblBpcGUsIGFyZ3Vt ZW50cy0+YnVmZmVyKCksIGFyZ3VtZW50cy0+YnVmZmVyU2l6ZSgpLCAwLCAmbV93cml0ZVN0YXRl KSkgewogICAgICAgICAvLyBXZSBzdWNjZXNzZnVsbHkgc2VudCB0aGlzIG1lc3NhZ2UuCi0gICAg ICAgIHJldHVybjsKKyAgICAgICAgcmV0dXJuIHRydWU7CiAgICAgfQogCiAgICAgRFdPUkQgZXJy b3IgPSA6OkdldExhc3RFcnJvcigpOwotICAgIGlmIChlcnJvciA9PSBFUlJPUl9JT19QRU5ESU5H KSB7Ci0gICAgICAgIC8vIFRoZSBtZXNzYWdlIHdpbGwgYmUgc2VudCBzb29uLgotICAgICAgICBy ZXR1cm47CisgICAgaWYgKGVycm9yICE9IEVSUk9SX0lPX1BFTkRJTkcpIHsKKyAgICAgICAgQVNT RVJUX05PVF9SRUFDSEVEKCk7CisgICAgICAgIHJldHVybiBmYWxzZTsKICAgICB9CiAKLSAgICBB U1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICAvLyBUaGUgbWVzc2FnZSB3aWxsIGJlIHNlbnQgc29v bi4gSG9sZCBvbnRvIHRoZSBhcmd1bWVudHMgc28gdGhhdCB0aGV5IHdvbid0IGJlIGRlc3Ryb3ll ZAorICAgIC8vIGJlZm9yZSB0aGUgd3JpdGUgY29tcGxldGVzLgorICAgIG1fcGVuZGluZ1dyaXRl QXJndW1lbnRzID0gYXJndW1lbnRzOworCisgICAgLy8gV2UgY2FuIG9ubHkgc2VuZCBvbmUgYXN5 bmNocm9ub3VzIG1lc3NhZ2UgYXQgYSB0aW1lIChzZWUgY29tbWVudCBpbiBwbGF0Zm9ybUNhblNl bmRPdXRnb2luZ01lc3NhZ2VzKS4KKyAgICByZXR1cm4gZmFsc2U7CiB9CiAKIH0gLy8gbmFtZXNw YWNlIENvcmVJUEMK