28795 2009-08-27 20:38:37 -0700 fast/workers/worker-lifecycle.html crashes intermittently on snowleopard 2009-08-31 16:42:05 -0700 1 1 1 Unclassified WebKit WebCore Misc. 528+ (Nightly build) PC OS X 10.5 RESOLVED FIXED P2 Normal --- 1 atwilson atwilson ap oliver oldest_to_newest 143283 0 atwilson 2009-08-27 20:38:37 -0700 The worker-lifecycle layout test crashes intermittently on snowleopard. The stderr shows: ASSERTION FAILED: !result (/Volumes/Data/WebKit-BuildSlave/snowleopard-intel-leaks/build/JavaScriptCore/wtf/ThreadingPthreads.cpp:248 void WTF::Mutex::lock()) pthread_mutex_lock() is returning an error - this seems to imply a deadlock of some kind, but I don't see any way for that to happen given the simple uses of mutexes in the worker code. 143297 1 ap 2009-08-27 22:14:58 -0700 > pthread_mutex_lock() is returning an error When I saw errors from this function, it usually meant that a garbage mutex object was passed in (likely because its containing object was already deallocated). 143394 2 atwilson 2009-08-28 09:46:58 -0700 I was able to repro this locally on Leopard (not snowleopard) by running the test in a tight loop - seems to happen every few hundred iterations. Debugging now. 143415 3 atwilson 2009-08-28 11:30:18 -0700 The race condition seems to be this: WorkerContext::close() invokes m_workerThread->stop(). This starts the process of shutting down the worker thread by calling runLoop.terminate(). Once the thread of execution unwinds and the runloop exits, the following actions occur: m_workerContext->clearScript(); // The below assignment will destroy the context, which will in turn notify messaging proxy. // We cannot let any objects survive past thread exit, because no other thread will run GC or otherwise destroy them. m_workerContext = 0; Note that we call clearScript() before freeing the workerContext - I'm not certain why, but I'm guessing it's to try to untangle some kind of circular reference. Now, while those steps are executing, imagine that the main thread decides to GC the Worker object (it can do this, because the WorkerThread went idle as part of shutting down). This invokes WorkerMessagingProxy::workerObjectDestroyed(): void WorkerMessagingProxy::workerObjectDestroyed() { m_workerObject = 0; if (m_workerThread) terminateWorkerContext(); else workerContextDestroyedInternal(); } Since the WorkerMessagingProxy doesn't know that the workerContext has been destroyed (hasn't happened yet), it happily invokes terminateWorkerContext() which invokes WorkerThread::stop() again. WorkerThread::stop() accesses the workerContext and WorkerScriptController to forbidExecution() (force the thread to exit), while those objects could be getting freed by the already-exiting thread, which generates this failure. 143419 4 atwilson 2009-08-28 11:35:51 -0700 Looks like only two pieces of WorkerThread are accessed cross-thread: 1) WorkerThread->runLoop() 2) WorkerThread->stop() Since runLoop is already thread safe, we're OK with accessing that across threads. WorkerThread::stop() currently grabs the m_threadCreationMutex while doing its work. I'm wondering if we should also grab that mutex while cleaning up after the run loop exits, to protect access to workerContext. I'll try that fix locally and see how it works. ap - what do you think? 143428 5 ap 2009-08-28 12:12:51 -0700 I think that WorkerContext.close() shouldn't close the worker directly - it should send this request to proxy, which should close the worker. All information about worker state should be current in proxy, workers themselves shouldn't have the freedom to stop. 143429 6 atwilson 2009-08-28 12:31:58 -0700 I don't think that's a viable solution. The semantics of WorkerGlobalScope::close() are such that no further async events (timers, message port messages, network requests, etc) should be processed after close() are processed. Routing close requests through the proxy would mean we'd have to jump through hoops to short-circuit any further event activity/generation. Possibly doable, but so much simpler to just call m_runLoop.terminate(). Also, forcing the parent to get involved has some nasty implications with nested SharedWorkers where the parent worker may not be around any more, although we probably address that by routing close requests through the repository instead of the parent worker object. What's the downside to allowing workers to shut themselves down (other than this bug, of course :)? 143433 7 ap 2009-08-28 12:55:00 -0700 See also: bug 25902 comment 3 (so, there was a race condition, after all!) I think this proves that the current solution is difficult to understand - the code smells wrong, but we couldn't find the bug even after detailed analysis, not until it was exposed by a test. Simplifying cross-thread communication by not letting worker contexts close without proxy consent should be much more maintainable long-term. 143499 8 38769 atwilson 2009-08-28 21:22:22 -0700 Created attachment 38769 proposed patch Per my earlier conversation with ap - we no longer invoke WorkerThread::stop() when WorkerContext::close() is called. Instead, the WorkerMessagingProxy and SharedWorkerProxy shutdown the thread themselves, to avoid race conditions with the thread shutting down while the main thread is still accessing it. 143500 9 38770 atwilson 2009-08-28 21:25:24 -0700 Created attachment 38770 patch with fix for typo in comment Had a typo in a comment so figured I'd fix it up. 143674 10 38770 ap 2009-08-31 10:43:56 -0700 Comment on attachment 38770 patch with fix for typo in comment + Error events should still be delivered even if the worker thread is closing. This sounds like something worth a comment in code, ideally with an explanation of why they should be delivered. Is this something covered by existing tests? + Also fixed problem where error events were not dispatched if error handlers were added via addEventListener(). Please add a test for this bug fix. void SharedWorkerProxy::close() { - ASSERT(!isClosing()); So, this function can now be called repeatedly. Is it OK to call m_thread->stop() twice? r=me on a condition there's a good answer to this last question. 143679 11 atwilson 2009-08-31 11:05:55 -0700 (In reply to comment #10) > (From update of attachment 38770 [details]) > + Error events should still be delivered even if the worker thread is > closing. > > This sounds like something worth a comment in code, ideally with an explanation > of why they should be delivered. Is this something covered by existing tests? Yes, it's covered by existing tests (worker_close.html), which is why I made this change (the tests started breaking once I routed WorkerContext::close() through the WorkerObjectProxy, because now the m_askToTerminate flag is set. I will add a comment, although it's weird to have a disembodied comment in the code about *why* you aren't introducing buggy behavior with unnecessary checks, which is why I put it in the ChangeLog instead :) > > + Also fixed problem where error events were not dispatched if error > handlers were added via addEventListener(). > > Please add a test for this bug fix. Will do. > > void SharedWorkerProxy::close() > { > - ASSERT(!isClosing()); > > So, this function can now be called repeatedly. Is it OK to call > m_thread->stop() twice? It is technically OK to call m_thread->stop() twice in this case (the case where it gets called twice is when the parent document closes while the worker thread is executing, then the worker thread calls WorkerContext::close(). The second call to m_thread->stop() would happen on the Worker thread itself, which is safe. However, this seems fragile so I'm going to make the following change to clean it up: 1) Make SharedWorkerProxy::close() private (should have been already). 2) Re-institute the ASSERT(!isClosing()) to SharedWorkerProxy::close(). 3) Add the following to workerContextClosed() to avoid calling close() on an already-closed worker: if (isClosing()) return; > > r=me on a condition there's a good answer to this last question. 143683 12 ap 2009-08-31 11:18:14 -0700 > I will add a comment, although it's weird to have a disembodied comment in the > code about *why* you aren't introducing buggy behavior with unnecessary checks, > which is why I put it in the ChangeLog instead :) This is a good way to think about it. But this change makes this version of performTask() different from MessageWorkerTask::performTask(), which can be confusing, and that was the reason for me to suggest having a comment in code. > However, this seems fragile so I'm going to make the following change to clean > it up: Sounds good to me. 143751 13 atwilson 2009-08-31 16:42:05 -0700 Committed as r47914. 38769 2009-08-28 21:22:22 -0700 2009-08-28 21:25:24 -0700 proposed patch x text/plain 9258 atwilson ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA3Njk3MzMxLi4xZTQ0ZjllIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAKKzIwMDktMDgt MjggIERyZXcgV2lsc29uICA8YXR3aWxzb25AZ29vZ2xlLmNvbT4KKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBmYXN0L3dvcmtlcnMvd29ya2VyLWxpZmVj eWNsZS5odG1sIGNyYXNoZXMgaW50ZXJtaXR0ZW50bHkgb24gc25vd2xlb3BhcmQKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI4Nzk1CisKKyAgICAgICAg UmVtb3ZlZCB3b3JrZXItbGlmZWN5Y2xlLmh0bWwgZnJvbSB0aGUgbGlzdCBvZiBTa2lwcGVkIHRl c3RzIHNpbmNlIGl0IG5vIGxvbmdlciBjcmFzaGVzLgorCisgICAgICAgICogcGxhdGZvcm0vbWFj LXNub3dsZW9wYXJkL1NraXBwZWQ6CisKIDIwMDktMDgtMjggIEphbiBNaWNoYWVsIEFsb256byAg PGptYWxvbnpvQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgR3VzdGF2byBOb3Jv bmhhLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFjLXNub3dsZW9wYXJkL1Nr aXBwZWQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMtc25vd2xlb3BhcmQvU2tpcHBlZAppbmRl eCAzZTUyYTllLi4xNDMyY2NmIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMt c25vd2xlb3BhcmQvU2tpcHBlZAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMtc25vd2xl b3BhcmQvU2tpcHBlZApAQCAtNDAsNiArNDAsMyBAQCBtZWRpYS9jb250cm9scy1kcmFnLXRpbWVi YXIuaHRtbAogCiAjPHJkYXI6Ly9wcm9ibGVtLzcxNDQ1ODM+IC0gSW50ZXJtaXR0ZW50IGZhaWx1 cmUKIHN2Zy9jc3MvZ2x5cGgtb3JpZW50YXRpb24tcm91bmRpbmctdGVzdC54aHRtbAotCi0jaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI4Nzk1IC0gZmFpbHVyZSBncmFi YmluZyBtdXRleCBsb2NrCi1mYXN0L3dvcmtlcnMvd29ya2VyLWxpZmVjeWNsZS5odG1sCmRpZmYg LS1naXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDg4MGFi ZGEuLjc0NTljY2IgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1dlYkNvcmUv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsNDAgQEAKKzIwMDktMDgtMjggIERyZXcgV2lsc29uICA8YXR3 aWxzb25AZ29vZ2xlLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICBmYXN0L3dvcmtlcnMvd29ya2VyLWxpZmVjeWNsZS5odG1sIGNyYXNoZXMgaW50 ZXJtaXR0ZW50bHkgb24gc25vd2xlb3BhcmQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTI4Nzk1CisKKyAgICAgICAgQ2hhbmdlZCBXb3JrZXJDb250ZXh0 OjpjbG9zZSgpIHRvIG5vIGxvbmdlciBzdG9wIHRoZSB3b3JrZXIgdGhyZWFkLgorICAgICAgICBJ dCBpcyBub3cgdGhlIHBhcmVudCdzIHJlc3BvbnNpYmlsaXR5IHRvIHNodXQgZG93biB0aGUgd29y a2VyIHRocmVhZCB3aGVuIGl0IGlzIG5vdGlmaWVkIHRoYXQgdGhlIGNvbnRleHQgaXMgY2xvc2Vk LgorCisgICAgICAgICogd29ya2Vycy9EZWZhdWx0U2hhcmVkV29ya2VyUmVwb3NpdG9yeS5jcHA6 CisgICAgICAgIChXZWJDb3JlOjpTaGFyZWRXb3JrZXJQcm94eTo6d29ya2VyQ29udGV4dENsb3Nl ZCk6CisgICAgICAgIE5vdyBzaHV0cyBkb3duIHRoZSB3b3JrZXIgdGhyZWFkIHdoZW4gbm90aWZp ZWQgdGhhdCB0aGUgY29udGV4dCBpcyBjbG9zZWQuCisgICAgICAgIChXZWJDb3JlOjpTaGFyZWRX b3JrZXJQcm94eTo6Y2xvc2UpOgorICAgICAgICBOb3cgaGFuZGxlcyBiZWluZyBpbnZva2VkIHdo ZW4gdGhlIGNvbnRleHQgaXMgYWxyZWFkeSBpbiB0aGUgcHJvY2VzcyBvZiBzaHV0dGluZyBkb3du LgorICAgICAgICAqIHdvcmtlcnMvV29ya2VyQ29udGV4dC5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpXb3JrZXJDb250ZXh0OjpjbG9zZSk6CisgICAgICAgIE5vIGxvbmdlciBjYWxscyBXb3JrZXJU aHJlYWQ6OnN0b3AoKSB0byBhdm9pZCByYWNlIGNvbmRpdGlvbnMgd2l0aCBzaHV0dGluZyBkb3du IHRoZSB0aHJlYWQgd2hpbGUgdGhlIHBhcmVudCBpcyBzdGlsbCBpbnRlcmFjdGluZyB3aXRoIGl0 LgorICAgICAgICAqIHdvcmtlcnMvV29ya2VyQ29udGV4dC5oOgorICAgICAgICAoV2ViQ29yZTo6 V29ya2VyQ29udGV4dDo6aXNDbG9zaW5nKToKKyAgICAgICAgaXNDbG9zaW5nKCkgaXMgbm93IHB1 YmxpYyBzbyBXb3JrZXJSdW5Mb29wIGNhbiBjYWxsIGl0IHRvIGRldGVybWluZSB3aGV0aGVyIHRv IHByb2Nlc3MgdGFza3MuCisgICAgICAgICogd29ya2Vycy9Xb3JrZXJNZXNzYWdpbmdQcm94eS5j cHA6CisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJFeGNlcHRpb25UYXNrOjpwZXJmb3JtVGFzayk6 CisgICAgICAgIEVycm9yIGV2ZW50cyBzaG91bGQgc3RpbGwgYmUgZGVsaXZlcmVkIGV2ZW4gaWYg dGhlIHdvcmtlciB0aHJlYWQgaXMgY2xvc2luZy4KKyAgICAgICAgQWxzbyBmaXhlZCBwcm9ibGVt IHdoZXJlIGVycm9yIGV2ZW50cyB3ZXJlIG5vdCBkaXNwYXRjaGVkIGlmIGVycm9yIGhhbmRsZXJz IHdlcmUgYWRkZWQgdmlhIGFkZEV2ZW50TGlzdGVuZXIoKS4KKyAgICAgICAgKFdlYkNvcmU6Oldv cmtlclRlcm1pbmF0ZVRhc2s6OmNyZWF0ZSk6CisgICAgICAgIE5ldyB0YXNrIHRoYXQgaW52b2tl cyB0ZXJtaW5hdGVXb3JrZXJDb250ZXh0KCkgb24gdGhlIHBhcmVudCB0aHJlYWQgd2hlbiB0aGUg Y29udGV4dCBpcyBjbG9zZWQuCisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJUZXJtaW5hdGVUYXNr OjpXb3JrZXJUZXJtaW5hdGVUYXNrKToKKyAgICAgICAgKFdlYkNvcmU6OldvcmtlclRlcm1pbmF0 ZVRhc2s6OnBlcmZvcm1UYXNrKToKKyAgICAgICAgKFdlYkNvcmU6Oldvcmtlck1lc3NhZ2luZ1By b3h5Ojp3b3JrZXJDb250ZXh0Q2xvc2VkKToKKyAgICAgICAgTm93IGZpcmVzIG9mZiBhIFdvcmtl clRlcm1pbmF0ZVRhc2sgdG8gc2h1dCBkb3duIHRoZSB0aHJlYWQgd2hlbiB0aGUgY29udGV4dCBp cyBjbG9zZWQuCisgICAgICAgICogd29ya2Vycy9Xb3JrZXJNZXNzYWdpbmdQcm94eS5oOgorICAg ICAgICBXb3JrZXJNZXNzYWdpbmdQcm94eSBub3cgb3ZlcnJpZGVzIHdvcmtlckNvbnRleHRDbG9z ZWQoKS4KKyAgICAgICAgKiB3b3JrZXJzL1dvcmtlclJ1bkxvb3AuY3BwOgorICAgICAgICAoV2Vi Q29yZTo6V29ya2VyUnVuTG9vcDo6cnVuSW5Nb2RlKToKKyAgICAgICAgTm93IGRyb3BzIHRhc2tz IG9uIHRoZSBmbG9vciBpZiB0aGUgV29ya2VyQ29udGV4dCBpcyBjbG9zaW5nLgorCiAyMDA5LTA4 LTI4ICBWaXRhbHkgUmVwZXNoa28gIDx2aXRhbHlyQGNocm9taXVtLm9yZz4KIAogICAgICAgICBS ZXZpZXdlZCBieSBEaW1pdHJpIEdsYXprb3YuCmRpZmYgLS1naXQgYS9XZWJDb3JlL3dvcmtlcnMv RGVmYXVsdFNoYXJlZFdvcmtlclJlcG9zaXRvcnkuY3BwIGIvV2ViQ29yZS93b3JrZXJzL0RlZmF1 bHRTaGFyZWRXb3JrZXJSZXBvc2l0b3J5LmNwcAppbmRleCAwMWRlMDE2Li5jNWI1Njc2IDEwMDY0 NAotLS0gYS9XZWJDb3JlL3dvcmtlcnMvRGVmYXVsdFNoYXJlZFdvcmtlclJlcG9zaXRvcnkuY3Bw CisrKyBiL1dlYkNvcmUvd29ya2Vycy9EZWZhdWx0U2hhcmVkV29ya2VyUmVwb3NpdG9yeS5jcHAK QEAgLTE1OCw3ICsxNTgsNyBAQCB2b2lkIFNoYXJlZFdvcmtlclByb3h5Ojpwb3N0Q29uc29sZU1l c3NhZ2VUb1dvcmtlck9iamVjdChNZXNzYWdlRGVzdGluYXRpb24gZGVzdAogCiB2b2lkIFNoYXJl ZFdvcmtlclByb3h5Ojp3b3JrZXJDb250ZXh0Q2xvc2VkKCkKIHsKLSAgICBtX2Nsb3NpbmcgPSB0 cnVlOworICAgIGNsb3NlKCk7CiB9CiAKIHZvaWQgU2hhcmVkV29ya2VyUHJveHk6OndvcmtlckNv bnRleHREZXN0cm95ZWQoKQpAQCAtMTkwLDcgKzE5MCw2IEBAIHZvaWQgU2hhcmVkV29ya2VyUHJv eHk6OmRvY3VtZW50RGV0YWNoZWQoRG9jdW1lbnQqIGRvY3VtZW50KQogCiB2b2lkIFNoYXJlZFdv cmtlclByb3h5OjpjbG9zZSgpCiB7Ci0gICAgQVNTRVJUKCFpc0Nsb3NpbmcoKSk7CiAgICAgbV9j bG9zaW5nID0gdHJ1ZTsKICAgICAvLyBTdG9wIHRoZSB3b3JrZXIgdGhyZWFkIC0gdGhlIHByb3h5 IHdpbGwgc3RheSBhcm91bmQgdW50aWwgd2UgZ2V0IHdvcmtlclRocmVhZEV4aXRlZCgpIG5vdGlm aWNhdGlvbi4KICAgICBpZiAobV90aHJlYWQpCmRpZmYgLS1naXQgYS9XZWJDb3JlL3dvcmtlcnMv V29ya2VyQ29udGV4dC5jcHAgYi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5jcHAKaW5k ZXggM2NiMTczMy4uZjY1OTE1YiAxMDA2NDQKLS0tIGEvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNv bnRleHQuY3BwCisrKyBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmNwcApAQCAtMTE5 LDkgKzExOSw4IEBAIHZvaWQgV29ya2VyQ29udGV4dDo6Y2xvc2UoKQogICAgICAgICByZXR1cm47 CiAKICAgICBtX2Nsb3NpbmcgPSB0cnVlOwotICAgIC8vIE5vdGlmeSBwYXJlbnQgdGhhdCB0aGlz IGNvbnRleHQgaXMgY2xvc2VkLgorICAgIC8vIE5vdGlmeSBwYXJlbnQgdGhhdCB0aGlzIGNvbnRl eHQgaXMgY2xvc2VkLiBQYXJlbnQgaXMgcmVzcG9uc2libGUgZm9yIGNhbGxpbmcgV29ya2VyVGhy ZWFkOjpjbG9zZSgpLgogICAgIHRocmVhZCgpLT53b3JrZXJSZXBvcnRpbmdQcm94eSgpLndvcmtl ckNvbnRleHRDbG9zZWQoKTsKLSAgICBtX3RocmVhZC0+c3RvcCgpOwogfQogCiBXb3JrZXJOYXZp Z2F0b3IqIFdvcmtlckNvbnRleHQ6Om5hdmlnYXRvcigpIGNvbnN0CmRpZmYgLS1naXQgYS9XZWJD b3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5oIGIvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRl eHQuaAppbmRleCAyMTMxYTdjLi5hM2MzODIwIDEwMDY0NAotLS0gYS9XZWJDb3JlL3dvcmtlcnMv V29ya2VyQ29udGV4dC5oCisrKyBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmgKQEAg LTExNyw5ICsxMTcsMTAgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICB1c2luZyBSZWZD b3VudGVkPFdvcmtlckNvbnRleHQ+OjpyZWY7CiAgICAgICAgIHVzaW5nIFJlZkNvdW50ZWQ8V29y a2VyQ29udGV4dD46OmRlcmVmOwogCisgICAgICAgIGJvb2wgaXNDbG9zaW5nKCkgeyByZXR1cm4g bV9jbG9zaW5nOyB9CisKICAgICBwcm90ZWN0ZWQ6CiAgICAgICAgIFdvcmtlckNvbnRleHQoY29u c3QgS1VSTCYsIGNvbnN0IFN0cmluZyYsIFdvcmtlclRocmVhZCopOwotICAgICAgICBib29sIGlz Q2xvc2luZygpIHsgcmV0dXJuIG1fY2xvc2luZzsgfQogCiAgICAgcHJpdmF0ZToKICAgICAgICAg dmlydHVhbCB2b2lkIHJlZlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKSB7IHJlZigpOyB9CmRpZmYg LS1naXQgYS9XZWJDb3JlL3dvcmtlcnMvV29ya2VyTWVzc2FnaW5nUHJveHkuY3BwIGIvV2ViQ29y ZS93b3JrZXJzL1dvcmtlck1lc3NhZ2luZ1Byb3h5LmNwcAppbmRleCA1YzZlY2MyLi5jM2NiZWIx IDEwMDY0NAotLS0gYS9XZWJDb3JlL3dvcmtlcnMvV29ya2VyTWVzc2FnaW5nUHJveHkuY3BwCisr KyBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJNZXNzYWdpbmdQcm94eS5jcHAKQEAgLTEyMCwxMiAr MTIwLDEwIEBAIHByaXZhdGU6CiAgICAgdmlydHVhbCB2b2lkIHBlcmZvcm1UYXNrKFNjcmlwdEV4 ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQpCiAgICAgewogICAgICAgICBXb3JrZXIqIHdvcmtlck9i amVjdCA9IG1fbWVzc2FnaW5nUHJveHktPndvcmtlck9iamVjdCgpOwotICAgICAgICBpZiAoIXdv cmtlck9iamVjdCB8fCBtX21lc3NhZ2luZ1Byb3h5LT5hc2tlZFRvVGVybWluYXRlKCkpCisgICAg ICAgIGlmICghd29ya2VyT2JqZWN0KQogICAgICAgICAgICAgcmV0dXJuOwogCi0gICAgICAgIGJv b2wgZXJyb3JIYW5kbGVkID0gZmFsc2U7Ci0gICAgICAgIGlmICh3b3JrZXJPYmplY3QtPm9uZXJy b3IoKSkKLSAgICAgICAgICAgIGVycm9ySGFuZGxlZCA9IHdvcmtlck9iamVjdC0+ZGlzcGF0Y2hT Y3JpcHRFcnJvckV2ZW50KG1fZXJyb3JNZXNzYWdlLCBtX3NvdXJjZVVSTCwgbV9saW5lTnVtYmVy KTsKKyAgICAgICAgYm9vbCBlcnJvckhhbmRsZWQgPSB3b3JrZXJPYmplY3QtPmRpc3BhdGNoU2Ny aXB0RXJyb3JFdmVudChtX2Vycm9yTWVzc2FnZSwgbV9zb3VyY2VVUkwsIG1fbGluZU51bWJlcik7 CiAKICAgICAgICAgaWYgKCFlcnJvckhhbmRsZWQpCiAgICAgICAgICAgICBjb250ZXh0LT5yZXBv cnRFeGNlcHRpb24obV9lcnJvck1lc3NhZ2UsIG1fbGluZU51bWJlciwgbV9zb3VyY2VVUkwpOwpA QCAtMTU4LDYgKzE1NiwyNyBAQCBwcml2YXRlOgogICAgIFdvcmtlck1lc3NhZ2luZ1Byb3h5KiBt X21lc3NhZ2luZ1Byb3h5OwogfTsKIAorY2xhc3MgV29ya2VyVGVybWluYXRlVGFzayA6IHB1Ymxp YyBTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrIHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFz c1JlZlB0cjxXb3JrZXJUZXJtaW5hdGVUYXNrPiBjcmVhdGUoV29ya2VyTWVzc2FnaW5nUHJveHkq IG1lc3NhZ2luZ1Byb3h5KQorICAgIHsKKyAgICAgICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBXb3Jr ZXJUZXJtaW5hdGVUYXNrKG1lc3NhZ2luZ1Byb3h5KSk7CisgICAgfQorCitwcml2YXRlOgorICAg IFdvcmtlclRlcm1pbmF0ZVRhc2soV29ya2VyTWVzc2FnaW5nUHJveHkqIG1lc3NhZ2luZ1Byb3h5 KQorICAgICAgICA6IG1fbWVzc2FnaW5nUHJveHkobWVzc2FnaW5nUHJveHkpCisgICAgeworICAg IH0KKworICAgIHZpcnR1YWwgdm9pZCBwZXJmb3JtVGFzayhTY3JpcHRFeGVjdXRpb25Db250ZXh0 KikKKyAgICB7CisgICAgICAgIG1fbWVzc2FnaW5nUHJveHktPnRlcm1pbmF0ZVdvcmtlckNvbnRl eHQoKTsKKyAgICB9CisKKyAgICBXb3JrZXJNZXNzYWdpbmdQcm94eSogbV9tZXNzYWdpbmdQcm94 eTsKK307CisKIGNsYXNzIFdvcmtlclRocmVhZEFjdGl2aXR5UmVwb3J0VGFzayA6IHB1YmxpYyBT Y3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrIHsKIHB1YmxpYzoKICAgICBzdGF0aWMgUGFzc1Jl ZlB0cjxXb3JrZXJUaHJlYWRBY3Rpdml0eVJlcG9ydFRhc2s+IGNyZWF0ZShXb3JrZXJNZXNzYWdp bmdQcm94eSogbWVzc2FnaW5nUHJveHksIGJvb2wgY29uZmlybWluZ01lc3NhZ2UsIGJvb2wgaGFz UGVuZGluZ0FjdGl2aXR5KQpAQCAtMzAxLDYgKzMyMCwxMiBAQCB2b2lkIFdvcmtlck1lc3NhZ2lu Z1Byb3h5Ojp3b3JrZXJDb250ZXh0RGVzdHJveWVkKCkKICAgICAvLyBXaWxsIGV4ZWN1dGUgd29y a2VyQ29udGV4dERlc3Ryb3llZEludGVybmFsKCkgb24gY29udGV4dCdzIHRocmVhZC4KIH0KIAor dm9pZCBXb3JrZXJNZXNzYWdpbmdQcm94eTo6d29ya2VyQ29udGV4dENsb3NlZCgpCit7CisgICAg Ly8gRXhlY3V0ZXMgdGVybWluYXRlV29ya2VyQ29udGV4dCgpIG9uIHBhcmVudCBjb250ZXh0J3Mg dGhyZWFkLgorICAgIG1fc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+cG9zdFRhc2soV29ya2VyVGVy bWluYXRlVGFzazo6Y3JlYXRlKHRoaXMpKTsKK30KKwogdm9pZCBXb3JrZXJNZXNzYWdpbmdQcm94 eTo6d29ya2VyQ29udGV4dERlc3Ryb3llZEludGVybmFsKCkKIHsKICAgICAvLyBXb3JrZXJDb250 ZXh0RGVzdHJveWVkVGFzayBpcyBhbHdheXMgdGhlIGxhc3QgdG8gYmUgcGVyZm9ybWVkLCBzbyB0 aGUgcHJveHkgaXMgbm90IG5lZWRlZCBmb3IgY29tbXVuaWNhdGlvbgpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS93b3JrZXJzL1dvcmtlck1lc3NhZ2luZ1Byb3h5LmggYi9XZWJDb3JlL3dvcmtlcnMvV29y a2VyTWVzc2FnaW5nUHJveHkuaAppbmRleCBkZDMwOWQ1Li44YWIwY2I2IDEwMDY0NAotLS0gYS9X ZWJDb3JlL3dvcmtlcnMvV29ya2VyTWVzc2FnaW5nUHJveHkuaAorKysgYi9XZWJDb3JlL3dvcmtl cnMvV29ya2VyTWVzc2FnaW5nUHJveHkuaApAQCAtNjUsNiArNjUsNyBAQCBuYW1lc3BhY2UgV2Vi Q29yZSB7CiAgICAgICAgIHZpcnR1YWwgdm9pZCBwb3N0Q29uc29sZU1lc3NhZ2VUb1dvcmtlck9i amVjdChNZXNzYWdlRGVzdGluYXRpb24sIE1lc3NhZ2VTb3VyY2UsIE1lc3NhZ2VUeXBlLCBNZXNz YWdlTGV2ZWwsIGNvbnN0IFN0cmluZyYgbWVzc2FnZSwgaW50IGxpbmVOdW1iZXIsIGNvbnN0IFN0 cmluZyYgc291cmNlVVJMKTsKICAgICAgICAgdmlydHVhbCB2b2lkIGNvbmZpcm1NZXNzYWdlRnJv bVdvcmtlck9iamVjdChib29sIGhhc1BlbmRpbmdBY3Rpdml0eSk7CiAgICAgICAgIHZpcnR1YWwg dm9pZCByZXBvcnRQZW5kaW5nQWN0aXZpdHkoYm9vbCBoYXNQZW5kaW5nQWN0aXZpdHkpOworICAg ICAgICB2aXJ0dWFsIHZvaWQgd29ya2VyQ29udGV4dENsb3NlZCgpOwogICAgICAgICB2aXJ0dWFs IHZvaWQgd29ya2VyQ29udGV4dERlc3Ryb3llZCgpOwogCiAgICAgICAgIC8vIEltcGxlbWVudGF0 aW9uIG9mIFdvcmtlckxvYWRlclByb3h5LgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS93b3JrZXJzL1dv cmtlclJ1bkxvb3AuY3BwIGIvV2ViQ29yZS93b3JrZXJzL1dvcmtlclJ1bkxvb3AuY3BwCmluZGV4 IGNiMzFmZTcuLjUyZDY1MGYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJSdW5M b29wLmNwcAorKysgYi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyUnVuTG9vcC5jcHAKQEAgLTE3Myw2 ICsxNzMsMTAgQEAgTWVzc2FnZVF1ZXVlV2FpdFJlc3VsdCBXb3JrZXJSdW5Mb29wOjpydW5Jbk1v ZGUoV29ya2VyQ29udGV4dCogY29udGV4dCwgY29uc3QgTW8KICAgICBSZWZQdHI8VGFzaz4gdGFz azsKICAgICBNZXNzYWdlUXVldWVXYWl0UmVzdWx0IHJlc3VsdCA9IG1fbWVzc2FnZVF1ZXVlLndh aXRGb3JNZXNzYWdlRmlsdGVyZWRXaXRoVGltZW91dCh0YXNrLCBwcmVkaWNhdGUsIGFic29sdXRl VGltZSk7CiAKKyAgICAvLyBJZiB0aGUgY29udGV4dCBpcyBjbG9zaW5nLCBkb24ndCBkaXNwYXRj aCBhbnkgZnVydGhlciB0YXNrcyAocGVyIHNlY3Rpb24gNC4xLjEgb2YgdGhlIFdlYiBXb3JrZXJz IHNwZWMpLgorICAgIGlmIChjb250ZXh0LT5pc0Nsb3NpbmcoKSkKKyAgICAgICAgcmV0dXJuIHJl c3VsdDsKKwogICAgIHN3aXRjaCAocmVzdWx0KSB7CiAgICAgY2FzZSBNZXNzYWdlUXVldWVUZXJt aW5hdGVkOgogICAgICAgICBicmVhazsK 38770 2009-08-28 21:25:24 -0700 2009-08-31 10:43:56 -0700 patch with fix for typo in comment x text/plain 9257 atwilson ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA3Njk3MzMxLi4xZTQ0ZjllIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAKKzIwMDktMDgt MjggIERyZXcgV2lsc29uICA8YXR3aWxzb25AZ29vZ2xlLmNvbT4KKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBmYXN0L3dvcmtlcnMvd29ya2VyLWxpZmVj eWNsZS5odG1sIGNyYXNoZXMgaW50ZXJtaXR0ZW50bHkgb24gc25vd2xlb3BhcmQKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI4Nzk1CisKKyAgICAgICAg UmVtb3ZlZCB3b3JrZXItbGlmZWN5Y2xlLmh0bWwgZnJvbSB0aGUgbGlzdCBvZiBTa2lwcGVkIHRl c3RzIHNpbmNlIGl0IG5vIGxvbmdlciBjcmFzaGVzLgorCisgICAgICAgICogcGxhdGZvcm0vbWFj LXNub3dsZW9wYXJkL1NraXBwZWQ6CisKIDIwMDktMDgtMjggIEphbiBNaWNoYWVsIEFsb256byAg PGptYWxvbnpvQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgR3VzdGF2byBOb3Jv bmhhLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFjLXNub3dsZW9wYXJkL1Nr aXBwZWQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMtc25vd2xlb3BhcmQvU2tpcHBlZAppbmRl eCAzZTUyYTllLi4xNDMyY2NmIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMt c25vd2xlb3BhcmQvU2tpcHBlZAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMtc25vd2xl b3BhcmQvU2tpcHBlZApAQCAtNDAsNiArNDAsMyBAQCBtZWRpYS9jb250cm9scy1kcmFnLXRpbWVi YXIuaHRtbAogCiAjPHJkYXI6Ly9wcm9ibGVtLzcxNDQ1ODM+IC0gSW50ZXJtaXR0ZW50IGZhaWx1 cmUKIHN2Zy9jc3MvZ2x5cGgtb3JpZW50YXRpb24tcm91bmRpbmctdGVzdC54aHRtbAotCi0jaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI4Nzk1IC0gZmFpbHVyZSBncmFi YmluZyBtdXRleCBsb2NrCi1mYXN0L3dvcmtlcnMvd29ya2VyLWxpZmVjeWNsZS5odG1sCmRpZmYg LS1naXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDg4MGFi ZGEuLjc0NTljY2IgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1dlYkNvcmUv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsNDAgQEAKKzIwMDktMDgtMjggIERyZXcgV2lsc29uICA8YXR3 aWxzb25AZ29vZ2xlLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICBmYXN0L3dvcmtlcnMvd29ya2VyLWxpZmVjeWNsZS5odG1sIGNyYXNoZXMgaW50 ZXJtaXR0ZW50bHkgb24gc25vd2xlb3BhcmQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTI4Nzk1CisKKyAgICAgICAgQ2hhbmdlZCBXb3JrZXJDb250ZXh0 OjpjbG9zZSgpIHRvIG5vIGxvbmdlciBzdG9wIHRoZSB3b3JrZXIgdGhyZWFkLgorICAgICAgICBJ dCBpcyBub3cgdGhlIHBhcmVudCdzIHJlc3BvbnNpYmlsaXR5IHRvIHNodXQgZG93biB0aGUgd29y a2VyIHRocmVhZCB3aGVuIGl0IGlzIG5vdGlmaWVkIHRoYXQgdGhlIGNvbnRleHQgaXMgY2xvc2Vk LgorCisgICAgICAgICogd29ya2Vycy9EZWZhdWx0U2hhcmVkV29ya2VyUmVwb3NpdG9yeS5jcHA6 CisgICAgICAgIChXZWJDb3JlOjpTaGFyZWRXb3JrZXJQcm94eTo6d29ya2VyQ29udGV4dENsb3Nl ZCk6CisgICAgICAgIE5vdyBzaHV0cyBkb3duIHRoZSB3b3JrZXIgdGhyZWFkIHdoZW4gbm90aWZp ZWQgdGhhdCB0aGUgY29udGV4dCBpcyBjbG9zZWQuCisgICAgICAgIChXZWJDb3JlOjpTaGFyZWRX b3JrZXJQcm94eTo6Y2xvc2UpOgorICAgICAgICBOb3cgaGFuZGxlcyBiZWluZyBpbnZva2VkIHdo ZW4gdGhlIGNvbnRleHQgaXMgYWxyZWFkeSBpbiB0aGUgcHJvY2VzcyBvZiBzaHV0dGluZyBkb3du LgorICAgICAgICAqIHdvcmtlcnMvV29ya2VyQ29udGV4dC5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpXb3JrZXJDb250ZXh0OjpjbG9zZSk6CisgICAgICAgIE5vIGxvbmdlciBjYWxscyBXb3JrZXJU aHJlYWQ6OnN0b3AoKSB0byBhdm9pZCByYWNlIGNvbmRpdGlvbnMgd2l0aCBzaHV0dGluZyBkb3du IHRoZSB0aHJlYWQgd2hpbGUgdGhlIHBhcmVudCBpcyBzdGlsbCBpbnRlcmFjdGluZyB3aXRoIGl0 LgorICAgICAgICAqIHdvcmtlcnMvV29ya2VyQ29udGV4dC5oOgorICAgICAgICAoV2ViQ29yZTo6 V29ya2VyQ29udGV4dDo6aXNDbG9zaW5nKToKKyAgICAgICAgaXNDbG9zaW5nKCkgaXMgbm93IHB1 YmxpYyBzbyBXb3JrZXJSdW5Mb29wIGNhbiBjYWxsIGl0IHRvIGRldGVybWluZSB3aGV0aGVyIHRv IHByb2Nlc3MgdGFza3MuCisgICAgICAgICogd29ya2Vycy9Xb3JrZXJNZXNzYWdpbmdQcm94eS5j cHA6CisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJFeGNlcHRpb25UYXNrOjpwZXJmb3JtVGFzayk6 CisgICAgICAgIEVycm9yIGV2ZW50cyBzaG91bGQgc3RpbGwgYmUgZGVsaXZlcmVkIGV2ZW4gaWYg dGhlIHdvcmtlciB0aHJlYWQgaXMgY2xvc2luZy4KKyAgICAgICAgQWxzbyBmaXhlZCBwcm9ibGVt IHdoZXJlIGVycm9yIGV2ZW50cyB3ZXJlIG5vdCBkaXNwYXRjaGVkIGlmIGVycm9yIGhhbmRsZXJz IHdlcmUgYWRkZWQgdmlhIGFkZEV2ZW50TGlzdGVuZXIoKS4KKyAgICAgICAgKFdlYkNvcmU6Oldv cmtlclRlcm1pbmF0ZVRhc2s6OmNyZWF0ZSk6CisgICAgICAgIE5ldyB0YXNrIHRoYXQgaW52b2tl cyB0ZXJtaW5hdGVXb3JrZXJDb250ZXh0KCkgb24gdGhlIHBhcmVudCB0aHJlYWQgd2hlbiB0aGUg Y29udGV4dCBpcyBjbG9zZWQuCisgICAgICAgIChXZWJDb3JlOjpXb3JrZXJUZXJtaW5hdGVUYXNr OjpXb3JrZXJUZXJtaW5hdGVUYXNrKToKKyAgICAgICAgKFdlYkNvcmU6OldvcmtlclRlcm1pbmF0 ZVRhc2s6OnBlcmZvcm1UYXNrKToKKyAgICAgICAgKFdlYkNvcmU6Oldvcmtlck1lc3NhZ2luZ1By b3h5Ojp3b3JrZXJDb250ZXh0Q2xvc2VkKToKKyAgICAgICAgTm93IGZpcmVzIG9mZiBhIFdvcmtl clRlcm1pbmF0ZVRhc2sgdG8gc2h1dCBkb3duIHRoZSB0aHJlYWQgd2hlbiB0aGUgY29udGV4dCBp cyBjbG9zZWQuCisgICAgICAgICogd29ya2Vycy9Xb3JrZXJNZXNzYWdpbmdQcm94eS5oOgorICAg ICAgICBXb3JrZXJNZXNzYWdpbmdQcm94eSBub3cgb3ZlcnJpZGVzIHdvcmtlckNvbnRleHRDbG9z ZWQoKS4KKyAgICAgICAgKiB3b3JrZXJzL1dvcmtlclJ1bkxvb3AuY3BwOgorICAgICAgICAoV2Vi Q29yZTo6V29ya2VyUnVuTG9vcDo6cnVuSW5Nb2RlKToKKyAgICAgICAgTm93IGRyb3BzIHRhc2tz IG9uIHRoZSBmbG9vciBpZiB0aGUgV29ya2VyQ29udGV4dCBpcyBjbG9zaW5nLgorCiAyMDA5LTA4 LTI4ICBWaXRhbHkgUmVwZXNoa28gIDx2aXRhbHlyQGNocm9taXVtLm9yZz4KIAogICAgICAgICBS ZXZpZXdlZCBieSBEaW1pdHJpIEdsYXprb3YuCmRpZmYgLS1naXQgYS9XZWJDb3JlL3dvcmtlcnMv RGVmYXVsdFNoYXJlZFdvcmtlclJlcG9zaXRvcnkuY3BwIGIvV2ViQ29yZS93b3JrZXJzL0RlZmF1 bHRTaGFyZWRXb3JrZXJSZXBvc2l0b3J5LmNwcAppbmRleCAwMWRlMDE2Li5jNWI1Njc2IDEwMDY0 NAotLS0gYS9XZWJDb3JlL3dvcmtlcnMvRGVmYXVsdFNoYXJlZFdvcmtlclJlcG9zaXRvcnkuY3Bw CisrKyBiL1dlYkNvcmUvd29ya2Vycy9EZWZhdWx0U2hhcmVkV29ya2VyUmVwb3NpdG9yeS5jcHAK QEAgLTE1OCw3ICsxNTgsNyBAQCB2b2lkIFNoYXJlZFdvcmtlclByb3h5Ojpwb3N0Q29uc29sZU1l c3NhZ2VUb1dvcmtlck9iamVjdChNZXNzYWdlRGVzdGluYXRpb24gZGVzdAogCiB2b2lkIFNoYXJl ZFdvcmtlclByb3h5Ojp3b3JrZXJDb250ZXh0Q2xvc2VkKCkKIHsKLSAgICBtX2Nsb3NpbmcgPSB0 cnVlOworICAgIGNsb3NlKCk7CiB9CiAKIHZvaWQgU2hhcmVkV29ya2VyUHJveHk6OndvcmtlckNv bnRleHREZXN0cm95ZWQoKQpAQCAtMTkwLDcgKzE5MCw2IEBAIHZvaWQgU2hhcmVkV29ya2VyUHJv eHk6OmRvY3VtZW50RGV0YWNoZWQoRG9jdW1lbnQqIGRvY3VtZW50KQogCiB2b2lkIFNoYXJlZFdv cmtlclByb3h5OjpjbG9zZSgpCiB7Ci0gICAgQVNTRVJUKCFpc0Nsb3NpbmcoKSk7CiAgICAgbV9j bG9zaW5nID0gdHJ1ZTsKICAgICAvLyBTdG9wIHRoZSB3b3JrZXIgdGhyZWFkIC0gdGhlIHByb3h5 IHdpbGwgc3RheSBhcm91bmQgdW50aWwgd2UgZ2V0IHdvcmtlclRocmVhZEV4aXRlZCgpIG5vdGlm aWNhdGlvbi4KICAgICBpZiAobV90aHJlYWQpCmRpZmYgLS1naXQgYS9XZWJDb3JlL3dvcmtlcnMv V29ya2VyQ29udGV4dC5jcHAgYi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4dC5jcHAKaW5k ZXggM2NiMTczMy4uNmQ5NWUwMiAxMDA2NDQKLS0tIGEvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNv bnRleHQuY3BwCisrKyBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmNwcApAQCAtMTE5 LDkgKzExOSw4IEBAIHZvaWQgV29ya2VyQ29udGV4dDo6Y2xvc2UoKQogICAgICAgICByZXR1cm47 CiAKICAgICBtX2Nsb3NpbmcgPSB0cnVlOwotICAgIC8vIE5vdGlmeSBwYXJlbnQgdGhhdCB0aGlz IGNvbnRleHQgaXMgY2xvc2VkLgorICAgIC8vIE5vdGlmeSBwYXJlbnQgdGhhdCB0aGlzIGNvbnRl eHQgaXMgY2xvc2VkLiBQYXJlbnQgaXMgcmVzcG9uc2libGUgZm9yIGNhbGxpbmcgV29ya2VyVGhy ZWFkOjpzdG9wKCkuCiAgICAgdGhyZWFkKCktPndvcmtlclJlcG9ydGluZ1Byb3h5KCkud29ya2Vy Q29udGV4dENsb3NlZCgpOwotICAgIG1fdGhyZWFkLT5zdG9wKCk7CiB9CiAKIFdvcmtlck5hdmln YXRvciogV29ya2VyQ29udGV4dDo6bmF2aWdhdG9yKCkgY29uc3QKZGlmZiAtLWdpdCBhL1dlYkNv cmUvd29ya2Vycy9Xb3JrZXJDb250ZXh0LmggYi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyQ29udGV4 dC5oCmluZGV4IDIxMzFhN2MuLmEzYzM4MjAgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvd29ya2Vycy9X b3JrZXJDb250ZXh0LmgKKysrIGIvV2ViQ29yZS93b3JrZXJzL1dvcmtlckNvbnRleHQuaApAQCAt MTE3LDkgKzExNywxMCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHVzaW5nIFJlZkNv dW50ZWQ8V29ya2VyQ29udGV4dD46OnJlZjsKICAgICAgICAgdXNpbmcgUmVmQ291bnRlZDxXb3Jr ZXJDb250ZXh0Pjo6ZGVyZWY7CiAKKyAgICAgICAgYm9vbCBpc0Nsb3NpbmcoKSB7IHJldHVybiBt X2Nsb3Npbmc7IH0KKwogICAgIHByb3RlY3RlZDoKICAgICAgICAgV29ya2VyQ29udGV4dChjb25z dCBLVVJMJiwgY29uc3QgU3RyaW5nJiwgV29ya2VyVGhyZWFkKik7Ci0gICAgICAgIGJvb2wgaXND bG9zaW5nKCkgeyByZXR1cm4gbV9jbG9zaW5nOyB9CiAKICAgICBwcml2YXRlOgogICAgICAgICB2 aXJ0dWFsIHZvaWQgcmVmU2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpIHsgcmVmKCk7IH0KZGlmZiAt LWdpdCBhL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJNZXNzYWdpbmdQcm94eS5jcHAgYi9XZWJDb3Jl L3dvcmtlcnMvV29ya2VyTWVzc2FnaW5nUHJveHkuY3BwCmluZGV4IDVjNmVjYzIuLmMzY2JlYjEg MTAwNjQ0Ci0tLSBhL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJNZXNzYWdpbmdQcm94eS5jcHAKKysr IGIvV2ViQ29yZS93b3JrZXJzL1dvcmtlck1lc3NhZ2luZ1Byb3h5LmNwcApAQCAtMTIwLDEyICsx MjAsMTAgQEAgcHJpdmF0ZToKICAgICB2aXJ0dWFsIHZvaWQgcGVyZm9ybVRhc2soU2NyaXB0RXhl Y3V0aW9uQ29udGV4dCogY29udGV4dCkKICAgICB7CiAgICAgICAgIFdvcmtlciogd29ya2VyT2Jq ZWN0ID0gbV9tZXNzYWdpbmdQcm94eS0+d29ya2VyT2JqZWN0KCk7Ci0gICAgICAgIGlmICghd29y a2VyT2JqZWN0IHx8IG1fbWVzc2FnaW5nUHJveHktPmFza2VkVG9UZXJtaW5hdGUoKSkKKyAgICAg ICAgaWYgKCF3b3JrZXJPYmplY3QpCiAgICAgICAgICAgICByZXR1cm47CiAKLSAgICAgICAgYm9v bCBlcnJvckhhbmRsZWQgPSBmYWxzZTsKLSAgICAgICAgaWYgKHdvcmtlck9iamVjdC0+b25lcnJv cigpKQotICAgICAgICAgICAgZXJyb3JIYW5kbGVkID0gd29ya2VyT2JqZWN0LT5kaXNwYXRjaFNj cmlwdEVycm9yRXZlbnQobV9lcnJvck1lc3NhZ2UsIG1fc291cmNlVVJMLCBtX2xpbmVOdW1iZXIp OworICAgICAgICBib29sIGVycm9ySGFuZGxlZCA9IHdvcmtlck9iamVjdC0+ZGlzcGF0Y2hTY3Jp cHRFcnJvckV2ZW50KG1fZXJyb3JNZXNzYWdlLCBtX3NvdXJjZVVSTCwgbV9saW5lTnVtYmVyKTsK IAogICAgICAgICBpZiAoIWVycm9ySGFuZGxlZCkKICAgICAgICAgICAgIGNvbnRleHQtPnJlcG9y dEV4Y2VwdGlvbihtX2Vycm9yTWVzc2FnZSwgbV9saW5lTnVtYmVyLCBtX3NvdXJjZVVSTCk7CkBA IC0xNTgsNiArMTU2LDI3IEBAIHByaXZhdGU6CiAgICAgV29ya2VyTWVzc2FnaW5nUHJveHkqIG1f bWVzc2FnaW5nUHJveHk7CiB9OwogCitjbGFzcyBXb3JrZXJUZXJtaW5hdGVUYXNrIDogcHVibGlj IFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2sgeworcHVibGljOgorICAgIHN0YXRpYyBQYXNz UmVmUHRyPFdvcmtlclRlcm1pbmF0ZVRhc2s+IGNyZWF0ZShXb3JrZXJNZXNzYWdpbmdQcm94eSog bWVzc2FnaW5nUHJveHkpCisgICAgeworICAgICAgICByZXR1cm4gYWRvcHRSZWYobmV3IFdvcmtl clRlcm1pbmF0ZVRhc2sobWVzc2FnaW5nUHJveHkpKTsKKyAgICB9CisKK3ByaXZhdGU6CisgICAg V29ya2VyVGVybWluYXRlVGFzayhXb3JrZXJNZXNzYWdpbmdQcm94eSogbWVzc2FnaW5nUHJveHkp CisgICAgICAgIDogbV9tZXNzYWdpbmdQcm94eShtZXNzYWdpbmdQcm94eSkKKyAgICB7CisgICAg fQorCisgICAgdmlydHVhbCB2b2lkIHBlcmZvcm1UYXNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQq KQorICAgIHsKKyAgICAgICAgbV9tZXNzYWdpbmdQcm94eS0+dGVybWluYXRlV29ya2VyQ29udGV4 dCgpOworICAgIH0KKworICAgIFdvcmtlck1lc3NhZ2luZ1Byb3h5KiBtX21lc3NhZ2luZ1Byb3h5 OworfTsKKwogY2xhc3MgV29ya2VyVGhyZWFkQWN0aXZpdHlSZXBvcnRUYXNrIDogcHVibGljIFNj cmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2sgewogcHVibGljOgogICAgIHN0YXRpYyBQYXNzUmVm UHRyPFdvcmtlclRocmVhZEFjdGl2aXR5UmVwb3J0VGFzaz4gY3JlYXRlKFdvcmtlck1lc3NhZ2lu Z1Byb3h5KiBtZXNzYWdpbmdQcm94eSwgYm9vbCBjb25maXJtaW5nTWVzc2FnZSwgYm9vbCBoYXNQ ZW5kaW5nQWN0aXZpdHkpCkBAIC0zMDEsNiArMzIwLDEyIEBAIHZvaWQgV29ya2VyTWVzc2FnaW5n UHJveHk6OndvcmtlckNvbnRleHREZXN0cm95ZWQoKQogICAgIC8vIFdpbGwgZXhlY3V0ZSB3b3Jr ZXJDb250ZXh0RGVzdHJveWVkSW50ZXJuYWwoKSBvbiBjb250ZXh0J3MgdGhyZWFkLgogfQogCit2 b2lkIFdvcmtlck1lc3NhZ2luZ1Byb3h5Ojp3b3JrZXJDb250ZXh0Q2xvc2VkKCkKK3sKKyAgICAv LyBFeGVjdXRlcyB0ZXJtaW5hdGVXb3JrZXJDb250ZXh0KCkgb24gcGFyZW50IGNvbnRleHQncyB0 aHJlYWQuCisgICAgbV9zY3JpcHRFeGVjdXRpb25Db250ZXh0LT5wb3N0VGFzayhXb3JrZXJUZXJt aW5hdGVUYXNrOjpjcmVhdGUodGhpcykpOworfQorCiB2b2lkIFdvcmtlck1lc3NhZ2luZ1Byb3h5 Ojp3b3JrZXJDb250ZXh0RGVzdHJveWVkSW50ZXJuYWwoKQogewogICAgIC8vIFdvcmtlckNvbnRl eHREZXN0cm95ZWRUYXNrIGlzIGFsd2F5cyB0aGUgbGFzdCB0byBiZSBwZXJmb3JtZWQsIHNvIHRo ZSBwcm94eSBpcyBub3QgbmVlZGVkIGZvciBjb21tdW5pY2F0aW9uCmRpZmYgLS1naXQgYS9XZWJD b3JlL3dvcmtlcnMvV29ya2VyTWVzc2FnaW5nUHJveHkuaCBiL1dlYkNvcmUvd29ya2Vycy9Xb3Jr ZXJNZXNzYWdpbmdQcm94eS5oCmluZGV4IGRkMzA5ZDUuLjhhYjBjYjYgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvd29ya2Vycy9Xb3JrZXJNZXNzYWdpbmdQcm94eS5oCisrKyBiL1dlYkNvcmUvd29ya2Vy cy9Xb3JrZXJNZXNzYWdpbmdQcm94eS5oCkBAIC02NSw2ICs2NSw3IEBAIG5hbWVzcGFjZSBXZWJD b3JlIHsKICAgICAgICAgdmlydHVhbCB2b2lkIHBvc3RDb25zb2xlTWVzc2FnZVRvV29ya2VyT2Jq ZWN0KE1lc3NhZ2VEZXN0aW5hdGlvbiwgTWVzc2FnZVNvdXJjZSwgTWVzc2FnZVR5cGUsIE1lc3Nh Z2VMZXZlbCwgY29uc3QgU3RyaW5nJiBtZXNzYWdlLCBpbnQgbGluZU51bWJlciwgY29uc3QgU3Ry aW5nJiBzb3VyY2VVUkwpOwogICAgICAgICB2aXJ0dWFsIHZvaWQgY29uZmlybU1lc3NhZ2VGcm9t V29ya2VyT2JqZWN0KGJvb2wgaGFzUGVuZGluZ0FjdGl2aXR5KTsKICAgICAgICAgdmlydHVhbCB2 b2lkIHJlcG9ydFBlbmRpbmdBY3Rpdml0eShib29sIGhhc1BlbmRpbmdBY3Rpdml0eSk7CisgICAg ICAgIHZpcnR1YWwgdm9pZCB3b3JrZXJDb250ZXh0Q2xvc2VkKCk7CiAgICAgICAgIHZpcnR1YWwg dm9pZCB3b3JrZXJDb250ZXh0RGVzdHJveWVkKCk7CiAKICAgICAgICAgLy8gSW1wbGVtZW50YXRp b24gb2YgV29ya2VyTG9hZGVyUHJveHkuCmRpZmYgLS1naXQgYS9XZWJDb3JlL3dvcmtlcnMvV29y a2VyUnVuTG9vcC5jcHAgYi9XZWJDb3JlL3dvcmtlcnMvV29ya2VyUnVuTG9vcC5jcHAKaW5kZXgg Y2IzMWZlNy4uNTJkNjUwZiAxMDA2NDQKLS0tIGEvV2ViQ29yZS93b3JrZXJzL1dvcmtlclJ1bkxv b3AuY3BwCisrKyBiL1dlYkNvcmUvd29ya2Vycy9Xb3JrZXJSdW5Mb29wLmNwcApAQCAtMTczLDYg KzE3MywxMCBAQCBNZXNzYWdlUXVldWVXYWl0UmVzdWx0IFdvcmtlclJ1bkxvb3A6OnJ1bkluTW9k ZShXb3JrZXJDb250ZXh0KiBjb250ZXh0LCBjb25zdCBNbwogICAgIFJlZlB0cjxUYXNrPiB0YXNr OwogICAgIE1lc3NhZ2VRdWV1ZVdhaXRSZXN1bHQgcmVzdWx0ID0gbV9tZXNzYWdlUXVldWUud2Fp dEZvck1lc3NhZ2VGaWx0ZXJlZFdpdGhUaW1lb3V0KHRhc2ssIHByZWRpY2F0ZSwgYWJzb2x1dGVU aW1lKTsKIAorICAgIC8vIElmIHRoZSBjb250ZXh0IGlzIGNsb3NpbmcsIGRvbid0IGRpc3BhdGNo IGFueSBmdXJ0aGVyIHRhc2tzIChwZXIgc2VjdGlvbiA0LjEuMSBvZiB0aGUgV2ViIFdvcmtlcnMg c3BlYykuCisgICAgaWYgKGNvbnRleHQtPmlzQ2xvc2luZygpKQorICAgICAgICByZXR1cm4gcmVz dWx0OworCiAgICAgc3dpdGNoIChyZXN1bHQpIHsKICAgICBjYXNlIE1lc3NhZ2VRdWV1ZVRlcm1p bmF0ZWQ6CiAgICAgICAgIGJyZWFrOwo=