51897 2011-01-04 14:11:32 -0800 Escape should clear search field 2011-07-15 01:11:13 -0700 1 1 1 Unclassified WebKit Forms 528+ (Nightly build) All All RESOLVED FIXED P2 Normal --- 1 estade webkit-unassigned darin haraken ojan tkent webkit.review.bot oldest_to_newest 329206 0 estade 2011-01-04 14:11:32 -0800 pressing escape in a <input type="search"> field should clear the contents (same as if the user presses the x) 436391 1 100667 haraken 2011-07-13 06:01:20 -0700 Created attachment 100667 Patch 436483 2 100667 evan 2011-07-13 09:55:32 -0700 Comment on attachment 100667 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=100667&action=review > Source/WebCore/html/SearchInputType.cpp:113 > + const String& key = event->keyIdentifier(); > + if (key == "U+001B") { > + HTMLInputElement* input = element(); > + input->setValueForUser(""); > + input->onSearch(); > + event->setDefaultHandled(); > + } else > + TextFieldInputType::handleKeydownEvent(event); Does this mean it's impossible for content to handle 'esc' specially? I wonder if this maybe belongs on keypress rather than keydown. 436812 3 100667 tkent 2011-07-13 18:06:02 -0700 Comment on attachment 100667 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=100667&action=review r- because of possible use-after-free. > LayoutTests/fast/forms/input-search-press-escape-key.html:28 > + eventSender.keyDown("escape"); Do you need to use eventSender? Doesn't the following event dispatching work? var event = document.createEvent('KeyboardEvents'); event.initKeyboardEvent(...); input.dispatchEvent(event); > Source/WebCore/html/SearchInputType.cpp:110 > + input->setValueForUser(""); > + input->onSearch(); setValueForUser() dispatches 'change' event and a JavaScript handler can delete 'input'. You need to use RefPtr<HTMLInputElement>. >> Source/WebCore/html/SearchInputType.cpp:113 >> + TextFieldInputType::handleKeydownEvent(event); > > Does this mean it's impossible for content to handle 'esc' specially? I wonder if this maybe belongs on keypress rather than keydown. Agree with Evan. 436902 4 100667 haraken 2011-07-13 19:51:56 -0700 Comment on attachment 100667 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=100667&action=review >> LayoutTests/fast/forms/input-search-press-escape-key.html:28 >> + eventSender.keyDown("escape"); > > Do you need to use eventSender? > Doesn't the following event dispatching work? > var event = document.createEvent('KeyboardEvents'); > event.initKeyboardEvent(...); > input.dispatchEvent(event); Keyboard event dispatching does fire the event but does nothing because of the bug: http://code.google.com/p/chromium/issues/detail?id=52408 This bug happens on not only Linux Chromium 14.0.822.0 but also Mac Safari 5.0.5 and even Linux Firefox 5.0. You can test it here: http://haraken.info/null/keyevent.html Provided that the above test code is not wrong, I am not sure but I guess that this is not a bug and there must be some strong reason (security or something?) that browsers are forbidding dispatching keyboard events. But if this is really a bug to be fixed and you think that we should first fix the keyboard event dispatching bug, then I will fix it and then come back to this search form bug later. >> Source/WebCore/html/SearchInputType.cpp:110 >> + input->onSearch(); > > setValueForUser() dispatches 'change' event and a JavaScript handler can delete 'input'. > You need to use RefPtr<HTMLInputElement>. OK. I will fix it in the next patch. >>> Source/WebCore/html/SearchInputType.cpp:113 >>> + TextFieldInputType::handleKeydownEvent(event); >> >> Does this mean it's impossible for content to handle 'esc' specially? I wonder if this maybe belongs on keypress rather than keydown. > > Agree with Evan. I am not sure for this. I agree that it becomes impossible for content to handle 'Escape', if we handle it in handleKeydownEvent(). However, it seems that most key events for input elements are being handled not by handleKeypressEvent() but by handleKeydownEvent(). For example, TextFieldInputType.cpp, NumberInputType.cpp and RangeInputType.cpp have handleKeydownEvent() but do not have handleKeypressEvent(). Also, if we handle 'Escape' in handleKeypressEvent(), then it becomes impossible to test it by eventSender.keyDown("escape") (, although whether we should test it by eventSender.keyDown() or not is debatable as I described above). 436993 5 100667 tkent 2011-07-14 01:24:03 -0700 Comment on attachment 100667 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=100667&action=review >>> LayoutTests/fast/forms/input-search-press-escape-key.html:28 >>> + eventSender.keyDown("escape"); >> >> Do you need to use eventSender? >> Doesn't the following event dispatching work? >> var event = document.createEvent('KeyboardEvents'); >> event.initKeyboardEvent(...); >> input.dispatchEvent(event); > > Keyboard event dispatching does fire the event but does nothing because of the bug: http://code.google.com/p/chromium/issues/detail?id=52408 > This bug happens on not only Linux Chromium 14.0.822.0 but also Mac Safari 5.0.5 and even Linux Firefox 5.0. > > You can test it here: > http://haraken.info/null/keyevent.html > > Provided that the above test code is not wrong, I am not sure but I guess that this is not a bug and there must be some strong reason (security or something?) that browsers are forbidding dispatching keyboard events. But if this is really a bug to be fixed and you think that we should first fix the keyboard event dispatching bug, then I will fix it and then come back to this search form bug later. ok, I understand createEvent&initKeyboardEvet doesn't work. >>>> Source/WebCore/html/SearchInputType.cpp:113 >>>> + TextFieldInputType::handleKeydownEvent(event); >>> >>> Does this mean it's impossible for content to handle 'esc' specially? I wonder if this maybe belongs on keypress rather than keydown. >> >> Agree with Evan. > > I am not sure for this. I agree that it becomes impossible for content to handle 'Escape', if we handle it in handleKeydownEvent(). However, it seems that most key events for input elements are being handled not by handleKeypressEvent() but by handleKeydownEvent(). For example, TextFieldInputType.cpp, NumberInputType.cpp and RangeInputType.cpp have handleKeydownEvent() but do not have handleKeypressEvent(). Also, if we handle 'Escape' in handleKeypressEvent(), then it becomes impossible to test it by eventSender.keyDown("escape") (, although whether we should test it by eventSender.keyDown() or not is debatable as I described above). I think many existing key-binding code should be switched to keypress. eventSender.keyDown() dispatched keydown, keyup, and keypress. 437341 6 100667 ojan 2011-07-14 14:45:52 -0700 Comment on attachment 100667 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=100667&action=review >>>>> Source/WebCore/html/SearchInputType.cpp:113 >>>>> + TextFieldInputType::handleKeydownEvent(event); >>>> >>>> Does this mean it's impossible for content to handle 'esc' specially? I wonder if this maybe belongs on keypress rather than keydown. >>> >>> Agree with Evan. >> >> I am not sure for this. I agree that it becomes impossible for content to handle 'Escape', if we handle it in handleKeydownEvent(). However, it seems that most key events for input elements are being handled not by handleKeypressEvent() but by handleKeydownEvent(). For example, TextFieldInputType.cpp, NumberInputType.cpp and RangeInputType.cpp have handleKeydownEvent() but do not have handleKeypressEvent(). Also, if we handle 'Escape' in handleKeypressEvent(), then it becomes impossible to test it by eventSender.keyDown("escape") (, although whether we should test it by eventSender.keyDown() or not is debatable as I described above). > > I think many existing key-binding code should be switched to keypress. > eventSender.keyDown() dispatched keydown, keyup, and keypress. Looking at EventDispatcher::dispatchEvent, we first fire the event to JS and then call defaultEventHandler. haraken, can you confirm that if you call preventDefault from the esc key's keydown event that we don't clear the search input? That said, I think tkent is probably right that most, if not all, of the existing key-binding code should be moved to handleKeyPressEvent. I'm not 100% sure of that though. Would be nice to get input from someone involved in putting it on handleKeydownEvent in the first place. haraken, you could look at the blame list for some other instances of it and CC the appropriate developers on this bug to get them to comment. 437440 7 haraken 2011-07-14 17:57:36 -0700 Thank you for comments! ojan: > Looking at EventDispatcher::dispatchEvent, we first fire the event to JS and then call defaultEventHandler. haraken, can you confirm that if you call preventDefault from the esc key's keydown event that we don't clear the search input? You are right. I confirmed that we can prevent WebCore from calling defaultEventHandler() by calling preventDefault() in JS. tkent: > > I think many existing key-binding code should be switched to keypress. > > eventSender.keyDown() dispatched keydown, keyup, and keypress. Indeed we may switch those key-binding codes to keypress, but at the present stage, there are several problems to try to handle those key-bindings in the keypress event. [1] xxxxxxInputType::handleKeypressEvent() is not called. HTMLInputElement.cpp: void HTMLInputElement::defaultEventHandler(Event* evt) { ...; /*** part1 ***/ // Call the base event handler before any of our own event handling for almost all events in text fields. // Makes editing keyboard handling take precedence over the keydown and keypress handling in this function. bool callBaseClassEarly = isTextField() && (evt->type() == eventNames().keydownEvent || evt->type() == eventNames().keypressEvent); if (callBaseClassEarly) { HTMLFormControlElementWithState::defaultEventHandler(evt); if (evt->defaultHandled()) return; } /*** part2 ***/ // DOMActivate events cause the input to be "activated" - in the case of image and submit inputs, this means // actually submitting the form. For reset inputs, the form is reset. These events are sent when the user clicks // on the element, or presses enter while it is the active element. JavaScript code wishing to activate the element // must dispatch a DOMActivate event - a click event will not do the job. if (evt->type() == eventNames().DOMActivateEvent) { m_inputType->handleDOMActivateEvent(evt); if (evt->defaultHandled()) return; } /*** part3 ***/ // Use key press event here since sending simulated mouse events // on key down blocks the proper sending of the key press event. if (evt->isKeyboardEvent() && evt->type() == eventNames().keypressEvent) { m_inputType->handleKeypressEvent(static_cast<KeyboardEvent*>(evt)); if (evt->defaultHandled()) return; } ...; } What is happening is that since HTMLFormControlElementWithState::defaultEventHandler(evt) calls setDefaultHandled() deep inside the call, the method returns at the end of part1 and thus m_inputType->handleKeypressEvent(static_cast<KeyboardEvent*>(evt)) is never called. I guess that this problem can be safely resolved just by reordering the above codes to part3 -> part2 -> part1. [2] EventSender::keyDown() does not dispatch a keypress event for control characters, including 'escape'. For example, in chromium... chromium/EventSender.cpp: void EventSender::keyDown(const CppArgumentList& arguments, CppVariant* result) { ...; webview()->handleInputEvent(eventDown); // keydown event m_shell->webViewHost()->clearEditCommand(); if (generateChar) { // only if it is not a control character... eventChar.type = WebInputEvent::Char; eventChar.keyIdentifier[0] = '\0'; webview()->handleInputEvent(eventChar); // keypress event } webview()->handleInputEvent(eventUp); // keyup event } Also, I confirmed that mac/EventSendingController.mm dispatches the keypress event only for non-control characters. I am not sure for efl, gtk, qt and win, but anyway, we definitely need per-platform changes. I think that it is possible to make the fix so that it always dispatches the keypress event, but I am not sure whether this fix is acceptable. 437488 8 tkent 2011-07-14 19:35:04 -0700 (In reply to comment #7) > [2] EventSender::keyDown() does not dispatch a keypress event for control characters, including 'escape'. For example, in chromium... I checked the specification: http://www.w3.org/TR/DOM-Level-3-Events/#event-type-keypress > A user agent must dispatch this event when a key is pressed down, if and only if that key normally produces a character value. I think it's the reason we don't produce keypress for control characters. So, using keydown event is very reasonable in this case. 437507 9 100922 haraken 2011-07-14 20:32:18 -0700 Created attachment 100922 Patch 437509 10 100667 haraken 2011-07-14 20:34:38 -0700 Comment on attachment 100667 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=100667&action=review >>> Source/WebCore/html/SearchInputType.cpp:110 >>> + input->onSearch(); >> >> setValueForUser() dispatches 'change' event and a JavaScript handler can delete 'input'. >> You need to use RefPtr<HTMLInputElement>. > > OK. I will fix it in the next patch. Done. 437511 11 100922 darin 2011-07-14 20:35:43 -0700 Comment on attachment 100922 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=100922&action=review > LayoutTests/fast/forms/input-search-press-escape-key.html:28 > + eventSender.keyDown("escape"); Why can’t we just use "\x1B" here? > Source/WebCore/html/SearchInputType.cpp:104 > + return; Why are we not calling TextFieldInputType::handleKeydownEvent in this case? > Source/WebCore/html/SearchInputType.cpp:113 > + event->setDefaultHandled(); > + } else > + TextFieldInputType::handleKeydownEvent(event); We'd normally use a return here instead of an else. 437512 12 darin 2011-07-14 20:36:18 -0700 On Mac escape should only clear the search field if we already have dismissed the menu. 437529 13 100927 haraken 2011-07-14 21:38:29 -0700 Created attachment 100927 Patch 437531 14 100922 haraken 2011-07-14 21:38:48 -0700 Comment on attachment 100922 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=100922&action=review >> LayoutTests/fast/forms/input-search-press-escape-key.html:28 >> + eventSender.keyDown("escape"); > > Why can’t we just use "\x1B" here? Great idea! I fixed it and removed all per-platform changes in EventSender. >> Source/WebCore/html/SearchInputType.cpp:104 >> + return; > > Why are we not calling TextFieldInputType::handleKeydownEvent in this case? Fixed. >> Source/WebCore/html/SearchInputType.cpp:113 >> + TextFieldInputType::handleKeydownEvent(event); > > We'd normally use a return here instead of an else. Fixed. 437533 15 haraken 2011-07-14 21:39:27 -0700 > On Mac escape should only clear the search field if we already have dismissed the menu. Do you mean the menu of the search field that suggests a list of matched candidates with the input value? On my Mac 10.6 environment, when I press 'escape', the search field is cleared even if the menu is being appeared. 437537 16 tkent 2011-07-14 21:54:14 -0700 (In reply to comment #15) > > On Mac escape should only clear the search field if we already have dismissed the menu. > > Do you mean the menu of the search field that suggests a list of matched candidates with the input value? On my Mac 10.6 environment, when I press 'escape', the search field is cleared even if the menu is being appeared. With search fields on the upper-right corner of Xcode and Safari 5, escape key dismisses a menu and doesn't clear the text. 437556 17 haraken 2011-07-14 22:34:41 -0700 darin: > On Mac escape should only clear the search field if we already have dismissed the menu. I manually confirmed on Mac Safari 5.0.5 that the search field is cleared only if we have dismissed the menu, using the following html: <input type="search" value="Test" results="20" onsearch="alert('onsearch')" /> tkent: > With search fields on the upper-right corner of Xcode and Safari 5, escape key dismisses a menu and doesn't clear the text. Thanks, I confirmed it. FYI: However, with search fields on the upper-right corner of "System Preferences", escape key clears the text even if a menu is being displayed. 437561 18 100927 tkent 2011-07-14 22:44:08 -0700 Comment on attachment 100927 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=100927&action=review r- because of patch conflicts. > LayoutTests/fast/forms/input-search-press-escape-key.html:65 > +} > + Please show a manual test instruction if there is no layoutTestController or eventSender. > Source/WebCore/html/SearchInputType.cpp:107 > + if (input->disabled() || input->readOnly()) > + return; TextFieldInputType::handleKeydownEvent() should be called even if the input is not editable. It doesn't affect any behavior. It's for consistency. 437579 19 100934 haraken 2011-07-14 23:09:55 -0700 Created attachment 100934 Patch 437582 20 100934 tkent 2011-07-14 23:19:59 -0700 Comment on attachment 100934 Patch r- because of patch conflicts 437594 21 100940 haraken 2011-07-14 23:35:44 -0700 Created attachment 100940 Patch 437597 22 100940 tkent 2011-07-14 23:50:31 -0700 Comment on attachment 100940 Patch ok 437623 23 100940 webkit.review.bot 2011-07-15 01:11:07 -0700 Comment on attachment 100940 Patch Clearing flags on attachment: 100940 Committed r91058: <http://trac.webkit.org/changeset/91058> 437624 24 webkit.review.bot 2011-07-15 01:11:13 -0700 All reviewed patches have been landed. Closing bug. 100667 2011-07-13 06:01:20 -0700 2011-07-14 20:34:38 -0700 Patch bug-51897-20110713220118.patch text/plain 12941 haraken U3VidmVyc2lvbiBSZXZpc2lvbjogOTA3OTUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCBjOTFhMDk1YTIwNjM2YjMzNTIxYjRk YWEwNmZlNDdjZTgzMDMyOGIxLi5mMTZhMjU0OTYxMWRmNTI3OGIyNzFiZmEwNzAxODNhZGRjMzg1 NjZlIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAKKzIwMTEtMDctMTMgIEtlbnRhcm8gSGFyYSAgPGhh cmFrZW5AZ29vZ2xlLmNvbT4KKworICAgICAgICBDbGVhciB0aGUgY29udGVudCBvZiBhIHNlYXJj aCBpbnB1dCBmb3JtIHdoZW4gJ0VzY2FwZScgaXMgcHJlc3NlZC4KKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUxODk3CisKKyAgICAgICAgVGhlIGFkZGVk IHRlc3QgY2hlY2tzIGlmIHRoZSB2YWx1ZSBpbiBhIHNlYXJjaCBpbnB1dCBmb3JtIGlzIGNsZWFy ZWQKKyAgICAgICAgYW5kIGEgJ3NlYXJjaCcgZXZlbnQgaXMgdHJpZ2dlcmVkLCB3aGVuIHdlIHBy ZXNzICdFc2NhcGUnIGtleS4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICAqIGZhc3QvZm9ybXMvaW5wdXQtc2VhcmNoLXByZXNzLWVzY2FwZS1rZXktZXhw ZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2Zvcm1zL2lucHV0LXNlYXJjaC1wcmVz cy1lc2NhcGUta2V5Lmh0bWw6IEFkZGVkLgorCiAyMDExLTA3LTExICBPamFuIFZhZmFpICA8b2ph bkBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgV2luNyByZWJhc2VsaW5lcyBhZnRlciBodHRwOi8v dHJhYy53ZWJraXQub3JnL2NoYW5nZXNldC85MDcwMS4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3Rz L2Zhc3QvZm9ybXMvaW5wdXQtc2VhcmNoLXByZXNzLWVzY2FwZS1rZXktZXhwZWN0ZWQudHh0IGIv TGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9pbnB1dC1zZWFyY2gtcHJlc3MtZXNjYXBlLWtleS1leHBl Y3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMC4uYjNjMDRkY2Y3MjJkODJjNjdiMmIwZWI5NTMyMjIwNTUyZmEx MzhjMAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMvaW5wdXQtc2Vh cmNoLXByZXNzLWVzY2FwZS1rZXktZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMTcgQEAKKworVGhp cyB0ZXN0cyBpZiB0aGUgdmFsdWUgaW4gYSBzZWFyY2ggaW5wdXQgZm9ybSBpcyBjbGVhcmVkIGFu ZCBhICdzZWFyY2gnIGV2ZW50IGlzIHRyaWdnZXJlZCwgd2hlbiB3ZSBwcmVzcyBFc2NhcGUga2V5 LiBUaGlzIHRlc3QgY2Fubm90IHJ1biBpbnRlcmFjdGl2ZWx5LgorCitQQVNTIGlucHV0LnZhbHVl IGlzICIiCitQQVNTIHNlYXJjaEV2ZW50T2JzZXJ2ZWQgaXMgdHJ1ZQorUEFTUyBpbnB1dC52YWx1 ZSBpcyAiIgorUEFTUyBzZWFyY2hFdmVudE9ic2VydmVkIGlzIHRydWUKK1BBU1MgaW5wdXQudmFs dWUgaXMgImZvbyIKK1BBU1Mgc2VhcmNoRXZlbnRPYnNlcnZlZCBpcyBmYWxzZQorUEFTUyBpbnB1 dC52YWx1ZSBpcyAiZm9vIgorUEFTUyBzZWFyY2hFdmVudE9ic2VydmVkIGlzIGZhbHNlCitQQVNT IGlucHV0LnZhbHVlIGlzICJmb28iCitQQVNTIHNlYXJjaEV2ZW50T2JzZXJ2ZWQgaXMgZmFsc2UK K1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQorCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL2lucHV0LXNlYXJjaC1wcmVzcy1lc2NhcGUt a2V5Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL2lucHV0LXNlYXJjaC1wcmVzcy1lc2Nh cGUta2V5Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uODNlZDJjZTI2ZjVkNTgzNWYzODhiY2VhZGE4Nzc0NGY0 OWZjYTEwOAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMvaW5wdXQt c2VhcmNoLXByZXNzLWVzY2FwZS1rZXkuaHRtbApAQCAtMCwwICsxLDgwIEBACis8IURPQ1RZUEUg aHRtbD4KKzxodG1sPgorPGhlYWQ+Cis8c2NyaXB0IHNyYz0iLi4vanMvcmVzb3VyY2VzL2pzLXRl c3QtcHJlLmpzIj48L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSJyZXNvdXJjZXMvY29tbW9uLmpzIj48 L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5PgorPGlucHV0IGlkPSJzZWFyY2giIHR5cGU9InNlYXJj aCIgb25zZWFyY2g9InNlYXJjaEV2ZW50RGlzcGF0Y2hlZCgpIiAvPgorPGRpdiBpZD0iY29uc29s ZSI+Cis8cD4KK1RoaXMgdGVzdHMgaWYgdGhlIHZhbHVlIGluIGEgc2VhcmNoIGlucHV0IGZvcm0g aXMgY2xlYXJlZCAKK2FuZCBhICdzZWFyY2gnIGV2ZW50IGlzIHRyaWdnZXJlZCwgd2hlbiB3ZSBw cmVzcyBFc2NhcGUga2V5LgorVGhpcyB0ZXN0IGNhbm5vdCBydW4gaW50ZXJhY3RpdmVseS4KKzwv cD4KKzwvZGl2PgorPHNjcmlwdD4KK3ZhciBzZWFyY2hFdmVudE9ic2VydmVkOworCitpZiAod2lu ZG93LmxheW91dFRlc3RDb250cm9sbGVyICYmIHdpbmRvdy5ldmVudFNlbmRlcikgeworICAgIHZh ciBpbnB1dCA9ICQoInNlYXJjaCIpOworICAgIHZhciBlbmFibGVkID0gZmFsc2U7CisgICAgdmFy IGRpc2FibGVkID0gdHJ1ZTsKKyAgICB2YXIgcmVhZG9ubHkgPSB0cnVlOworCisgICAgc2VhcmNo RXZlbnRPYnNlcnZlZCA9IGZhbHNlOworICAgIGlucHV0LmZvY3VzKCk7CisgICAgc2V0SW5wdXRB dHRyaWJ1dGVzKGlucHV0LCAiZm9vIiwgZW5hYmxlZCk7CisgICAgZXZlbnRTZW5kZXIua2V5RG93 bigiZXNjYXBlIik7CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCdpbnB1dC52YWx1ZScsICIi KTsKKyAgICBzaG91bGRCZSgnc2VhcmNoRXZlbnRPYnNlcnZlZCcsICd0cnVlJyk7CisgICAgaW5w dXQuYmx1cigpOworCisgICAgc2VhcmNoRXZlbnRPYnNlcnZlZCA9IGZhbHNlOworICAgIGlucHV0 LmZvY3VzKCk7CisgICAgc2V0SW5wdXRBdHRyaWJ1dGVzKGlucHV0LCAiIiwgZW5hYmxlZCk7Cisg ICAgZXZlbnRTZW5kZXIua2V5RG93bigiZXNjYXBlIik7CisgICAgc2hvdWxkQmVFcXVhbFRvU3Ry aW5nKCdpbnB1dC52YWx1ZScsICIiKTsKKyAgICBzaG91bGRCZSgnc2VhcmNoRXZlbnRPYnNlcnZl ZCcsICd0cnVlJyk7CisgICAgaW5wdXQuYmx1cigpOworCisgICAgc2VhcmNoRXZlbnRPYnNlcnZl ZCA9IGZhbHNlOworICAgIGlucHV0LmZvY3VzKCk7CisgICAgc2V0SW5wdXRBdHRyaWJ1dGVzKGlu cHV0LCAiZm9vIiwgZW5hYmxlZCwgcmVhZG9ubHkpOworICAgIGV2ZW50U2VuZGVyLmtleURvd24o ImVzY2FwZSIpOworICAgIHNob3VsZEJlRXF1YWxUb1N0cmluZygnaW5wdXQudmFsdWUnLCAiZm9v Iik7CisgICAgc2hvdWxkQmUoJ3NlYXJjaEV2ZW50T2JzZXJ2ZWQnLCAnZmFsc2UnKTsKKyAgICBp bnB1dC5ibHVyKCk7CisKKyAgICBzZWFyY2hFdmVudE9ic2VydmVkID0gZmFsc2U7CisgICAgaW5w dXQuZm9jdXMoKTsKKyAgICBzZXRJbnB1dEF0dHJpYnV0ZXMoaW5wdXQsICJmb28iLCBkaXNhYmxl ZCk7CisgICAgZXZlbnRTZW5kZXIua2V5RG93bigiZXNjYXBlIik7CisgICAgc2hvdWxkQmVFcXVh bFRvU3RyaW5nKCdpbnB1dC52YWx1ZScsICJmb28iKTsKKyAgICBzaG91bGRCZSgnc2VhcmNoRXZl bnRPYnNlcnZlZCcsICdmYWxzZScpOworICAgIGlucHV0LmJsdXIoKTsKKworICAgIHNlYXJjaEV2 ZW50T2JzZXJ2ZWQgPSBmYWxzZTsKKyAgICBpbnB1dC5mb2N1cygpOworICAgIHNldElucHV0QXR0 cmlidXRlcyhpbnB1dCwgImZvbyIsIGRpc2FibGVkLCByZWFkb25seSk7CisgICAgZXZlbnRTZW5k ZXIua2V5RG93bigiZXNjYXBlIik7CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCdpbnB1dC52 YWx1ZScsICJmb28iKTsKKyAgICBzaG91bGRCZSgnc2VhcmNoRXZlbnRPYnNlcnZlZCcsICdmYWxz ZScpOworICAgIGlucHV0LmJsdXIoKTsKK30KKworZnVuY3Rpb24gc2V0SW5wdXRBdHRyaWJ1dGVz KGlucHV0LCB0ZXh0LCBkaXNhYmxlZCwgcmVhZG9ubHkpIHsKKyAgICBpbnB1dC52YWx1ZSA9IHRl eHQ7CisgICAgaW5wdXQuZGlzYWJsZWQgPSBkaXNhYmxlZDsKKyAgICBpbnB1dC5yZWFkT25seSA9 ICEhcmVhZG9ubHk7Cit9CisKK2Z1bmN0aW9uIHNlYXJjaEV2ZW50RGlzcGF0Y2hlZCgpIHsKKyAg ICBzZWFyY2hFdmVudE9ic2VydmVkID0gdHJ1ZTsKK30KKwordmFyIHN1Y2Nlc3NmdWxseVBhcnNl ZCA9IHRydWU7Cis8L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSIuLi9qcy9yZXNvdXJjZXMvanMtdGVz dC1wb3N0LmpzIj48L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA0OGQ1 NDZiMjg1YmRlZGE1MzA3ZGY0NmUzYmU3NTg2NjE0ZDQ1ZTkwLi5hYWMyMWVjNzFmNGZhOWZlMjgw ZjZjNmYzN2ZlY2RkNmQ0MGEwNmQ1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VM b2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTkgQEAKKzIwMTEt MDctMTMgIEtlbnRhcm8gSGFyYSAgPGhhcmFrZW5AZ29vZ2xlLmNvbT4KKworICAgICAgICBDbGVh ciB0aGUgY29udGVudCBvZiBhIHNlYXJjaCBpbnB1dCBmb3JtIHdoZW4gJ0VzY2FwZScgaXMgcHJl c3NlZC4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUx ODk3CisKKyAgICAgICAgVGhpcyBjaGFuZ2UgYWRkZWQgaGFuZGxlS2V5ZG93bkV2ZW50KCkgdG8g YSBzZWFyY2ggaW5wdXQgZm9ybSwKKyAgICAgICAgd2hpY2ggY2xlYXJzIHRoZSBmb3JtIGFuZCB0 cmlnZ2VycyBhICdzZWFyY2gnIGV2ZW50IHdoZW4gJ0VzY2FwZScgaXMgcHJlc3NlZC4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBUZXN0OiBmYXN0L2Zv cm1zL2lucHV0LXNlYXJjaC1wcmVzcy1lc2NhcGUta2V5Lmh0bWwKKworICAgICAgICAqIGh0bWwv U2VhcmNoSW5wdXRUeXBlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNlYXJjaElucHV0VHlwZTo6 aGFuZGxlS2V5ZG93bkV2ZW50KToKKyAgICAgICAgKiBodG1sL1NlYXJjaElucHV0VHlwZS5oOgor CiAyMDExLTA3LTExICBMZXZpIFdlaW50cmF1YiAgPGxldml3QGNocm9taXVtLm9yZz4KIAogICAg ICAgICBTd2l0Y2ggbGluZVRvcCBhbmQgbGluZUJvdHRvbSB0byBuZXcgbGF5b3V0IHR5cGVzCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL1NlYXJjaElucHV0VHlwZS5jcHAgYi9Tb3Vy Y2UvV2ViQ29yZS9odG1sL1NlYXJjaElucHV0VHlwZS5jcHAKaW5kZXggZDZiYzg2ZWUwNzI0MWQ3 NGY1NjJiYjk4MjZkNGFlYjVkOWU2MzU0Ny4uMTQyOWI1MGEyMmI3ZmQyNDEzNWE5OWFhZjlkOTgw OTQ3MDhmYmEzOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9TZWFyY2hJbnB1dFR5 cGUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvU2VhcmNoSW5wdXRUeXBlLmNwcApAQCAt MzIsNiArMzIsNyBAQAogI2luY2x1ZGUgIlNlYXJjaElucHV0VHlwZS5oIgogCiAjaW5jbHVkZSAi SFRNTElucHV0RWxlbWVudC5oIgorI2luY2x1ZGUgIktleWJvYXJkRXZlbnQuaCIKICNpbmNsdWRl ICJTaGFkb3dSb290LmgiCiAjaW5jbHVkZSAiVGV4dENvbnRyb2xJbm5lckVsZW1lbnRzLmgiCiAj aW5jbHVkZSA8d3RmL1Bhc3NPd25QdHIuaD4KQEAgLTk3LDYgKzk4LDIxIEBAIEhUTUxFbGVtZW50 KiBTZWFyY2hJbnB1dFR5cGU6OmNhbmNlbEJ1dHRvbkVsZW1lbnQoKSBjb25zdAogICAgIHJldHVy biBtX2NhbmNlbEJ1dHRvbi5nZXQoKTsKIH0KIAordm9pZCBTZWFyY2hJbnB1dFR5cGU6OmhhbmRs ZUtleWRvd25FdmVudChLZXlib2FyZEV2ZW50KiBldmVudCkKK3sKKyAgICBpZiAoZWxlbWVudCgp LT5kaXNhYmxlZCgpIHx8IGVsZW1lbnQoKS0+cmVhZE9ubHkoKSkKKyAgICAgICAgcmV0dXJuOwor CisgICAgY29uc3QgU3RyaW5nJiBrZXkgPSBldmVudC0+a2V5SWRlbnRpZmllcigpOworICAgIGlm IChrZXkgPT0gIlUrMDAxQiIpIHsKKyAgICAgICAgSFRNTElucHV0RWxlbWVudCogaW5wdXQgPSBl bGVtZW50KCk7CisgICAgICAgIGlucHV0LT5zZXRWYWx1ZUZvclVzZXIoIiIpOworICAgICAgICBp bnB1dC0+b25TZWFyY2goKTsKKyAgICAgICAgZXZlbnQtPnNldERlZmF1bHRIYW5kbGVkKCk7Cisg ICAgfSBlbHNlCisgICAgICAgIFRleHRGaWVsZElucHV0VHlwZTo6aGFuZGxlS2V5ZG93bkV2ZW50 KGV2ZW50KTsKK30KKwogdm9pZCBTZWFyY2hJbnB1dFR5cGU6OmRlc3Ryb3lTaGFkb3dTdWJ0cmVl KCkKIHsKICAgICBUZXh0RmllbGRJbnB1dFR5cGU6OmRlc3Ryb3lTaGFkb3dTdWJ0cmVlKCk7CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL1NlYXJjaElucHV0VHlwZS5oIGIvU291cmNl L1dlYkNvcmUvaHRtbC9TZWFyY2hJbnB1dFR5cGUuaAppbmRleCA2OTk5ZDExZmZlNGZiNmFmZjIx YTI0ZDg4Zjc4YjVlMzNmMmY2NTgwLi44M2U1ZDg4OWRmYTE3OWVjNTA2MTM1MWJmNDM2OTYyN2I0 Yjg1MDM2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL1NlYXJjaElucHV0VHlwZS5o CisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvU2VhcmNoSW5wdXRUeXBlLmgKQEAgLTUyLDYgKzUy LDcgQEAgcHJpdmF0ZToKICAgICB2aXJ0dWFsIHZvaWQgZGVzdHJveVNoYWRvd1N1YnRyZWUoKTsK ICAgICB2aXJ0dWFsIEhUTUxFbGVtZW50KiByZXN1bHRzQnV0dG9uRWxlbWVudCgpIGNvbnN0Owog ICAgIHZpcnR1YWwgSFRNTEVsZW1lbnQqIGNhbmNlbEJ1dHRvbkVsZW1lbnQoKSBjb25zdDsKKyAg ICB2aXJ0dWFsIHZvaWQgaGFuZGxlS2V5ZG93bkV2ZW50KEtleWJvYXJkRXZlbnQqKTsKIAogICAg IFJlZlB0cjxIVE1MRWxlbWVudD4gbV9yZXN1bHRzQnV0dG9uOwogICAgIFJlZlB0cjxIVE1MRWxl bWVudD4gbV9jYW5jZWxCdXR0b247CmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29s cy9DaGFuZ2VMb2cKaW5kZXggNzZlZjhlNjQ0NWI0NWVkMDU0Njg0NzZlM2FlMjEwYWJkNjA3ZDBh NS4uNGMxODk5NThlNDcxMmIzMDA5MmY1Yzk3Yzk1OWMwZTEwNDliNWQ5NiAxMDA2NDQKLS0tIGEv VG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI1IEBACisy MDExLTA3LTEzICBLZW50YXJvIEhhcmEgIDxoYXJha2VuQGdvb2dsZS5jb20+CisKKyAgICAgICAg Q2xlYXIgdGhlIGNvbnRlbnQgb2YgYSBzZWFyY2ggaW5wdXQgZm9ybSB3aGVuICdFc2NhcGUnIGlz IHByZXNzZWQuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD01MTg5NworCisgICAgICAgIFRoaXMgY2hhbmdlIGVuYWJsZXMgdXMgdG8gcHJlc3MgYW4gJ2Vz Y2FwZScga2V5IGJ5IGV2ZW50U2VuZGVyLmtleURvd24oImVzY2FwZSIpLgorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvY2hy b21pdW0vRXZlbnRTZW5kZXIuY3BwOgorICAgICAgICAoRXZlbnRTZW5kZXI6OmtleURvd24pOiBB ZGRlZCB0aGUgJ2VzY2FwZScga2V5LgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL2VmbC9FdmVu dFNlbmRlci5jcHA6CisgICAgICAgIChrZXlOYW1lRnJvbUpTVmFsdWUpOiBEaXR0by4KKyAgICAg ICAgKiBEdW1wUmVuZGVyVHJlZS9ndGsvRXZlbnRTZW5kZXIuY3BwOgorICAgICAgICAoa2V5RG93 bkNhbGxiYWNrKTogRGl0dG8uCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvbWFjL0V2ZW50U2Vu ZGluZ0NvbnRyb2xsZXIubW06CisgICAgICAgICgtW0V2ZW50U2VuZGluZ0NvbnRyb2xsZXIga2V5 RG93bjp3aXRoTW9kaWZpZXJzOndpdGhMb2NhdGlvbjpdKTogRGl0dG8uCisgICAgICAgICogRHVt cFJlbmRlclRyZWUvcXQvRXZlbnRTZW5kZXJRdC5jcHA6CisgICAgICAgIChFdmVudFNlbmRlcjo6 a2V5RG93bik6IERpdHRvLgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL3dpbi9FdmVudFNlbmRl ci5jcHA6CisgICAgICAgIChrZXlEb3duQ2FsbGJhY2spOiBEaXR0by4KKwogMjAxMS0wNy0xMSAg Unlvc3VrZSBOaXdhICA8cm5pd2FAd2Via2l0Lm9yZz4KIAogICAgICAgICB3ZWJraXQtcGF0Y2gg cm9sbC1jaHJvbWl1bS1kZXBzIG5vIGxvbmdlciB3b3JrcwpkaWZmIC0tZ2l0IGEvVG9vbHMvRHVt cFJlbmRlclRyZWUvY2hyb21pdW0vRXZlbnRTZW5kZXIuY3BwIGIvVG9vbHMvRHVtcFJlbmRlclRy ZWUvY2hyb21pdW0vRXZlbnRTZW5kZXIuY3BwCmluZGV4IGJmZWUwNzc4Mjg5Njg5Mzc5Zjk4ZmM1 MzVkOTc0NTkxZTdiNzcxOTguLjk4OWJkNjExMjZhNzhiNTVlZGRkZmI2OTVjMWNlOWNiMzZjMDYy NjEgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL0V2ZW50U2VuZGVy LmNwcAorKysgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9FdmVudFNlbmRlci5jcHAK QEAgLTUzMiw2ICs1MzIsOSBAQCB2b2lkIEV2ZW50U2VuZGVyOjprZXlEb3duKGNvbnN0IENwcEFy Z3VtZW50TGlzdCYgYXJndW1lbnRzLCBDcHBWYXJpYW50KiByZXN1bHQpCiAgICAgICAgIGNvZGUg PSB3ZWJraXRfc3VwcG9ydDo6VktFWV9IT01FOwogICAgIGVsc2UgaWYgKCJlbmQiID09IGNvZGVT dHIpCiAgICAgICAgIGNvZGUgPSB3ZWJraXRfc3VwcG9ydDo6VktFWV9FTkQ7CisgICAgZWxzZSBp ZiAoImVzY2FwZSIgPT0gY29kZVN0cikKKyAgICAgICAgLy8gRklYTUU6IENoYW5nZSB0aGlzIHRv IHdlYmtpdF9zdXBwb3J0OjpWS0VZX0VTQ0FQRS4KKyAgICAgICAgY29kZSA9IDB4MUI7CiAgICAg ZWxzZSBpZiAoInByaW50U2NyZWVuIiA9PSBjb2RlU3RyKQogICAgICAgICBjb2RlID0gd2Via2l0 X3N1cHBvcnQ6OlZLRVlfU05BUFNIT1Q7CiAgICAgZWxzZSBpZiAoIm1lbnUiID09IGNvZGVTdHIp CmRpZmYgLS1naXQgYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9lZmwvRXZlbnRTZW5kZXIuY3BwIGIv VG9vbHMvRHVtcFJlbmRlclRyZWUvZWZsL0V2ZW50U2VuZGVyLmNwcAppbmRleCBlZGQwYTgzZDE4 YWE2ZjVlZGZiZTg0ZDEyOTdhMDE4ZGFmYzBlMjRhLi40YjA0ODA2Yjg2ODRiMzIzNDBhNGVjMTJj M2UzZThkYTgyMDQ3NmYzIDEwMDY0NAotLS0gYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9lZmwvRXZl bnRTZW5kZXIuY3BwCisrKyBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2VmbC9FdmVudFNlbmRlci5j cHAKQEAgLTM1NSw2ICszNTUsOCBAQCBzdGF0aWMgY29uc3QgY2hhcioga2V5TmFtZUZyb21KU1Zh bHVlKEpTU3RyaW5nUmVmIGNoYXJhY3RlcikKICAgICAgICAgcmV0dXJuICJJbnNlcnQiOwogICAg IGlmIChlcXVhbHMoY2hhcmFjdGVyLCAiZGVsZXRlIikpCiAgICAgICAgIHJldHVybiAiRGVsZXRl IjsKKyAgICBpZiAoZXF1YWxzKGNoYXJhY3RlciwgImVzY2FwZSIpKQorICAgICAgICByZXR1cm4g IkVzY2FwZSI7CiAgICAgaWYgKGVxdWFscyhjaGFyYWN0ZXIsICJwcmludFNjcmVlbiIpKQogICAg ICAgICByZXR1cm4gIlByaW50IjsKICAgICBpZiAoZXF1YWxzKGNoYXJhY3RlciwgIm1lbnUiKSkK ZGlmZiAtLWdpdCBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9FdmVudFNlbmRlci5jcHAgYi9U b29scy9EdW1wUmVuZGVyVHJlZS9ndGsvRXZlbnRTZW5kZXIuY3BwCmluZGV4IDdkYTQ5NWZmYWVj Yjc0NTM0ZGJmZDUzMTFiZmQ2NmE5MThlMmQwYmIuLjU1ZjMwYmNkYmE4MmQ2ZjdjZDEzMzZkNWQy NjIxMzMyMmQ1YjZmMTkgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9FdmVu dFNlbmRlci5jcHAKKysrIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvZ3RrL0V2ZW50U2VuZGVyLmNw cApAQCAtNjY5LDYgKzY2OSw4IEBAIHN0YXRpYyBKU1ZhbHVlUmVmIGtleURvd25DYWxsYmFjayhK U0NvbnRleHRSZWYgY29udGV4dCwgSlNPYmplY3RSZWYgZnVuY3Rpb24sIEpTCiAgICAgICAgICAg ICBnZGtLZXlTeW0gPSBHREtfSW5zZXJ0OwogICAgICAgICBlbHNlIGlmIChKU1N0cmluZ0lzRXF1 YWxUb1VURjhDU3RyaW5nKGNoYXJhY3RlciwgImRlbGV0ZSIpKQogICAgICAgICAgICAgZ2RrS2V5 U3ltID0gR0RLX0RlbGV0ZTsKKyAgICAgICAgZWxzZSBpZiAoSlNTdHJpbmdJc0VxdWFsVG9VVEY4 Q1N0cmluZyhjaGFyYWN0ZXIsICJlc2NhcGUiKSkKKyAgICAgICAgICAgIGdka0tleVN5bSA9IEdE S19Fc2NhcGU7CiAgICAgICAgIGVsc2UgaWYgKEpTU3RyaW5nSXNFcXVhbFRvVVRGOENTdHJpbmco Y2hhcmFjdGVyLCAicHJpbnRTY3JlZW4iKSkKICAgICAgICAgICAgIGdka0tleVN5bSA9IEdES19Q cmludDsKICAgICAgICAgZWxzZSBpZiAoSlNTdHJpbmdJc0VxdWFsVG9VVEY4Q1N0cmluZyhjaGFy YWN0ZXIsICJtZW51IikpCmRpZmYgLS1naXQgYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9tYWMvRXZl bnRTZW5kaW5nQ29udHJvbGxlci5tbSBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9FdmVudFNl bmRpbmdDb250cm9sbGVyLm1tCmluZGV4IGYwN2E0M2U4N2JlZmZlZmM5ODU4MDhjZjA3N2ZiOWQw ZTJlMzdkYmMuLjEzN2NiNzYwYzYwZTM2ODkyNGZmZjI4ODVjODE3MjgyYjhjMzUzZjQgMTAwNjQ0 Ci0tLSBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9FdmVudFNlbmRpbmdDb250cm9sbGVyLm1t CisrKyBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9FdmVudFNlbmRpbmdDb250cm9sbGVyLm1t CkBAIC02MTAsNiArNjEwLDEwIEBAIHN0YXRpYyBpbnQgYnVpbGRNb2RpZmllckZsYWdzKGNvbnN0 IFdlYlNjcmlwdE9iamVjdCogbW9kaWZpZXJzKQogICAgICAgICBjb25zdCB1bmljaGFyIGNoID0g TlNEZWxldGVGdW5jdGlvbktleTsKICAgICAgICAgZXZlbnRDaGFyYWN0ZXIgPSBbTlNTdHJpbmcg c3RyaW5nV2l0aENoYXJhY3RlcnM6JmNoIGxlbmd0aDoxXTsKICAgICAgICAga2V5Q29kZSA9IDB4 NzU7CisgICAgfSBlbHNlIGlmIChbY2hhcmFjdGVyIGlzRXF1YWxUb1N0cmluZzpAImVzY2FwZSJd KSB7CisgICAgICAgIGNvbnN0IHVuaWNoYXIgY2ggPSAweDFCOworICAgICAgICBldmVudENoYXJh Y3RlciA9IFtOU1N0cmluZyBzdHJpbmdXaXRoQ2hhcmFjdGVyczomY2ggbGVuZ3RoOjFdOworICAg ICAgICBrZXlDb2RlID0gMHgzNTsKICAgICB9IGVsc2UgaWYgKFtjaGFyYWN0ZXIgaXNFcXVhbFRv U3RyaW5nOkAicHJpbnRTY3JlZW4iXSkgewogICAgICAgICBjb25zdCB1bmljaGFyIGNoID0gTlNQ cmludFNjcmVlbkZ1bmN0aW9uS2V5OwogICAgICAgICBldmVudENoYXJhY3RlciA9IFtOU1N0cmlu ZyBzdHJpbmdXaXRoQ2hhcmFjdGVyczomY2ggbGVuZ3RoOjFdOwpkaWZmIC0tZ2l0IGEvVG9vbHMv RHVtcFJlbmRlclRyZWUvcXQvRXZlbnRTZW5kZXJRdC5jcHAgYi9Ub29scy9EdW1wUmVuZGVyVHJl ZS9xdC9FdmVudFNlbmRlclF0LmNwcAppbmRleCAxZWNiNzM5N2JkZjg3MjQ4ZTMxYWJkNjRlZDli YWY1MzVmZDk5MTg1Li45YzVlYTcyZGQ3ZWY2OTYwZGI0M2VhYmNjMTY0ZDBjNjcxMjMwNjQ3IDEw MDY0NAotLS0gYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9xdC9FdmVudFNlbmRlclF0LmNwcAorKysg Yi9Ub29scy9EdW1wUmVuZGVyVHJlZS9xdC9FdmVudFNlbmRlclF0LmNwcApAQCAtMzU2LDYgKzM1 Niw5IEBAIHZvaWQgRXZlbnRTZW5kZXI6OmtleURvd24oY29uc3QgUVN0cmluZyYgc3RyaW5nLCBj b25zdCBRU3RyaW5nTGlzdCYgbW9kaWZpZXJzLCB1CiAgICAgICAgIH0gZWxzZSBpZiAoc3RyaW5n ID09IFFMYXRpbjFTdHJpbmcoImRlbGV0ZSIpKSB7CiAgICAgICAgICAgICBzID0gUVN0cmluZygp OwogICAgICAgICAgICAgY29kZSA9IFF0OjpLZXlfRGVsZXRlOworICAgICAgICB9IGVsc2UgaWYg KHN0cmluZyA9PSBRTGF0aW4xU3RyaW5nKCJlc2NhcGUiKSkgeworICAgICAgICAgICAgcyA9IFFT dHJpbmcoKTsKKyAgICAgICAgICAgIGNvZGUgPSBRdDo6S2V5X0VzY2FwZTsKICAgICAgICAgfSBl bHNlIGlmIChzdHJpbmcgPT0gUUxhdGluMVN0cmluZygicHJpbnRTY3JlZW4iKSkgewogICAgICAg ICAgICAgcyA9IFFTdHJpbmcoKTsKICAgICAgICAgICAgIGNvZGUgPSBRdDo6S2V5X1ByaW50Owpk aWZmIC0tZ2l0IGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0V2ZW50U2VuZGVyLmNwcCBiL1Rv b2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9FdmVudFNlbmRlci5jcHAKaW5kZXggZTFjNWNkNTAyM2Ux OGYxYzVmNjgwMzVmMTRmZjRhMDVkNDEyZDliYi4uYWRmNmJhMDUzYWIyMjZjZWI5YzBjZGY5NmI4 NDA1NWU1M2VlZDcyMCAxMDA2NDQKLS0tIGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0V2ZW50 U2VuZGVyLmNwcAorKysgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS93aW4vRXZlbnRTZW5kZXIuY3Bw CkBAIC00NzEsNiArNDcxLDggQEAgc3RhdGljIEpTVmFsdWVSZWYga2V5RG93bkNhbGxiYWNrKEpT Q29udGV4dFJlZiBjb250ZXh0LCBKU09iamVjdFJlZiBmdW5jdGlvbiwgSlMKICAgICAgICAgdmly dHVhbEtleUNvZGUgPSBWS19JTlNFUlQ7CiAgICAgZWxzZSBpZiAoSlNTdHJpbmdJc0VxdWFsVG9V VEY4Q1N0cmluZyhjaGFyYWN0ZXIsICJkZWxldGUiKSkKICAgICAgICAgdmlydHVhbEtleUNvZGUg PSBWS19ERUxFVEU7CisgICAgZWxzZSBpZiAoSlNTdHJpbmdJc0VxdWFsVG9VVEY4Q1N0cmluZyhj aGFyYWN0ZXIsICJlc2NhcGUiKSkKKyAgICAgICAgdmlydHVhbEtleUNvZGUgPSBWS19FU0NBUEU7 CiAgICAgZWxzZSBpZiAoSlNTdHJpbmdJc0VxdWFsVG9VVEY4Q1N0cmluZyhjaGFyYWN0ZXIsICJw cmludFNjcmVlbiIpKQogICAgICAgICB2aXJ0dWFsS2V5Q29kZSA9IFZLX1NOQVBTSE9UOwogICAg IGVsc2UgaWYgKEpTU3RyaW5nSXNFcXVhbFRvVVRGOENTdHJpbmcoY2hhcmFjdGVyLCAibWVudSIp KQo= 100922 2011-07-14 20:32:18 -0700 2011-07-14 23:09:42 -0700 Patch bug-51897-20110715123216.patch text/plain 12889 haraken U3VidmVyc2lvbiBSZXZpc2lvbjogOTA3OTUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCBjOTFhMDk1YTIwNjM2YjMzNTIxYjRk YWEwNmZlNDdjZTgzMDMyOGIxLi42NDNjNDE0ZjkxZWRhNzQ4ZGFlYzgwYmE0NjYxYTBkNmI3NWY1 NGU3IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAKKzIwMTEtMDctMTQgIEtlbnRhcm8gSGFyYSAgPGhh cmFrZW5AZ29vZ2xlLmNvbT4KKworICAgICAgICBDbGVhciB0aGUgY29udGVudCBvZiBhIHNlYXJj aCBpbnB1dCBmb3JtIHdoZW4gJ0VzY2FwZScgaXMgcHJlc3NlZC4KKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUxODk3CisKKyAgICAgICAgVGhlIGFkZGVk IHRlc3QgY2hlY2tzIGlmIHRoZSB2YWx1ZSBpbiBhIHNlYXJjaCBpbnB1dCBmb3JtIGlzIGNsZWFy ZWQKKyAgICAgICAgYW5kIGEgJ3NlYXJjaCcgZXZlbnQgaXMgdHJpZ2dlcmVkLCB3aGVuIHdlIHBy ZXNzICdFc2NhcGUnIGtleS4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICAqIGZhc3QvZm9ybXMvaW5wdXQtc2VhcmNoLXByZXNzLWVzY2FwZS1rZXktZXhw ZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2Zvcm1zL2lucHV0LXNlYXJjaC1wcmVz cy1lc2NhcGUta2V5Lmh0bWw6IEFkZGVkLgorCiAyMDExLTA3LTExICBPamFuIFZhZmFpICA8b2ph bkBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgV2luNyByZWJhc2VsaW5lcyBhZnRlciBodHRwOi8v dHJhYy53ZWJraXQub3JnL2NoYW5nZXNldC85MDcwMS4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3Rz L2Zhc3QvZm9ybXMvaW5wdXQtc2VhcmNoLXByZXNzLWVzY2FwZS1rZXktZXhwZWN0ZWQudHh0IGIv TGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9pbnB1dC1zZWFyY2gtcHJlc3MtZXNjYXBlLWtleS1leHBl Y3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMC4uYjNjMDRkY2Y3MjJkODJjNjdiMmIwZWI5NTMyMjIwNTUyZmEx MzhjMAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMvaW5wdXQtc2Vh cmNoLXByZXNzLWVzY2FwZS1rZXktZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMTcgQEAKKworVGhp cyB0ZXN0cyBpZiB0aGUgdmFsdWUgaW4gYSBzZWFyY2ggaW5wdXQgZm9ybSBpcyBjbGVhcmVkIGFu ZCBhICdzZWFyY2gnIGV2ZW50IGlzIHRyaWdnZXJlZCwgd2hlbiB3ZSBwcmVzcyBFc2NhcGUga2V5 LiBUaGlzIHRlc3QgY2Fubm90IHJ1biBpbnRlcmFjdGl2ZWx5LgorCitQQVNTIGlucHV0LnZhbHVl IGlzICIiCitQQVNTIHNlYXJjaEV2ZW50T2JzZXJ2ZWQgaXMgdHJ1ZQorUEFTUyBpbnB1dC52YWx1 ZSBpcyAiIgorUEFTUyBzZWFyY2hFdmVudE9ic2VydmVkIGlzIHRydWUKK1BBU1MgaW5wdXQudmFs dWUgaXMgImZvbyIKK1BBU1Mgc2VhcmNoRXZlbnRPYnNlcnZlZCBpcyBmYWxzZQorUEFTUyBpbnB1 dC52YWx1ZSBpcyAiZm9vIgorUEFTUyBzZWFyY2hFdmVudE9ic2VydmVkIGlzIGZhbHNlCitQQVNT IGlucHV0LnZhbHVlIGlzICJmb28iCitQQVNTIHNlYXJjaEV2ZW50T2JzZXJ2ZWQgaXMgZmFsc2UK K1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQorCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL2lucHV0LXNlYXJjaC1wcmVzcy1lc2NhcGUt a2V5Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL2lucHV0LXNlYXJjaC1wcmVzcy1lc2Nh cGUta2V5Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uODNlZDJjZTI2ZjVkNTgzNWYzODhiY2VhZGE4Nzc0NGY0 OWZjYTEwOAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMvaW5wdXQt c2VhcmNoLXByZXNzLWVzY2FwZS1rZXkuaHRtbApAQCAtMCwwICsxLDgwIEBACis8IURPQ1RZUEUg aHRtbD4KKzxodG1sPgorPGhlYWQ+Cis8c2NyaXB0IHNyYz0iLi4vanMvcmVzb3VyY2VzL2pzLXRl c3QtcHJlLmpzIj48L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSJyZXNvdXJjZXMvY29tbW9uLmpzIj48 L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5PgorPGlucHV0IGlkPSJzZWFyY2giIHR5cGU9InNlYXJj aCIgb25zZWFyY2g9InNlYXJjaEV2ZW50RGlzcGF0Y2hlZCgpIiAvPgorPGRpdiBpZD0iY29uc29s ZSI+Cis8cD4KK1RoaXMgdGVzdHMgaWYgdGhlIHZhbHVlIGluIGEgc2VhcmNoIGlucHV0IGZvcm0g aXMgY2xlYXJlZCAKK2FuZCBhICdzZWFyY2gnIGV2ZW50IGlzIHRyaWdnZXJlZCwgd2hlbiB3ZSBw cmVzcyBFc2NhcGUga2V5LgorVGhpcyB0ZXN0IGNhbm5vdCBydW4gaW50ZXJhY3RpdmVseS4KKzwv cD4KKzwvZGl2PgorPHNjcmlwdD4KK3ZhciBzZWFyY2hFdmVudE9ic2VydmVkOworCitpZiAod2lu ZG93LmxheW91dFRlc3RDb250cm9sbGVyICYmIHdpbmRvdy5ldmVudFNlbmRlcikgeworICAgIHZh ciBpbnB1dCA9ICQoInNlYXJjaCIpOworICAgIHZhciBlbmFibGVkID0gZmFsc2U7CisgICAgdmFy IGRpc2FibGVkID0gdHJ1ZTsKKyAgICB2YXIgcmVhZG9ubHkgPSB0cnVlOworCisgICAgc2VhcmNo RXZlbnRPYnNlcnZlZCA9IGZhbHNlOworICAgIGlucHV0LmZvY3VzKCk7CisgICAgc2V0SW5wdXRB dHRyaWJ1dGVzKGlucHV0LCAiZm9vIiwgZW5hYmxlZCk7CisgICAgZXZlbnRTZW5kZXIua2V5RG93 bigiZXNjYXBlIik7CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCdpbnB1dC52YWx1ZScsICIi KTsKKyAgICBzaG91bGRCZSgnc2VhcmNoRXZlbnRPYnNlcnZlZCcsICd0cnVlJyk7CisgICAgaW5w dXQuYmx1cigpOworCisgICAgc2VhcmNoRXZlbnRPYnNlcnZlZCA9IGZhbHNlOworICAgIGlucHV0 LmZvY3VzKCk7CisgICAgc2V0SW5wdXRBdHRyaWJ1dGVzKGlucHV0LCAiIiwgZW5hYmxlZCk7Cisg ICAgZXZlbnRTZW5kZXIua2V5RG93bigiZXNjYXBlIik7CisgICAgc2hvdWxkQmVFcXVhbFRvU3Ry aW5nKCdpbnB1dC52YWx1ZScsICIiKTsKKyAgICBzaG91bGRCZSgnc2VhcmNoRXZlbnRPYnNlcnZl ZCcsICd0cnVlJyk7CisgICAgaW5wdXQuYmx1cigpOworCisgICAgc2VhcmNoRXZlbnRPYnNlcnZl ZCA9IGZhbHNlOworICAgIGlucHV0LmZvY3VzKCk7CisgICAgc2V0SW5wdXRBdHRyaWJ1dGVzKGlu cHV0LCAiZm9vIiwgZW5hYmxlZCwgcmVhZG9ubHkpOworICAgIGV2ZW50U2VuZGVyLmtleURvd24o ImVzY2FwZSIpOworICAgIHNob3VsZEJlRXF1YWxUb1N0cmluZygnaW5wdXQudmFsdWUnLCAiZm9v Iik7CisgICAgc2hvdWxkQmUoJ3NlYXJjaEV2ZW50T2JzZXJ2ZWQnLCAnZmFsc2UnKTsKKyAgICBp bnB1dC5ibHVyKCk7CisKKyAgICBzZWFyY2hFdmVudE9ic2VydmVkID0gZmFsc2U7CisgICAgaW5w dXQuZm9jdXMoKTsKKyAgICBzZXRJbnB1dEF0dHJpYnV0ZXMoaW5wdXQsICJmb28iLCBkaXNhYmxl ZCk7CisgICAgZXZlbnRTZW5kZXIua2V5RG93bigiZXNjYXBlIik7CisgICAgc2hvdWxkQmVFcXVh bFRvU3RyaW5nKCdpbnB1dC52YWx1ZScsICJmb28iKTsKKyAgICBzaG91bGRCZSgnc2VhcmNoRXZl bnRPYnNlcnZlZCcsICdmYWxzZScpOworICAgIGlucHV0LmJsdXIoKTsKKworICAgIHNlYXJjaEV2 ZW50T2JzZXJ2ZWQgPSBmYWxzZTsKKyAgICBpbnB1dC5mb2N1cygpOworICAgIHNldElucHV0QXR0 cmlidXRlcyhpbnB1dCwgImZvbyIsIGRpc2FibGVkLCByZWFkb25seSk7CisgICAgZXZlbnRTZW5k ZXIua2V5RG93bigiZXNjYXBlIik7CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCdpbnB1dC52 YWx1ZScsICJmb28iKTsKKyAgICBzaG91bGRCZSgnc2VhcmNoRXZlbnRPYnNlcnZlZCcsICdmYWxz ZScpOworICAgIGlucHV0LmJsdXIoKTsKK30KKworZnVuY3Rpb24gc2V0SW5wdXRBdHRyaWJ1dGVz KGlucHV0LCB0ZXh0LCBkaXNhYmxlZCwgcmVhZG9ubHkpIHsKKyAgICBpbnB1dC52YWx1ZSA9IHRl eHQ7CisgICAgaW5wdXQuZGlzYWJsZWQgPSBkaXNhYmxlZDsKKyAgICBpbnB1dC5yZWFkT25seSA9 ICEhcmVhZG9ubHk7Cit9CisKK2Z1bmN0aW9uIHNlYXJjaEV2ZW50RGlzcGF0Y2hlZCgpIHsKKyAg ICBzZWFyY2hFdmVudE9ic2VydmVkID0gdHJ1ZTsKK30KKwordmFyIHN1Y2Nlc3NmdWxseVBhcnNl ZCA9IHRydWU7Cis8L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSIuLi9qcy9yZXNvdXJjZXMvanMtdGVz dC1wb3N0LmpzIj48L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA0OGQ1 NDZiMjg1YmRlZGE1MzA3ZGY0NmUzYmU3NTg2NjE0ZDQ1ZTkwLi42NDk5NTg3M2QyM2FlMDBmZTNj OTdiYmMyZTA5YjExYWQxMDJhYzBhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VM b2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTkgQEAKKzIwMTEt MDctMTQgIEtlbnRhcm8gSGFyYSAgPGhhcmFrZW5AZ29vZ2xlLmNvbT4KKworICAgICAgICBDbGVh ciB0aGUgY29udGVudCBvZiBhIHNlYXJjaCBpbnB1dCBmb3JtIHdoZW4gJ0VzY2FwZScgaXMgcHJl c3NlZC4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUx ODk3CisKKyAgICAgICAgVGhpcyBjaGFuZ2UgYWRkZWQgaGFuZGxlS2V5ZG93bkV2ZW50KCkgdG8g YSBzZWFyY2ggaW5wdXQgZm9ybSwKKyAgICAgICAgd2hpY2ggY2xlYXJzIHRoZSBmb3JtIGFuZCB0 cmlnZ2VycyBhICdzZWFyY2gnIGV2ZW50IHdoZW4gJ0VzY2FwZScgaXMgcHJlc3NlZC4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBUZXN0OiBmYXN0L2Zv cm1zL2lucHV0LXNlYXJjaC1wcmVzcy1lc2NhcGUta2V5Lmh0bWwKKworICAgICAgICAqIGh0bWwv U2VhcmNoSW5wdXRUeXBlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNlYXJjaElucHV0VHlwZTo6 aGFuZGxlS2V5ZG93bkV2ZW50KToKKyAgICAgICAgKiBodG1sL1NlYXJjaElucHV0VHlwZS5oOgor CiAyMDExLTA3LTExICBMZXZpIFdlaW50cmF1YiAgPGxldml3QGNocm9taXVtLm9yZz4KIAogICAg ICAgICBTd2l0Y2ggbGluZVRvcCBhbmQgbGluZUJvdHRvbSB0byBuZXcgbGF5b3V0IHR5cGVzCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL1NlYXJjaElucHV0VHlwZS5jcHAgYi9Tb3Vy Y2UvV2ViQ29yZS9odG1sL1NlYXJjaElucHV0VHlwZS5jcHAKaW5kZXggZDZiYzg2ZWUwNzI0MWQ3 NGY1NjJiYjk4MjZkNGFlYjVkOWU2MzU0Ny4uMDdmOTBmYjU4YTc4MDIzZDdkYzk2MDYzYzU0ZDJm YjQyNzdhMGI5OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9TZWFyY2hJbnB1dFR5 cGUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvU2VhcmNoSW5wdXRUeXBlLmNwcApAQCAt MzIsNiArMzIsNyBAQAogI2luY2x1ZGUgIlNlYXJjaElucHV0VHlwZS5oIgogCiAjaW5jbHVkZSAi SFRNTElucHV0RWxlbWVudC5oIgorI2luY2x1ZGUgIktleWJvYXJkRXZlbnQuaCIKICNpbmNsdWRl ICJTaGFkb3dSb290LmgiCiAjaW5jbHVkZSAiVGV4dENvbnRyb2xJbm5lckVsZW1lbnRzLmgiCiAj aW5jbHVkZSA8d3RmL1Bhc3NPd25QdHIuaD4KQEAgLTk3LDYgKzk4LDIxIEBAIEhUTUxFbGVtZW50 KiBTZWFyY2hJbnB1dFR5cGU6OmNhbmNlbEJ1dHRvbkVsZW1lbnQoKSBjb25zdAogICAgIHJldHVy biBtX2NhbmNlbEJ1dHRvbi5nZXQoKTsKIH0KIAordm9pZCBTZWFyY2hJbnB1dFR5cGU6OmhhbmRs ZUtleWRvd25FdmVudChLZXlib2FyZEV2ZW50KiBldmVudCkKK3sKKyAgICBpZiAoZWxlbWVudCgp LT5kaXNhYmxlZCgpIHx8IGVsZW1lbnQoKS0+cmVhZE9ubHkoKSkKKyAgICAgICAgcmV0dXJuOwor CisgICAgY29uc3QgU3RyaW5nJiBrZXkgPSBldmVudC0+a2V5SWRlbnRpZmllcigpOworICAgIGlm IChrZXkgPT0gIlUrMDAxQiIpIHsKKyAgICAgICAgUmVmUHRyPEhUTUxJbnB1dEVsZW1lbnQ+IGlu cHV0ID0gZWxlbWVudCgpOworICAgICAgICBpbnB1dC0+c2V0VmFsdWVGb3JVc2VyKCIiKTsKKyAg ICAgICAgaW5wdXQtPm9uU2VhcmNoKCk7CisgICAgICAgIGV2ZW50LT5zZXREZWZhdWx0SGFuZGxl ZCgpOworICAgIH0gZWxzZQorICAgICAgICBUZXh0RmllbGRJbnB1dFR5cGU6OmhhbmRsZUtleWRv d25FdmVudChldmVudCk7Cit9CisKIHZvaWQgU2VhcmNoSW5wdXRUeXBlOjpkZXN0cm95U2hhZG93 U3VidHJlZSgpCiB7CiAgICAgVGV4dEZpZWxkSW5wdXRUeXBlOjpkZXN0cm95U2hhZG93U3VidHJl ZSgpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9TZWFyY2hJbnB1dFR5cGUuaCBi L1NvdXJjZS9XZWJDb3JlL2h0bWwvU2VhcmNoSW5wdXRUeXBlLmgKaW5kZXggNjk5OWQxMWZmZTRm YjZhZmYyMWEyNGQ4OGY3OGI1ZTMzZjJmNjU4MC4uODNlNWQ4ODlkZmExNzllYzUwNjEzNTFiZjQz Njk2MjdiNGI4NTAzNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9TZWFyY2hJbnB1 dFR5cGUuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL1NlYXJjaElucHV0VHlwZS5oCkBAIC01 Miw2ICs1Miw3IEBAIHByaXZhdGU6CiAgICAgdmlydHVhbCB2b2lkIGRlc3Ryb3lTaGFkb3dTdWJ0 cmVlKCk7CiAgICAgdmlydHVhbCBIVE1MRWxlbWVudCogcmVzdWx0c0J1dHRvbkVsZW1lbnQoKSBj b25zdDsKICAgICB2aXJ0dWFsIEhUTUxFbGVtZW50KiBjYW5jZWxCdXR0b25FbGVtZW50KCkgY29u c3Q7CisgICAgdmlydHVhbCB2b2lkIGhhbmRsZUtleWRvd25FdmVudChLZXlib2FyZEV2ZW50Kik7 CiAKICAgICBSZWZQdHI8SFRNTEVsZW1lbnQ+IG1fcmVzdWx0c0J1dHRvbjsKICAgICBSZWZQdHI8 SFRNTEVsZW1lbnQ+IG1fY2FuY2VsQnV0dG9uOwpkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9n IGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IDc2ZWY4ZTY0NDViNDVlZDA1NDY4NDc2ZTNhZTIxMGFi ZDYwN2QwYTUuLjAwM2FkZjY1OGFlMDE4ZTc0ZDhjYzllZWM5NzI3NzM0YjFhZDA5ZjkgMTAwNjQ0 Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwy NSBAQAorMjAxMS0wNy0xNCAgS2VudGFybyBIYXJhICA8aGFyYWtlbkBnb29nbGUuY29tPgorCisg ICAgICAgIENsZWFyIHRoZSBjb250ZW50IG9mIGEgc2VhcmNoIGlucHV0IGZvcm0gd2hlbiAnRXNj YXBlJyBpcyBwcmVzc2VkLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9NTE4OTcKKworICAgICAgICBUaGlzIGNoYW5nZSBlbmFibGVzIHVzIHRvIHByZXNz IGFuICdlc2NhcGUnIGtleSBieSBldmVudFNlbmRlci5rZXlEb3duKCJlc2NhcGUiKS4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIER1bXBSZW5kZXJU cmVlL2Nocm9taXVtL0V2ZW50U2VuZGVyLmNwcDoKKyAgICAgICAgKEV2ZW50U2VuZGVyOjprZXlE b3duKToKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9lZmwvRXZlbnRTZW5kZXIuY3BwOgorICAg ICAgICAoa2V5TmFtZUZyb21KU1ZhbHVlKToKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9ndGsv RXZlbnRTZW5kZXIuY3BwOgorICAgICAgICAoa2V5RG93bkNhbGxiYWNrKToKKyAgICAgICAgKiBE dW1wUmVuZGVyVHJlZS9tYWMvRXZlbnRTZW5kaW5nQ29udHJvbGxlci5tbToKKyAgICAgICAgKC1b RXZlbnRTZW5kaW5nQ29udHJvbGxlciBrZXlEb3duOndpdGhNb2RpZmllcnM6d2l0aExvY2F0aW9u Ol0pOgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL3F0L0V2ZW50U2VuZGVyUXQuY3BwOgorICAg ICAgICAoRXZlbnRTZW5kZXI6OmtleURvd24pOgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL3dp bi9FdmVudFNlbmRlci5jcHA6CisgICAgICAgIChrZXlEb3duQ2FsbGJhY2spOgorCiAyMDExLTA3 LTExICBSeW9zdWtlIE5pd2EgIDxybml3YUB3ZWJraXQub3JnPgogCiAgICAgICAgIHdlYmtpdC1w YXRjaCByb2xsLWNocm9taXVtLWRlcHMgbm8gbG9uZ2VyIHdvcmtzCmRpZmYgLS1naXQgYS9Ub29s cy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9FdmVudFNlbmRlci5jcHAgYi9Ub29scy9EdW1wUmVu ZGVyVHJlZS9jaHJvbWl1bS9FdmVudFNlbmRlci5jcHAKaW5kZXggYmZlZTA3NzgyODk2ODkzNzlm OThmYzUzNWQ5NzQ1OTFlN2I3NzE5OC4uOTg5YmQ2MTEyNmE3OGI1NWVkZGRmYjY5NWMxY2U5Y2Iz NmMwNjI2MSAxMDA2NDQKLS0tIGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vRXZlbnRT ZW5kZXIuY3BwCisrKyBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL0V2ZW50U2VuZGVy LmNwcApAQCAtNTMyLDYgKzUzMiw5IEBAIHZvaWQgRXZlbnRTZW5kZXI6OmtleURvd24oY29uc3Qg Q3BwQXJndW1lbnRMaXN0JiBhcmd1bWVudHMsIENwcFZhcmlhbnQqIHJlc3VsdCkKICAgICAgICAg Y29kZSA9IHdlYmtpdF9zdXBwb3J0OjpWS0VZX0hPTUU7CiAgICAgZWxzZSBpZiAoImVuZCIgPT0g Y29kZVN0cikKICAgICAgICAgY29kZSA9IHdlYmtpdF9zdXBwb3J0OjpWS0VZX0VORDsKKyAgICBl bHNlIGlmICgiZXNjYXBlIiA9PSBjb2RlU3RyKQorICAgICAgICAvLyBGSVhNRTogQ2hhbmdlIHRo aXMgdG8gd2Via2l0X3N1cHBvcnQ6OlZLRVlfRVNDQVBFLgorICAgICAgICBjb2RlID0gMHgxQjsK ICAgICBlbHNlIGlmICgicHJpbnRTY3JlZW4iID09IGNvZGVTdHIpCiAgICAgICAgIGNvZGUgPSB3 ZWJraXRfc3VwcG9ydDo6VktFWV9TTkFQU0hPVDsKICAgICBlbHNlIGlmICgibWVudSIgPT0gY29k ZVN0cikKZGlmZiAtLWdpdCBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2VmbC9FdmVudFNlbmRlci5j cHAgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9lZmwvRXZlbnRTZW5kZXIuY3BwCmluZGV4IGVkZDBh ODNkMThhYTZmNWVkZmJlODRkMTI5N2EwMThkYWZjMGUyNGEuLjRiMDQ4MDZiODY4NGIzMjM0MGE0 ZWMxMmMzZTNlOGRhODIwNDc2ZjMgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Vm bC9FdmVudFNlbmRlci5jcHAKKysrIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvZWZsL0V2ZW50U2Vu ZGVyLmNwcApAQCAtMzU1LDYgKzM1NSw4IEBAIHN0YXRpYyBjb25zdCBjaGFyKiBrZXlOYW1lRnJv bUpTVmFsdWUoSlNTdHJpbmdSZWYgY2hhcmFjdGVyKQogICAgICAgICByZXR1cm4gIkluc2VydCI7 CiAgICAgaWYgKGVxdWFscyhjaGFyYWN0ZXIsICJkZWxldGUiKSkKICAgICAgICAgcmV0dXJuICJE ZWxldGUiOworICAgIGlmIChlcXVhbHMoY2hhcmFjdGVyLCAiZXNjYXBlIikpCisgICAgICAgIHJl dHVybiAiRXNjYXBlIjsKICAgICBpZiAoZXF1YWxzKGNoYXJhY3RlciwgInByaW50U2NyZWVuIikp CiAgICAgICAgIHJldHVybiAiUHJpbnQiOwogICAgIGlmIChlcXVhbHMoY2hhcmFjdGVyLCAibWVu dSIpKQpkaWZmIC0tZ2l0IGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvZ3RrL0V2ZW50U2VuZGVyLmNw cCBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9FdmVudFNlbmRlci5jcHAKaW5kZXggN2RhNDk1 ZmZhZWNiNzQ1MzRkYmZkNTMxMWJmZDY2YTkxOGUyZDBiYi4uNTVmMzBiY2RiYTgyZDZmN2NkMTMz NmQ1ZDI2MjEzMzIyZDViNmYxOSAxMDA2NDQKLS0tIGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvZ3Rr L0V2ZW50U2VuZGVyLmNwcAorKysgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9ndGsvRXZlbnRTZW5k ZXIuY3BwCkBAIC02NjksNiArNjY5LDggQEAgc3RhdGljIEpTVmFsdWVSZWYga2V5RG93bkNhbGxi YWNrKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU09iamVjdFJlZiBmdW5jdGlvbiwgSlMKICAgICAg ICAgICAgIGdka0tleVN5bSA9IEdES19JbnNlcnQ7CiAgICAgICAgIGVsc2UgaWYgKEpTU3RyaW5n SXNFcXVhbFRvVVRGOENTdHJpbmcoY2hhcmFjdGVyLCAiZGVsZXRlIikpCiAgICAgICAgICAgICBn ZGtLZXlTeW0gPSBHREtfRGVsZXRlOworICAgICAgICBlbHNlIGlmIChKU1N0cmluZ0lzRXF1YWxU b1VURjhDU3RyaW5nKGNoYXJhY3RlciwgImVzY2FwZSIpKQorICAgICAgICAgICAgZ2RrS2V5U3lt ID0gR0RLX0VzY2FwZTsKICAgICAgICAgZWxzZSBpZiAoSlNTdHJpbmdJc0VxdWFsVG9VVEY4Q1N0 cmluZyhjaGFyYWN0ZXIsICJwcmludFNjcmVlbiIpKQogICAgICAgICAgICAgZ2RrS2V5U3ltID0g R0RLX1ByaW50OwogICAgICAgICBlbHNlIGlmIChKU1N0cmluZ0lzRXF1YWxUb1VURjhDU3RyaW5n KGNoYXJhY3RlciwgIm1lbnUiKSkKZGlmZiAtLWdpdCBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL21h Yy9FdmVudFNlbmRpbmdDb250cm9sbGVyLm1tIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0V2 ZW50U2VuZGluZ0NvbnRyb2xsZXIubW0KaW5kZXggZjA3YTQzZTg3YmVmZmVmYzk4NTgwOGNmMDc3 ZmI5ZDBlMmUzN2RiYy4uMTM3Y2I3NjBjNjBlMzY4OTI0ZmZmMjg4NWM4MTcyODJiOGMzNTNmNCAx MDA2NDQKLS0tIGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0V2ZW50U2VuZGluZ0NvbnRyb2xs ZXIubW0KKysrIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0V2ZW50U2VuZGluZ0NvbnRyb2xs ZXIubW0KQEAgLTYxMCw2ICs2MTAsMTAgQEAgc3RhdGljIGludCBidWlsZE1vZGlmaWVyRmxhZ3Mo Y29uc3QgV2ViU2NyaXB0T2JqZWN0KiBtb2RpZmllcnMpCiAgICAgICAgIGNvbnN0IHVuaWNoYXIg Y2ggPSBOU0RlbGV0ZUZ1bmN0aW9uS2V5OwogICAgICAgICBldmVudENoYXJhY3RlciA9IFtOU1N0 cmluZyBzdHJpbmdXaXRoQ2hhcmFjdGVyczomY2ggbGVuZ3RoOjFdOwogICAgICAgICBrZXlDb2Rl ID0gMHg3NTsKKyAgICB9IGVsc2UgaWYgKFtjaGFyYWN0ZXIgaXNFcXVhbFRvU3RyaW5nOkAiZXNj YXBlIl0pIHsKKyAgICAgICAgY29uc3QgdW5pY2hhciBjaCA9IDB4MUI7CisgICAgICAgIGV2ZW50 Q2hhcmFjdGVyID0gW05TU3RyaW5nIHN0cmluZ1dpdGhDaGFyYWN0ZXJzOiZjaCBsZW5ndGg6MV07 CisgICAgICAgIGtleUNvZGUgPSAweDM1OwogICAgIH0gZWxzZSBpZiAoW2NoYXJhY3RlciBpc0Vx dWFsVG9TdHJpbmc6QCJwcmludFNjcmVlbiJdKSB7CiAgICAgICAgIGNvbnN0IHVuaWNoYXIgY2gg PSBOU1ByaW50U2NyZWVuRnVuY3Rpb25LZXk7CiAgICAgICAgIGV2ZW50Q2hhcmFjdGVyID0gW05T U3RyaW5nIHN0cmluZ1dpdGhDaGFyYWN0ZXJzOiZjaCBsZW5ndGg6MV07CmRpZmYgLS1naXQgYS9U b29scy9EdW1wUmVuZGVyVHJlZS9xdC9FdmVudFNlbmRlclF0LmNwcCBiL1Rvb2xzL0R1bXBSZW5k ZXJUcmVlL3F0L0V2ZW50U2VuZGVyUXQuY3BwCmluZGV4IDFlY2I3Mzk3YmRmODcyNDhlMzFhYmQ2 NGVkOWJhZjUzNWZkOTkxODUuLjljNWVhNzJkZDdlZjY5NjBkYjQzZWFiY2MxNjRkMGM2NzEyMzA2 NDcgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL3F0L0V2ZW50U2VuZGVyUXQuY3Bw CisrKyBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL3F0L0V2ZW50U2VuZGVyUXQuY3BwCkBAIC0zNTYs NiArMzU2LDkgQEAgdm9pZCBFdmVudFNlbmRlcjo6a2V5RG93bihjb25zdCBRU3RyaW5nJiBzdHJp bmcsIGNvbnN0IFFTdHJpbmdMaXN0JiBtb2RpZmllcnMsIHUKICAgICAgICAgfSBlbHNlIGlmIChz dHJpbmcgPT0gUUxhdGluMVN0cmluZygiZGVsZXRlIikpIHsKICAgICAgICAgICAgIHMgPSBRU3Ry aW5nKCk7CiAgICAgICAgICAgICBjb2RlID0gUXQ6OktleV9EZWxldGU7CisgICAgICAgIH0gZWxz ZSBpZiAoc3RyaW5nID09IFFMYXRpbjFTdHJpbmcoImVzY2FwZSIpKSB7CisgICAgICAgICAgICBz ID0gUVN0cmluZygpOworICAgICAgICAgICAgY29kZSA9IFF0OjpLZXlfRXNjYXBlOwogICAgICAg ICB9IGVsc2UgaWYgKHN0cmluZyA9PSBRTGF0aW4xU3RyaW5nKCJwcmludFNjcmVlbiIpKSB7CiAg ICAgICAgICAgICBzID0gUVN0cmluZygpOwogICAgICAgICAgICAgY29kZSA9IFF0OjpLZXlfUHJp bnQ7CmRpZmYgLS1naXQgYS9Ub29scy9EdW1wUmVuZGVyVHJlZS93aW4vRXZlbnRTZW5kZXIuY3Bw IGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0V2ZW50U2VuZGVyLmNwcAppbmRleCBlMWM1Y2Q1 MDIzZTE4ZjFjNWY2ODAzNWYxNGZmNGEwNWQ0MTJkOWJiLi5hZGY2YmEwNTNhYjIyNmNlYjljMGNk Zjk2Yjg0MDU1ZTUzZWVkNzIwIDEwMDY0NAotLS0gYS9Ub29scy9EdW1wUmVuZGVyVHJlZS93aW4v RXZlbnRTZW5kZXIuY3BwCisrKyBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9FdmVudFNlbmRl ci5jcHAKQEAgLTQ3MSw2ICs0NzEsOCBAQCBzdGF0aWMgSlNWYWx1ZVJlZiBrZXlEb3duQ2FsbGJh Y2soSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTT2JqZWN0UmVmIGZ1bmN0aW9uLCBKUwogICAgICAg ICB2aXJ0dWFsS2V5Q29kZSA9IFZLX0lOU0VSVDsKICAgICBlbHNlIGlmIChKU1N0cmluZ0lzRXF1 YWxUb1VURjhDU3RyaW5nKGNoYXJhY3RlciwgImRlbGV0ZSIpKQogICAgICAgICB2aXJ0dWFsS2V5 Q29kZSA9IFZLX0RFTEVURTsKKyAgICBlbHNlIGlmIChKU1N0cmluZ0lzRXF1YWxUb1VURjhDU3Ry aW5nKGNoYXJhY3RlciwgImVzY2FwZSIpKQorICAgICAgICB2aXJ0dWFsS2V5Q29kZSA9IFZLX0VT Q0FQRTsKICAgICBlbHNlIGlmIChKU1N0cmluZ0lzRXF1YWxUb1VURjhDU3RyaW5nKGNoYXJhY3Rl ciwgInByaW50U2NyZWVuIikpCiAgICAgICAgIHZpcnR1YWxLZXlDb2RlID0gVktfU05BUFNIT1Q7 CiAgICAgZWxzZSBpZiAoSlNTdHJpbmdJc0VxdWFsVG9VVEY4Q1N0cmluZyhjaGFyYWN0ZXIsICJt ZW51IikpCg== 100927 2011-07-14 21:38:29 -0700 2011-07-14 23:09:46 -0700 Patch bug-51897-20110715133827.patch text/plain 7005 haraken U3VidmVyc2lvbiBSZXZpc2lvbjogOTA5NjUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCBkN2E3MDlhNzBmODUyYzYzM2RlY2Nk ZjA1MTY3ZmUyNjI5NzY3MmJkLi41MGJlNjZlNGRiZDkzOGQ1NjkyYWQ2MjFiNTczMzc4Y2Y2NmQ2 YTUyIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAKKzIwMTEtMDctMTQgIEtlbnRhcm8gSGFyYSAgPGhh cmFrZW5AZ29vZ2xlLmNvbT4KKworICAgICAgICBDbGVhciB0aGUgY29udGVudCBvZiBhIHNlYXJj aCBpbnB1dCBmb3JtIHdoZW4gJ0VzY2FwZScgaXMgcHJlc3NlZC4KKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUxODk3CisKKyAgICAgICAgVGhlIGFkZGVk IHRlc3QgY2hlY2tzIGlmIHRoZSB2YWx1ZSBpbiBhIHNlYXJjaCBpbnB1dCBmb3JtIGlzIGNsZWFy ZWQKKyAgICAgICAgYW5kIGEgJ3NlYXJjaCcgZXZlbnQgaXMgdHJpZ2dlcmVkLCB3aGVuIHdlIHBy ZXNzICdFc2NhcGUnIGtleS4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICAqIGZhc3QvZm9ybXMvaW5wdXQtc2VhcmNoLXByZXNzLWVzY2FwZS1rZXktZXhw ZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2Zvcm1zL2lucHV0LXNlYXJjaC1wcmVz cy1lc2NhcGUta2V5Lmh0bWw6IEFkZGVkLgorCiAyMDExLTA3LTEzICBNaWNoYWVsIFNhYm9mZiAg PG1zYWJvZmZAYXBwbGUuY29tPgogCiAgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD02NDIwMgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9p bnB1dC1zZWFyY2gtcHJlc3MtZXNjYXBlLWtleS1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9m YXN0L2Zvcm1zL2lucHV0LXNlYXJjaC1wcmVzcy1lc2NhcGUta2V5LWV4cGVjdGVkLnR4dApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwLi5iM2MwNGRjZjcyMmQ4MmM2N2IyYjBlYjk1MzIyMjA1NTJmYTEzOGMwCi0tLSAvZGV2 L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9pbnB1dC1zZWFyY2gtcHJlc3MtZXNj YXBlLWtleS1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwxNyBAQAorCitUaGlzIHRlc3RzIGlmIHRo ZSB2YWx1ZSBpbiBhIHNlYXJjaCBpbnB1dCBmb3JtIGlzIGNsZWFyZWQgYW5kIGEgJ3NlYXJjaCcg ZXZlbnQgaXMgdHJpZ2dlcmVkLCB3aGVuIHdlIHByZXNzIEVzY2FwZSBrZXkuIFRoaXMgdGVzdCBj YW5ub3QgcnVuIGludGVyYWN0aXZlbHkuCisKK1BBU1MgaW5wdXQudmFsdWUgaXMgIiIKK1BBU1Mg c2VhcmNoRXZlbnRPYnNlcnZlZCBpcyB0cnVlCitQQVNTIGlucHV0LnZhbHVlIGlzICIiCitQQVNT IHNlYXJjaEV2ZW50T2JzZXJ2ZWQgaXMgdHJ1ZQorUEFTUyBpbnB1dC52YWx1ZSBpcyAiZm9vIgor UEFTUyBzZWFyY2hFdmVudE9ic2VydmVkIGlzIGZhbHNlCitQQVNTIGlucHV0LnZhbHVlIGlzICJm b28iCitQQVNTIHNlYXJjaEV2ZW50T2JzZXJ2ZWQgaXMgZmFsc2UKK1BBU1MgaW5wdXQudmFsdWUg aXMgImZvbyIKK1BBU1Mgc2VhcmNoRXZlbnRPYnNlcnZlZCBpcyBmYWxzZQorUEFTUyBzdWNjZXNz ZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBMRVRFCisKZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL2Zhc3QvZm9ybXMvaW5wdXQtc2VhcmNoLXByZXNzLWVzY2FwZS1rZXkuaHRtbCBiL0xh eW91dFRlc3RzL2Zhc3QvZm9ybXMvaW5wdXQtc2VhcmNoLXByZXNzLWVzY2FwZS1rZXkuaHRtbApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwLi40M2ZhYzM2MWJjMzYwMmNmMTUzNTBkZDFlYTEwMzdiYzY0ZmQ3YTVjCi0tLSAv ZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9pbnB1dC1zZWFyY2gtcHJlc3Mt ZXNjYXBlLWtleS5odG1sCkBAIC0wLDAgKzEsODAgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+ Cis8aGVhZD4KKzxzY3JpcHQgc3JjPSIuLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwv c2NyaXB0PgorPHNjcmlwdCBzcmM9InJlc291cmNlcy9jb21tb24uanMiPjwvc2NyaXB0PgorPC9o ZWFkPgorPGJvZHk+Cis8aW5wdXQgaWQ9InNlYXJjaCIgdHlwZT0ic2VhcmNoIiBvbnNlYXJjaD0i c2VhcmNoRXZlbnREaXNwYXRjaGVkKCkiIC8+Cis8ZGl2IGlkPSJjb25zb2xlIj4KKzxwPgorVGhp cyB0ZXN0cyBpZiB0aGUgdmFsdWUgaW4gYSBzZWFyY2ggaW5wdXQgZm9ybSBpcyBjbGVhcmVkIAor YW5kIGEgJ3NlYXJjaCcgZXZlbnQgaXMgdHJpZ2dlcmVkLCB3aGVuIHdlIHByZXNzIEVzY2FwZSBr ZXkuCitUaGlzIHRlc3QgY2Fubm90IHJ1biBpbnRlcmFjdGl2ZWx5LgorPC9wPgorPC9kaXY+Cis8 c2NyaXB0PgordmFyIHNlYXJjaEV2ZW50T2JzZXJ2ZWQ7CisKK2lmICh3aW5kb3cubGF5b3V0VGVz dENvbnRyb2xsZXIgJiYgd2luZG93LmV2ZW50U2VuZGVyKSB7CisgICAgdmFyIGlucHV0ID0gJCgi c2VhcmNoIik7CisgICAgdmFyIGVuYWJsZWQgPSBmYWxzZTsKKyAgICB2YXIgZGlzYWJsZWQgPSB0 cnVlOworICAgIHZhciByZWFkb25seSA9IHRydWU7CisKKyAgICBzZWFyY2hFdmVudE9ic2VydmVk ID0gZmFsc2U7CisgICAgaW5wdXQuZm9jdXMoKTsKKyAgICBzZXRJbnB1dEF0dHJpYnV0ZXMoaW5w dXQsICJmb28iLCBlbmFibGVkKTsKKyAgICBldmVudFNlbmRlci5rZXlEb3duKCJceDFCIik7Cisg ICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCdpbnB1dC52YWx1ZScsICIiKTsKKyAgICBzaG91bGRC ZSgnc2VhcmNoRXZlbnRPYnNlcnZlZCcsICd0cnVlJyk7CisgICAgaW5wdXQuYmx1cigpOworCisg ICAgc2VhcmNoRXZlbnRPYnNlcnZlZCA9IGZhbHNlOworICAgIGlucHV0LmZvY3VzKCk7CisgICAg c2V0SW5wdXRBdHRyaWJ1dGVzKGlucHV0LCAiIiwgZW5hYmxlZCk7CisgICAgZXZlbnRTZW5kZXIu a2V5RG93bigiXHgxQiIpOworICAgIHNob3VsZEJlRXF1YWxUb1N0cmluZygnaW5wdXQudmFsdWUn LCAiIik7CisgICAgc2hvdWxkQmUoJ3NlYXJjaEV2ZW50T2JzZXJ2ZWQnLCAndHJ1ZScpOworICAg IGlucHV0LmJsdXIoKTsKKworICAgIHNlYXJjaEV2ZW50T2JzZXJ2ZWQgPSBmYWxzZTsKKyAgICBp bnB1dC5mb2N1cygpOworICAgIHNldElucHV0QXR0cmlidXRlcyhpbnB1dCwgImZvbyIsIGVuYWJs ZWQsIHJlYWRvbmx5KTsKKyAgICBldmVudFNlbmRlci5rZXlEb3duKCJceDFCIik7CisgICAgc2hv dWxkQmVFcXVhbFRvU3RyaW5nKCdpbnB1dC52YWx1ZScsICJmb28iKTsKKyAgICBzaG91bGRCZSgn c2VhcmNoRXZlbnRPYnNlcnZlZCcsICdmYWxzZScpOworICAgIGlucHV0LmJsdXIoKTsKKworICAg IHNlYXJjaEV2ZW50T2JzZXJ2ZWQgPSBmYWxzZTsKKyAgICBpbnB1dC5mb2N1cygpOworICAgIHNl dElucHV0QXR0cmlidXRlcyhpbnB1dCwgImZvbyIsIGRpc2FibGVkKTsKKyAgICBldmVudFNlbmRl ci5rZXlEb3duKCJceDFCIik7CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCdpbnB1dC52YWx1 ZScsICJmb28iKTsKKyAgICBzaG91bGRCZSgnc2VhcmNoRXZlbnRPYnNlcnZlZCcsICdmYWxzZScp OworICAgIGlucHV0LmJsdXIoKTsKKworICAgIHNlYXJjaEV2ZW50T2JzZXJ2ZWQgPSBmYWxzZTsK KyAgICBpbnB1dC5mb2N1cygpOworICAgIHNldElucHV0QXR0cmlidXRlcyhpbnB1dCwgImZvbyIs IGRpc2FibGVkLCByZWFkb25seSk7CisgICAgZXZlbnRTZW5kZXIua2V5RG93bigiXHgxQiIpOwor ICAgIHNob3VsZEJlRXF1YWxUb1N0cmluZygnaW5wdXQudmFsdWUnLCAiZm9vIik7CisgICAgc2hv dWxkQmUoJ3NlYXJjaEV2ZW50T2JzZXJ2ZWQnLCAnZmFsc2UnKTsKKyAgICBpbnB1dC5ibHVyKCk7 Cit9CisKK2Z1bmN0aW9uIHNldElucHV0QXR0cmlidXRlcyhpbnB1dCwgdGV4dCwgZGlzYWJsZWQs IHJlYWRvbmx5KSB7CisgICAgaW5wdXQudmFsdWUgPSB0ZXh0OworICAgIGlucHV0LmRpc2FibGVk ID0gZGlzYWJsZWQ7CisgICAgaW5wdXQucmVhZE9ubHkgPSAhIXJlYWRvbmx5OworfQorCitmdW5j dGlvbiBzZWFyY2hFdmVudERpc3BhdGNoZWQoKSB7CisgICAgc2VhcmNoRXZlbnRPYnNlcnZlZCA9 IHRydWU7Cit9CisKK3ZhciBzdWNjZXNzZnVsbHlQYXJzZWQgPSB0cnVlOworPC9zY3JpcHQ+Cis8 c2NyaXB0IHNyYz0iLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcG9zdC5qcyI+PC9zY3JpcHQ+Cis8 L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cgYi9T b3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMTRiMDAxZGYwOGUxZGQ0ZDBhNzBhYWFmZjcz Y2MzYjc1M2ZkNmVmYy4uMWI3YTUyYTc3MDhlMjlhOWM1ZTM5Zjg3ZTA4YWNhYjg0MTExYTlmMyAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJDb3Jl L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDExLTA3LTE0ICBLZW50YXJvIEhhcmEgIDxo YXJha2VuQGdvb2dsZS5jb20+CisKKyAgICAgICAgQ2xlYXIgdGhlIGNvbnRlbnQgb2YgYSBzZWFy Y2ggaW5wdXQgZm9ybSB3aGVuICdFc2NhcGUnIGlzIHByZXNzZWQuCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01MTg5NworCisgICAgICAgIFRoaXMgY2hh bmdlIGFkZGVkIGhhbmRsZUtleWRvd25FdmVudCgpIHRvIGEgc2VhcmNoIGlucHV0IGZvcm0sCisg ICAgICAgIHdoaWNoIGNsZWFycyB0aGUgZm9ybSBhbmQgdHJpZ2dlcnMgYSAnc2VhcmNoJyBldmVu dCB3aGVuICdFc2NhcGUnIGlzIHByZXNzZWQuCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgVGVzdDogZmFzdC9mb3Jtcy9pbnB1dC1zZWFyY2gtcHJlc3Mt ZXNjYXBlLWtleS5odG1sCisKKyAgICAgICAgKiBodG1sL1NlYXJjaElucHV0VHlwZS5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpTZWFyY2hJbnB1dFR5cGU6OmhhbmRsZUtleWRvd25FdmVudCk6Cisg ICAgICAgICogaHRtbC9TZWFyY2hJbnB1dFR5cGUuaDoKKwogMjAxMS0wNy0xMyAgSmFtZXMgUm9i aW5zb24gIDxqYW1lc3JAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEtlbm5l dGggUnVzc2VsbC4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvU2VhcmNoSW5wdXRU eXBlLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvU2VhcmNoSW5wdXRUeXBlLmNwcAppbmRleCBk NmJjODZlZTA3MjQxZDc0ZjU2MmJiOTgyNmQ0YWViNWQ5ZTYzNTQ3Li43ODRhNTA1M2ZmNDFhNjUx MzcxMTQ1NTdmNTUxODY1MjMwOWY2ODE0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1s L1NlYXJjaElucHV0VHlwZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9TZWFyY2hJbnB1 dFR5cGUuY3BwCkBAIC0zMiw2ICszMiw3IEBACiAjaW5jbHVkZSAiU2VhcmNoSW5wdXRUeXBlLmgi CiAKICNpbmNsdWRlICJIVE1MSW5wdXRFbGVtZW50LmgiCisjaW5jbHVkZSAiS2V5Ym9hcmRFdmVu dC5oIgogI2luY2x1ZGUgIlNoYWRvd1Jvb3QuaCIKICNpbmNsdWRlICJUZXh0Q29udHJvbElubmVy RWxlbWVudHMuaCIKICNpbmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgpAQCAtOTcsNiArOTgsMjIg QEAgSFRNTEVsZW1lbnQqIFNlYXJjaElucHV0VHlwZTo6Y2FuY2VsQnV0dG9uRWxlbWVudCgpIGNv bnN0CiAgICAgcmV0dXJuIG1fY2FuY2VsQnV0dG9uLmdldCgpOwogfQogCit2b2lkIFNlYXJjaElu cHV0VHlwZTo6aGFuZGxlS2V5ZG93bkV2ZW50KEtleWJvYXJkRXZlbnQqIGV2ZW50KQoreworICAg IGNvbnN0IFN0cmluZyYga2V5ID0gZXZlbnQtPmtleUlkZW50aWZpZXIoKTsKKyAgICBpZiAoa2V5 ID09ICJVKzAwMUIiKSB7CisgICAgICAgIFJlZlB0cjxIVE1MSW5wdXRFbGVtZW50PiBpbnB1dCA9 IGVsZW1lbnQoKTsKKyAgICAgICAgaWYgKGlucHV0LT5kaXNhYmxlZCgpIHx8IGlucHV0LT5yZWFk T25seSgpKQorICAgICAgICAgICAgcmV0dXJuOworCisgICAgICAgIGlucHV0LT5zZXRWYWx1ZUZv clVzZXIoIiIpOworICAgICAgICBpbnB1dC0+b25TZWFyY2goKTsKKyAgICAgICAgZXZlbnQtPnNl dERlZmF1bHRIYW5kbGVkKCk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisgICAgVGV4dEZpZWxk SW5wdXRUeXBlOjpoYW5kbGVLZXlkb3duRXZlbnQoZXZlbnQpOworfQorCiB2b2lkIFNlYXJjaElu cHV0VHlwZTo6ZGVzdHJveVNoYWRvd1N1YnRyZWUoKQogewogICAgIFRleHRGaWVsZElucHV0VHlw ZTo6ZGVzdHJveVNoYWRvd1N1YnRyZWUoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0 bWwvU2VhcmNoSW5wdXRUeXBlLmggYi9Tb3VyY2UvV2ViQ29yZS9odG1sL1NlYXJjaElucHV0VHlw ZS5oCmluZGV4IDY5OTlkMTFmZmU0ZmI2YWZmMjFhMjRkODhmNzhiNWUzM2YyZjY1ODAuLjgzZTVk ODg5ZGZhMTc5ZWM1MDYxMzUxYmY0MzY5NjI3YjRiODUwMzYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL2h0bWwvU2VhcmNoSW5wdXRUeXBlLmgKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9T ZWFyY2hJbnB1dFR5cGUuaApAQCAtNTIsNiArNTIsNyBAQCBwcml2YXRlOgogICAgIHZpcnR1YWwg dm9pZCBkZXN0cm95U2hhZG93U3VidHJlZSgpOwogICAgIHZpcnR1YWwgSFRNTEVsZW1lbnQqIHJl c3VsdHNCdXR0b25FbGVtZW50KCkgY29uc3Q7CiAgICAgdmlydHVhbCBIVE1MRWxlbWVudCogY2Fu Y2VsQnV0dG9uRWxlbWVudCgpIGNvbnN0OworICAgIHZpcnR1YWwgdm9pZCBoYW5kbGVLZXlkb3du RXZlbnQoS2V5Ym9hcmRFdmVudCopOwogCiAgICAgUmVmUHRyPEhUTUxFbGVtZW50PiBtX3Jlc3Vs dHNCdXR0b247CiAgICAgUmVmUHRyPEhUTUxFbGVtZW50PiBtX2NhbmNlbEJ1dHRvbjsK 100934 2011-07-14 23:09:55 -0700 2011-07-14 23:35:35 -0700 Patch bug-51897-20110715150953.patch text/plain 7307 haraken U3VidmVyc2lvbiBSZXZpc2lvbjogOTA5NjUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCBkN2E3MDlhNzBmODUyYzYzM2RlY2Nk ZjA1MTY3ZmUyNjI5NzY3MmJkLi41MGJlNjZlNGRiZDkzOGQ1NjkyYWQ2MjFiNTczMzc4Y2Y2NmQ2 YTUyIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAKKzIwMTEtMDctMTQgIEtlbnRhcm8gSGFyYSAgPGhh cmFrZW5AZ29vZ2xlLmNvbT4KKworICAgICAgICBDbGVhciB0aGUgY29udGVudCBvZiBhIHNlYXJj aCBpbnB1dCBmb3JtIHdoZW4gJ0VzY2FwZScgaXMgcHJlc3NlZC4KKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUxODk3CisKKyAgICAgICAgVGhlIGFkZGVk IHRlc3QgY2hlY2tzIGlmIHRoZSB2YWx1ZSBpbiBhIHNlYXJjaCBpbnB1dCBmb3JtIGlzIGNsZWFy ZWQKKyAgICAgICAgYW5kIGEgJ3NlYXJjaCcgZXZlbnQgaXMgdHJpZ2dlcmVkLCB3aGVuIHdlIHBy ZXNzICdFc2NhcGUnIGtleS4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICAqIGZhc3QvZm9ybXMvaW5wdXQtc2VhcmNoLXByZXNzLWVzY2FwZS1rZXktZXhw ZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2Zvcm1zL2lucHV0LXNlYXJjaC1wcmVz cy1lc2NhcGUta2V5Lmh0bWw6IEFkZGVkLgorCiAyMDExLTA3LTEzICBNaWNoYWVsIFNhYm9mZiAg PG1zYWJvZmZAYXBwbGUuY29tPgogCiAgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD02NDIwMgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9p bnB1dC1zZWFyY2gtcHJlc3MtZXNjYXBlLWtleS1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9m YXN0L2Zvcm1zL2lucHV0LXNlYXJjaC1wcmVzcy1lc2NhcGUta2V5LWV4cGVjdGVkLnR4dApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwLi5iMzRhYWNmNjQ2NDdhODI5MTFlZjk5NmViNDJkZTI1ZmYwMzg1NDIzCi0tLSAvZGV2 L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9pbnB1dC1zZWFyY2gtcHJlc3MtZXNj YXBlLWtleS1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwxNyBAQAorCitUaGlzIHRlc3RzIGlmIHRo ZSB2YWx1ZSBpbiBhIHNlYXJjaCBpbnB1dCBmb3JtIGlzIGNsZWFyZWQgYW5kIGEgJ3NlYXJjaCcg ZXZlbnQgaXMgdHJpZ2dlcmVkLCB3aGVuIHdlIHByZXNzIHRoZSBFc2NhcGUga2V5LiBUbyBydW4g KGEgcGFydCBvZikgdGhpcyB0ZXN0IG1hbnVhbGx5LCB0eXBlIHNvbWUgdGV4dCBpbiB0aGUgc2Vh cmNoIGZvcm0gYW5kIHRoZW4gcHJlc3MgdGhlIEVzY2FwZSBrZXkuIElmIHRoZSB0ZXh0IGlzIGNs ZWFyZWQsIHRoZW4gdGhlIHRlc3QgcGFzc2VzLgorCitQQVNTIGlucHV0LnZhbHVlIGlzICIiCitQ QVNTIHNlYXJjaEV2ZW50T2JzZXJ2ZWQgaXMgdHJ1ZQorUEFTUyBpbnB1dC52YWx1ZSBpcyAiIgor UEFTUyBzZWFyY2hFdmVudE9ic2VydmVkIGlzIHRydWUKK1BBU1MgaW5wdXQudmFsdWUgaXMgImZv byIKK1BBU1Mgc2VhcmNoRXZlbnRPYnNlcnZlZCBpcyBmYWxzZQorUEFTUyBpbnB1dC52YWx1ZSBp cyAiZm9vIgorUEFTUyBzZWFyY2hFdmVudE9ic2VydmVkIGlzIGZhbHNlCitQQVNTIGlucHV0LnZh bHVlIGlzICJmb28iCitQQVNTIHNlYXJjaEV2ZW50T2JzZXJ2ZWQgaXMgZmFsc2UKK1BBU1Mgc3Vj Y2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQorCmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9mYXN0L2Zvcm1zL2lucHV0LXNlYXJjaC1wcmVzcy1lc2NhcGUta2V5Lmh0bWwg Yi9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL2lucHV0LXNlYXJjaC1wcmVzcy1lc2NhcGUta2V5Lmh0 bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMC4uMmRiOGJhYzJjNWZmY2E4YzRhODRiNzUyYTlmNGI3MTM3MjA3YjZjMAot LS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMvaW5wdXQtc2VhcmNoLXBy ZXNzLWVzY2FwZS1rZXkuaHRtbApAQCAtMCwwICsxLDgyIEBACis8IURPQ1RZUEUgaHRtbD4KKzxo dG1sPgorPGhlYWQ+Cis8c2NyaXB0IHNyYz0iLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpz Ij48L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSJyZXNvdXJjZXMvY29tbW9uLmpzIj48L3NjcmlwdD4K KzwvaGVhZD4KKzxib2R5PgorPGlucHV0IGlkPSJzZWFyY2giIHR5cGU9InNlYXJjaCIgb25zZWFy Y2g9InNlYXJjaEV2ZW50RGlzcGF0Y2hlZCgpIiAvPgorPGRpdiBpZD0iY29uc29sZSI+Cis8cD4K K1RoaXMgdGVzdHMgaWYgdGhlIHZhbHVlIGluIGEgc2VhcmNoIGlucHV0IGZvcm0gaXMgY2xlYXJl ZAorYW5kIGEgJ3NlYXJjaCcgZXZlbnQgaXMgdHJpZ2dlcmVkLCB3aGVuIHdlIHByZXNzIHRoZSBF c2NhcGUga2V5LgorVG8gcnVuIChhIHBhcnQgb2YpIHRoaXMgdGVzdCBtYW51YWxseSwKK3R5cGUg c29tZSB0ZXh0IGluIHRoZSBzZWFyY2ggZm9ybSBhbmQgdGhlbiBwcmVzcyB0aGUgRXNjYXBlIGtl eS4KK0lmIHRoZSB0ZXh0IGlzIGNsZWFyZWQsIHRoZW4gdGhlIHRlc3QgcGFzc2VzLgorPC9wPgor PC9kaXY+Cis8c2NyaXB0PgordmFyIHNlYXJjaEV2ZW50T2JzZXJ2ZWQ7CisKK2lmICh3aW5kb3cu bGF5b3V0VGVzdENvbnRyb2xsZXIgJiYgd2luZG93LmV2ZW50U2VuZGVyKSB7CisgICAgdmFyIGlu cHV0ID0gJCgic2VhcmNoIik7CisgICAgdmFyIGVuYWJsZWQgPSBmYWxzZTsKKyAgICB2YXIgZGlz YWJsZWQgPSB0cnVlOworICAgIHZhciByZWFkb25seSA9IHRydWU7CisKKyAgICBzZWFyY2hFdmVu dE9ic2VydmVkID0gZmFsc2U7CisgICAgaW5wdXQuZm9jdXMoKTsKKyAgICBzZXRJbnB1dEF0dHJp YnV0ZXMoaW5wdXQsICJmb28iLCBlbmFibGVkKTsKKyAgICBldmVudFNlbmRlci5rZXlEb3duKCJc eDFCIik7CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCdpbnB1dC52YWx1ZScsICIiKTsKKyAg ICBzaG91bGRCZSgnc2VhcmNoRXZlbnRPYnNlcnZlZCcsICd0cnVlJyk7CisgICAgaW5wdXQuYmx1 cigpOworCisgICAgc2VhcmNoRXZlbnRPYnNlcnZlZCA9IGZhbHNlOworICAgIGlucHV0LmZvY3Vz KCk7CisgICAgc2V0SW5wdXRBdHRyaWJ1dGVzKGlucHV0LCAiIiwgZW5hYmxlZCk7CisgICAgZXZl bnRTZW5kZXIua2V5RG93bigiXHgxQiIpOworICAgIHNob3VsZEJlRXF1YWxUb1N0cmluZygnaW5w dXQudmFsdWUnLCAiIik7CisgICAgc2hvdWxkQmUoJ3NlYXJjaEV2ZW50T2JzZXJ2ZWQnLCAndHJ1 ZScpOworICAgIGlucHV0LmJsdXIoKTsKKworICAgIHNlYXJjaEV2ZW50T2JzZXJ2ZWQgPSBmYWxz ZTsKKyAgICBpbnB1dC5mb2N1cygpOworICAgIHNldElucHV0QXR0cmlidXRlcyhpbnB1dCwgImZv byIsIGVuYWJsZWQsIHJlYWRvbmx5KTsKKyAgICBldmVudFNlbmRlci5rZXlEb3duKCJceDFCIik7 CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCdpbnB1dC52YWx1ZScsICJmb28iKTsKKyAgICBz aG91bGRCZSgnc2VhcmNoRXZlbnRPYnNlcnZlZCcsICdmYWxzZScpOworICAgIGlucHV0LmJsdXIo KTsKKworICAgIHNlYXJjaEV2ZW50T2JzZXJ2ZWQgPSBmYWxzZTsKKyAgICBpbnB1dC5mb2N1cygp OworICAgIHNldElucHV0QXR0cmlidXRlcyhpbnB1dCwgImZvbyIsIGRpc2FibGVkKTsKKyAgICBl dmVudFNlbmRlci5rZXlEb3duKCJceDFCIik7CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCdp bnB1dC52YWx1ZScsICJmb28iKTsKKyAgICBzaG91bGRCZSgnc2VhcmNoRXZlbnRPYnNlcnZlZCcs ICdmYWxzZScpOworICAgIGlucHV0LmJsdXIoKTsKKworICAgIHNlYXJjaEV2ZW50T2JzZXJ2ZWQg PSBmYWxzZTsKKyAgICBpbnB1dC5mb2N1cygpOworICAgIHNldElucHV0QXR0cmlidXRlcyhpbnB1 dCwgImZvbyIsIGRpc2FibGVkLCByZWFkb25seSk7CisgICAgZXZlbnRTZW5kZXIua2V5RG93bigi XHgxQiIpOworICAgIHNob3VsZEJlRXF1YWxUb1N0cmluZygnaW5wdXQudmFsdWUnLCAiZm9vIik7 CisgICAgc2hvdWxkQmUoJ3NlYXJjaEV2ZW50T2JzZXJ2ZWQnLCAnZmFsc2UnKTsKKyAgICBpbnB1 dC5ibHVyKCk7Cit9CisKK2Z1bmN0aW9uIHNldElucHV0QXR0cmlidXRlcyhpbnB1dCwgdGV4dCwg ZGlzYWJsZWQsIHJlYWRvbmx5KSB7CisgICAgaW5wdXQudmFsdWUgPSB0ZXh0OworICAgIGlucHV0 LmRpc2FibGVkID0gZGlzYWJsZWQ7CisgICAgaW5wdXQucmVhZE9ubHkgPSAhIXJlYWRvbmx5Owor fQorCitmdW5jdGlvbiBzZWFyY2hFdmVudERpc3BhdGNoZWQoKSB7CisgICAgc2VhcmNoRXZlbnRP YnNlcnZlZCA9IHRydWU7Cit9CisKK3ZhciBzdWNjZXNzZnVsbHlQYXJzZWQgPSB0cnVlOworPC9z Y3JpcHQ+Cis8c2NyaXB0IHNyYz0iLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcG9zdC5qcyI+PC9z Y3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9DaGFu Z2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMTRiMDAxZGYwOGUxZGQ0ZDBh NzBhYWFmZjczY2MzYjc1M2ZkNmVmYy4uMWI3YTUyYTc3MDhlMjlhOWM1ZTM5Zjg3ZTA4YWNhYjg0 MTExYTlmMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDExLTA3LTE0ICBLZW50YXJv IEhhcmEgIDxoYXJha2VuQGdvb2dsZS5jb20+CisKKyAgICAgICAgQ2xlYXIgdGhlIGNvbnRlbnQg b2YgYSBzZWFyY2ggaW5wdXQgZm9ybSB3aGVuICdFc2NhcGUnIGlzIHByZXNzZWQuCisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01MTg5NworCisgICAgICAg IFRoaXMgY2hhbmdlIGFkZGVkIGhhbmRsZUtleWRvd25FdmVudCgpIHRvIGEgc2VhcmNoIGlucHV0 IGZvcm0sCisgICAgICAgIHdoaWNoIGNsZWFycyB0aGUgZm9ybSBhbmQgdHJpZ2dlcnMgYSAnc2Vh cmNoJyBldmVudCB3aGVuICdFc2NhcGUnIGlzIHByZXNzZWQuCisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVGVzdDogZmFzdC9mb3Jtcy9pbnB1dC1zZWFy Y2gtcHJlc3MtZXNjYXBlLWtleS5odG1sCisKKyAgICAgICAgKiBodG1sL1NlYXJjaElucHV0VHlw ZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpTZWFyY2hJbnB1dFR5cGU6OmhhbmRsZUtleWRvd25F dmVudCk6CisgICAgICAgICogaHRtbC9TZWFyY2hJbnB1dFR5cGUuaDoKKwogMjAxMS0wNy0xMyAg SmFtZXMgUm9iaW5zb24gIDxqYW1lc3JAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJldmlld2Vk IGJ5IEtlbm5ldGggUnVzc2VsbC4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvU2Vh cmNoSW5wdXRUeXBlLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvU2VhcmNoSW5wdXRUeXBlLmNw cAppbmRleCBkNmJjODZlZTA3MjQxZDc0ZjU2MmJiOTgyNmQ0YWViNWQ5ZTYzNTQ3Li4wNjYwYWE5 YjYzODdmMDQ2MzA5Yzg0MTA5OTYyODkwZmM3MDg3NjFmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9odG1sL1NlYXJjaElucHV0VHlwZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9T ZWFyY2hJbnB1dFR5cGUuY3BwCkBAIC0zMiw2ICszMiw3IEBACiAjaW5jbHVkZSAiU2VhcmNoSW5w dXRUeXBlLmgiCiAKICNpbmNsdWRlICJIVE1MSW5wdXRFbGVtZW50LmgiCisjaW5jbHVkZSAiS2V5 Ym9hcmRFdmVudC5oIgogI2luY2x1ZGUgIlNoYWRvd1Jvb3QuaCIKICNpbmNsdWRlICJUZXh0Q29u dHJvbElubmVyRWxlbWVudHMuaCIKICNpbmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgpAQCAtOTcs NiArOTgsMjQgQEAgSFRNTEVsZW1lbnQqIFNlYXJjaElucHV0VHlwZTo6Y2FuY2VsQnV0dG9uRWxl bWVudCgpIGNvbnN0CiAgICAgcmV0dXJuIG1fY2FuY2VsQnV0dG9uLmdldCgpOwogfQogCit2b2lk IFNlYXJjaElucHV0VHlwZTo6aGFuZGxlS2V5ZG93bkV2ZW50KEtleWJvYXJkRXZlbnQqIGV2ZW50 KQoreworICAgIGlmIChlbGVtZW50KCktPmRpc2FibGVkKCkgfHwgZWxlbWVudCgpLT5yZWFkT25s eSgpKSB7CisgICAgICAgIFRleHRGaWVsZElucHV0VHlwZTo6aGFuZGxlS2V5ZG93bkV2ZW50KGV2 ZW50KTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIGNvbnN0IFN0cmluZyYga2V5ID0g ZXZlbnQtPmtleUlkZW50aWZpZXIoKTsKKyAgICBpZiAoa2V5ID09ICJVKzAwMUIiKSB7CisgICAg ICAgIFJlZlB0cjxIVE1MSW5wdXRFbGVtZW50PiBpbnB1dCA9IGVsZW1lbnQoKTsKKyAgICAgICAg aW5wdXQtPnNldFZhbHVlRm9yVXNlcigiIik7CisgICAgICAgIGlucHV0LT5vblNlYXJjaCgpOwor ICAgICAgICBldmVudC0+c2V0RGVmYXVsdEhhbmRsZWQoKTsKKyAgICAgICAgcmV0dXJuOworICAg IH0KKyAgICBUZXh0RmllbGRJbnB1dFR5cGU6OmhhbmRsZUtleWRvd25FdmVudChldmVudCk7Cit9 CisKIHZvaWQgU2VhcmNoSW5wdXRUeXBlOjpkZXN0cm95U2hhZG93U3VidHJlZSgpCiB7CiAgICAg VGV4dEZpZWxkSW5wdXRUeXBlOjpkZXN0cm95U2hhZG93U3VidHJlZSgpOwpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvaHRtbC9TZWFyY2hJbnB1dFR5cGUuaCBiL1NvdXJjZS9XZWJDb3JlL2h0 bWwvU2VhcmNoSW5wdXRUeXBlLmgKaW5kZXggNjk5OWQxMWZmZTRmYjZhZmYyMWEyNGQ4OGY3OGI1 ZTMzZjJmNjU4MC4uODNlNWQ4ODlkZmExNzllYzUwNjEzNTFiZjQzNjk2MjdiNGI4NTAzNiAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9TZWFyY2hJbnB1dFR5cGUuaAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9odG1sL1NlYXJjaElucHV0VHlwZS5oCkBAIC01Miw2ICs1Miw3IEBAIHByaXZh dGU6CiAgICAgdmlydHVhbCB2b2lkIGRlc3Ryb3lTaGFkb3dTdWJ0cmVlKCk7CiAgICAgdmlydHVh bCBIVE1MRWxlbWVudCogcmVzdWx0c0J1dHRvbkVsZW1lbnQoKSBjb25zdDsKICAgICB2aXJ0dWFs IEhUTUxFbGVtZW50KiBjYW5jZWxCdXR0b25FbGVtZW50KCkgY29uc3Q7CisgICAgdmlydHVhbCB2 b2lkIGhhbmRsZUtleWRvd25FdmVudChLZXlib2FyZEV2ZW50Kik7CiAKICAgICBSZWZQdHI8SFRN TEVsZW1lbnQ+IG1fcmVzdWx0c0J1dHRvbjsKICAgICBSZWZQdHI8SFRNTEVsZW1lbnQ+IG1fY2Fu Y2VsQnV0dG9uOwo= 100940 2011-07-14 23:35:44 -0700 2011-07-15 01:11:07 -0700 Patch bug-51897-20110715153542.patch text/plain 7446 haraken U3VidmVyc2lvbiBSZXZpc2lvbjogOTEwNTEKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCAyMDcyMWRjYmQxYmE3ZTZjNjkyNmYy NGNmYTU3ZWFkZTQ4MDA5ZTJjLi4yY2I5NzVjY2E5YWE5NmM4NTdkOTZjYjdkMGI4NWQ4ZDY0ZjVm YjNlIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAKKzIwMTEtMDctMTQgIEtlbnRhcm8gSGFyYSAgPGhh cmFrZW5AZ29vZ2xlLmNvbT4KKworICAgICAgICBDbGVhciB0aGUgY29udGVudCBvZiBhIHNlYXJj aCBpbnB1dCBmb3JtIHdoZW4gJ0VzY2FwZScgaXMgcHJlc3NlZC4KKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUxODk3CisKKyAgICAgICAgVGhlIGFkZGVk IHRlc3QgY2hlY2tzIGlmIHRoZSB2YWx1ZSBpbiBhIHNlYXJjaCBpbnB1dCBmb3JtIGlzIGNsZWFy ZWQKKyAgICAgICAgYW5kIGEgJ3NlYXJjaCcgZXZlbnQgaXMgdHJpZ2dlcmVkLCB3aGVuIHdlIHBy ZXNzICdFc2NhcGUnIGtleS4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICAqIGZhc3QvZm9ybXMvaW5wdXQtc2VhcmNoLXByZXNzLWVzY2FwZS1rZXktZXhw ZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2Zvcm1zL2lucHV0LXNlYXJjaC1wcmVz cy1lc2NhcGUta2V5Lmh0bWw6IEFkZGVkLgorCiAyMDExLTA3LTE0ICBLZW5pY2hpIElzaGliYXNo aSAgPGJhc2hpQGNocm9taXVtLm9yZz4KIAogICAgICAgICA8aW5wdXQgZm9ybT0ieCI+IHNob3Vs ZCBub3QgYXNzb2NpYXRlIHRoZSBpbnB1dCB3aXRoIGFueSBmb3JtcyB3aGVuIHRoZXJlIGlzIG5v ICBmb3JtIHdpdGggaWQ9IngiCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL2lu cHV0LXNlYXJjaC1wcmVzcy1lc2NhcGUta2V5LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zh c3QvZm9ybXMvaW5wdXQtc2VhcmNoLXByZXNzLWVzY2FwZS1rZXktZXhwZWN0ZWQudHh0Cm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAuLmIzNGFhY2Y2NDY0N2E4MjkxMWVmOTk2ZWI0MmRlMjVmZjAzODU0MjMKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL2lucHV0LXNlYXJjaC1wcmVzcy1lc2Nh cGUta2V5LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDE3IEBACisKK1RoaXMgdGVzdHMgaWYgdGhl IHZhbHVlIGluIGEgc2VhcmNoIGlucHV0IGZvcm0gaXMgY2xlYXJlZCBhbmQgYSAnc2VhcmNoJyBl dmVudCBpcyB0cmlnZ2VyZWQsIHdoZW4gd2UgcHJlc3MgdGhlIEVzY2FwZSBrZXkuIFRvIHJ1biAo YSBwYXJ0IG9mKSB0aGlzIHRlc3QgbWFudWFsbHksIHR5cGUgc29tZSB0ZXh0IGluIHRoZSBzZWFy Y2ggZm9ybSBhbmQgdGhlbiBwcmVzcyB0aGUgRXNjYXBlIGtleS4gSWYgdGhlIHRleHQgaXMgY2xl YXJlZCwgdGhlbiB0aGUgdGVzdCBwYXNzZXMuCisKK1BBU1MgaW5wdXQudmFsdWUgaXMgIiIKK1BB U1Mgc2VhcmNoRXZlbnRPYnNlcnZlZCBpcyB0cnVlCitQQVNTIGlucHV0LnZhbHVlIGlzICIiCitQ QVNTIHNlYXJjaEV2ZW50T2JzZXJ2ZWQgaXMgdHJ1ZQorUEFTUyBpbnB1dC52YWx1ZSBpcyAiZm9v IgorUEFTUyBzZWFyY2hFdmVudE9ic2VydmVkIGlzIGZhbHNlCitQQVNTIGlucHV0LnZhbHVlIGlz ICJmb28iCitQQVNTIHNlYXJjaEV2ZW50T2JzZXJ2ZWQgaXMgZmFsc2UKK1BBU1MgaW5wdXQudmFs dWUgaXMgImZvbyIKK1BBU1Mgc2VhcmNoRXZlbnRPYnNlcnZlZCBpcyBmYWxzZQorUEFTUyBzdWNj ZXNzZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBMRVRFCisKZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL2Zhc3QvZm9ybXMvaW5wdXQtc2VhcmNoLXByZXNzLWVzY2FwZS1rZXkuaHRtbCBi L0xheW91dFRlc3RzL2Zhc3QvZm9ybXMvaW5wdXQtc2VhcmNoLXByZXNzLWVzY2FwZS1rZXkuaHRt bApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwLi4yZGI4YmFjMmM1ZmZjYThjNGE4NGI3NTJhOWY0YjcxMzcyMDdiNmMwCi0t LSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9pbnB1dC1zZWFyY2gtcHJl c3MtZXNjYXBlLWtleS5odG1sCkBAIC0wLDAgKzEsODIgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0 bWw+Cis8aGVhZD4KKzxzY3JpcHQgc3JjPSIuLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMi Pjwvc2NyaXB0PgorPHNjcmlwdCBzcmM9InJlc291cmNlcy9jb21tb24uanMiPjwvc2NyaXB0Pgor PC9oZWFkPgorPGJvZHk+Cis8aW5wdXQgaWQ9InNlYXJjaCIgdHlwZT0ic2VhcmNoIiBvbnNlYXJj aD0ic2VhcmNoRXZlbnREaXNwYXRjaGVkKCkiIC8+Cis8ZGl2IGlkPSJjb25zb2xlIj4KKzxwPgor VGhpcyB0ZXN0cyBpZiB0aGUgdmFsdWUgaW4gYSBzZWFyY2ggaW5wdXQgZm9ybSBpcyBjbGVhcmVk CithbmQgYSAnc2VhcmNoJyBldmVudCBpcyB0cmlnZ2VyZWQsIHdoZW4gd2UgcHJlc3MgdGhlIEVz Y2FwZSBrZXkuCitUbyBydW4gKGEgcGFydCBvZikgdGhpcyB0ZXN0IG1hbnVhbGx5LAordHlwZSBz b21lIHRleHQgaW4gdGhlIHNlYXJjaCBmb3JtIGFuZCB0aGVuIHByZXNzIHRoZSBFc2NhcGUga2V5 LgorSWYgdGhlIHRleHQgaXMgY2xlYXJlZCwgdGhlbiB0aGUgdGVzdCBwYXNzZXMuCis8L3A+Cis8 L2Rpdj4KKzxzY3JpcHQ+Cit2YXIgc2VhcmNoRXZlbnRPYnNlcnZlZDsKKworaWYgKHdpbmRvdy5s YXlvdXRUZXN0Q29udHJvbGxlciAmJiB3aW5kb3cuZXZlbnRTZW5kZXIpIHsKKyAgICB2YXIgaW5w dXQgPSAkKCJzZWFyY2giKTsKKyAgICB2YXIgZW5hYmxlZCA9IGZhbHNlOworICAgIHZhciBkaXNh YmxlZCA9IHRydWU7CisgICAgdmFyIHJlYWRvbmx5ID0gdHJ1ZTsKKworICAgIHNlYXJjaEV2ZW50 T2JzZXJ2ZWQgPSBmYWxzZTsKKyAgICBpbnB1dC5mb2N1cygpOworICAgIHNldElucHV0QXR0cmli dXRlcyhpbnB1dCwgImZvbyIsIGVuYWJsZWQpOworICAgIGV2ZW50U2VuZGVyLmtleURvd24oIlx4 MUIiKTsKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoJ2lucHV0LnZhbHVlJywgIiIpOworICAg IHNob3VsZEJlKCdzZWFyY2hFdmVudE9ic2VydmVkJywgJ3RydWUnKTsKKyAgICBpbnB1dC5ibHVy KCk7CisKKyAgICBzZWFyY2hFdmVudE9ic2VydmVkID0gZmFsc2U7CisgICAgaW5wdXQuZm9jdXMo KTsKKyAgICBzZXRJbnB1dEF0dHJpYnV0ZXMoaW5wdXQsICIiLCBlbmFibGVkKTsKKyAgICBldmVu dFNlbmRlci5rZXlEb3duKCJceDFCIik7CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCdpbnB1 dC52YWx1ZScsICIiKTsKKyAgICBzaG91bGRCZSgnc2VhcmNoRXZlbnRPYnNlcnZlZCcsICd0cnVl Jyk7CisgICAgaW5wdXQuYmx1cigpOworCisgICAgc2VhcmNoRXZlbnRPYnNlcnZlZCA9IGZhbHNl OworICAgIGlucHV0LmZvY3VzKCk7CisgICAgc2V0SW5wdXRBdHRyaWJ1dGVzKGlucHV0LCAiZm9v IiwgZW5hYmxlZCwgcmVhZG9ubHkpOworICAgIGV2ZW50U2VuZGVyLmtleURvd24oIlx4MUIiKTsK KyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoJ2lucHV0LnZhbHVlJywgImZvbyIpOworICAgIHNo b3VsZEJlKCdzZWFyY2hFdmVudE9ic2VydmVkJywgJ2ZhbHNlJyk7CisgICAgaW5wdXQuYmx1cigp OworCisgICAgc2VhcmNoRXZlbnRPYnNlcnZlZCA9IGZhbHNlOworICAgIGlucHV0LmZvY3VzKCk7 CisgICAgc2V0SW5wdXRBdHRyaWJ1dGVzKGlucHV0LCAiZm9vIiwgZGlzYWJsZWQpOworICAgIGV2 ZW50U2VuZGVyLmtleURvd24oIlx4MUIiKTsKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoJ2lu cHV0LnZhbHVlJywgImZvbyIpOworICAgIHNob3VsZEJlKCdzZWFyY2hFdmVudE9ic2VydmVkJywg J2ZhbHNlJyk7CisgICAgaW5wdXQuYmx1cigpOworCisgICAgc2VhcmNoRXZlbnRPYnNlcnZlZCA9 IGZhbHNlOworICAgIGlucHV0LmZvY3VzKCk7CisgICAgc2V0SW5wdXRBdHRyaWJ1dGVzKGlucHV0 LCAiZm9vIiwgZGlzYWJsZWQsIHJlYWRvbmx5KTsKKyAgICBldmVudFNlbmRlci5rZXlEb3duKCJc eDFCIik7CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCdpbnB1dC52YWx1ZScsICJmb28iKTsK KyAgICBzaG91bGRCZSgnc2VhcmNoRXZlbnRPYnNlcnZlZCcsICdmYWxzZScpOworICAgIGlucHV0 LmJsdXIoKTsKK30KKworZnVuY3Rpb24gc2V0SW5wdXRBdHRyaWJ1dGVzKGlucHV0LCB0ZXh0LCBk aXNhYmxlZCwgcmVhZG9ubHkpIHsKKyAgICBpbnB1dC52YWx1ZSA9IHRleHQ7CisgICAgaW5wdXQu ZGlzYWJsZWQgPSBkaXNhYmxlZDsKKyAgICBpbnB1dC5yZWFkT25seSA9ICEhcmVhZG9ubHk7Cit9 CisKK2Z1bmN0aW9uIHNlYXJjaEV2ZW50RGlzcGF0Y2hlZCgpIHsKKyAgICBzZWFyY2hFdmVudE9i c2VydmVkID0gdHJ1ZTsKK30KKwordmFyIHN1Y2Nlc3NmdWxseVBhcnNlZCA9IHRydWU7Cis8L3Nj cmlwdD4KKzxzY3JpcHQgc3JjPSIuLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wb3N0LmpzIj48L3Nj cmlwdD4KKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5n ZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA2NGQ4N2VmYjMzMjVlYWE5Njc4 NjMxOTY5ZDBmODRiZjEwYTliMzViLi4wNTYyMTA2OTc2NzljZjkwYWNhNWMzNjk1NDdjZjdjMDJj MmU4MGI5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNl L1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTkgQEAKKzIwMTEtMDctMTQgIEtlbnRhcm8g SGFyYSAgPGhhcmFrZW5AZ29vZ2xlLmNvbT4KKworICAgICAgICBDbGVhciB0aGUgY29udGVudCBv ZiBhIHNlYXJjaCBpbnB1dCBmb3JtIHdoZW4gJ0VzY2FwZScgaXMgcHJlc3NlZC4KKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUxODk3CisKKyAgICAgICAg VGhpcyBjaGFuZ2UgYWRkZWQgaGFuZGxlS2V5ZG93bkV2ZW50KCkgdG8gYSBzZWFyY2ggaW5wdXQg Zm9ybSwKKyAgICAgICAgd2hpY2ggY2xlYXJzIHRoZSBmb3JtIGFuZCB0cmlnZ2VycyBhICdzZWFy Y2gnIGV2ZW50IHdoZW4gJ0VzY2FwZScgaXMgcHJlc3NlZC4KKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBUZXN0OiBmYXN0L2Zvcm1zL2lucHV0LXNlYXJj aC1wcmVzcy1lc2NhcGUta2V5Lmh0bWwKKworICAgICAgICAqIGh0bWwvU2VhcmNoSW5wdXRUeXBl LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNlYXJjaElucHV0VHlwZTo6aGFuZGxlS2V5ZG93bkV2 ZW50KToKKyAgICAgICAgKiBodG1sL1NlYXJjaElucHV0VHlwZS5oOgorCiAyMDExLTA3LTE0ICBT cmF2YW5LdW1hciBTICA8c3JhdmFuLmtlbkBnbWFpbC5jb20+CiAKICAgICAgICAgUmVwbGFjZWQg aXNDaGVja2VkKCkgd2l0aCBzaG91bGRBcHBlYXJDaGVja2VkKCkgaW4gSFRNTElucHV0RWxlbWVu dC5jcHAgYWxvbmcgd2l0aCBhbGwgdGhlIGNvcnJlc3BvbmRpbmcgZnVuY3Rpb24gY2FsbHMuCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL1NlYXJjaElucHV0VHlwZS5jcHAgYi9Tb3Vy Y2UvV2ViQ29yZS9odG1sL1NlYXJjaElucHV0VHlwZS5jcHAKaW5kZXggYWJkZGIwMTg2ZjBiMzgx Y2IxYmY3ZmQ4MGJmZTM2ZTg4NzU1MDk2MC4uN2NkOWNhMWE4YzBjYjE2ZmM4NWNiNjZhMjFjYmJk NDZjYzQwZGY3YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9TZWFyY2hJbnB1dFR5 cGUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvU2VhcmNoSW5wdXRUeXBlLmNwcApAQCAt MzIsNiArMzIsNyBAQAogI2luY2x1ZGUgIlNlYXJjaElucHV0VHlwZS5oIgogCiAjaW5jbHVkZSAi SFRNTElucHV0RWxlbWVudC5oIgorI2luY2x1ZGUgIktleWJvYXJkRXZlbnQuaCIKICNpbmNsdWRl ICJSZW5kZXJUZXh0Q29udHJvbFNpbmdsZUxpbmUuaCIKICNpbmNsdWRlICJTaGFkb3dSb290Lmgi CiAjaW5jbHVkZSAiVGV4dENvbnRyb2xJbm5lckVsZW1lbnRzLmgiCkBAIC05OSw2ICsxMDAsMjQg QEAgSFRNTEVsZW1lbnQqIFNlYXJjaElucHV0VHlwZTo6Y2FuY2VsQnV0dG9uRWxlbWVudCgpIGNv bnN0CiAgICAgcmV0dXJuIG1fY2FuY2VsQnV0dG9uLmdldCgpOwogfQogCit2b2lkIFNlYXJjaElu cHV0VHlwZTo6aGFuZGxlS2V5ZG93bkV2ZW50KEtleWJvYXJkRXZlbnQqIGV2ZW50KQoreworICAg IGlmIChlbGVtZW50KCktPmRpc2FibGVkKCkgfHwgZWxlbWVudCgpLT5yZWFkT25seSgpKSB7Cisg ICAgICAgIFRleHRGaWVsZElucHV0VHlwZTo6aGFuZGxlS2V5ZG93bkV2ZW50KGV2ZW50KTsKKyAg ICAgICAgcmV0dXJuOworICAgIH0KKworICAgIGNvbnN0IFN0cmluZyYga2V5ID0gZXZlbnQtPmtl eUlkZW50aWZpZXIoKTsKKyAgICBpZiAoa2V5ID09ICJVKzAwMUIiKSB7CisgICAgICAgIFJlZlB0 cjxIVE1MSW5wdXRFbGVtZW50PiBpbnB1dCA9IGVsZW1lbnQoKTsKKyAgICAgICAgaW5wdXQtPnNl dFZhbHVlRm9yVXNlcigiIik7CisgICAgICAgIGlucHV0LT5vblNlYXJjaCgpOworICAgICAgICBl dmVudC0+c2V0RGVmYXVsdEhhbmRsZWQoKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKyAgICBU ZXh0RmllbGRJbnB1dFR5cGU6OmhhbmRsZUtleWRvd25FdmVudChldmVudCk7Cit9CisKIHZvaWQg U2VhcmNoSW5wdXRUeXBlOjpkZXN0cm95U2hhZG93U3VidHJlZSgpCiB7CiAgICAgVGV4dEZpZWxk SW5wdXRUeXBlOjpkZXN0cm95U2hhZG93U3VidHJlZSgpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvaHRtbC9TZWFyY2hJbnB1dFR5cGUuaCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvU2VhcmNo SW5wdXRUeXBlLmgKaW5kZXggZDE5ZDA3MTNhNjZiOWJjMjliNTU4OWExZTc1MWRjNjkxMTBkZGJi Zi4uYTlmZWZiMWZmN2QzOTA1NGI5NDMxNzg2ZWY2NjgyYjA3MGE2MDdiOSAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvaHRtbC9TZWFyY2hJbnB1dFR5cGUuaAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9odG1sL1NlYXJjaElucHV0VHlwZS5oCkBAIC01Niw2ICs1Niw3IEBAIHByaXZhdGU6CiAgICAg dmlydHVhbCB2b2lkIGRlc3Ryb3lTaGFkb3dTdWJ0cmVlKCk7CiAgICAgdmlydHVhbCBIVE1MRWxl bWVudCogcmVzdWx0c0J1dHRvbkVsZW1lbnQoKSBjb25zdDsKICAgICB2aXJ0dWFsIEhUTUxFbGVt ZW50KiBjYW5jZWxCdXR0b25FbGVtZW50KCkgY29uc3Q7CisgICAgdmlydHVhbCB2b2lkIGhhbmRs ZUtleWRvd25FdmVudChLZXlib2FyZEV2ZW50Kik7CiAKICAgICB2b2lkIHNlYXJjaEV2ZW50VGlt ZXJGaXJlZChUaW1lcjxTZWFyY2hJbnB1dFR5cGU+Kik7CiAK