27443 2009-07-20 05:44:33 -0700 [Gtk] Open menulists should support typeahead find 2010-12-01 08:47:08 -0800 1 1 1 Unclassified WebKit WebKitGTK 528+ (Nightly build) PC Linux RESOLVED FIXED P2 Enhancement --- 0 reinouts webkit-unassigned a.butenka apelete dglazkov gustavo mrobinson petersen webkit.review.bot xan.lopez oldest_to_newest 133117 0 reinouts 2009-07-20 05:44:33 -0700 Comboboxes currently don't react to keyboard input to quickly select an item from a long list. Please add this functionality. For the desired interaction model, please see the related Gtk+ bug http://bugzilla.gnome.org/show_bug.cgi?id=567141 154737 1 xan.lopez 2009-10-15 00:30:56 -0700 *** Bug 30329 has been marked as a duplicate of this bug. *** 155053 2 petersen 2009-10-16 03:03:22 -0700 Works for me currently. 213643 3 53605 apelete 2010-04-17 12:18:27 -0700 Created attachment 53605 PopupMenu "find as you type" search Hi, This is a rough patch intended to add find as you type functionalty to the PopupMenus: entries are searchable and automatically selected using the keyboard. A few caveats though: - only works with flat PopupMenu list items, ie. PopupMenus containing tree list items does not work well (don't know if the explanation is clear enough) - only modifier keys are handled well for the moment, anything beyond alphanumerical keys and modifiers may have an unexpected behaviour - there is no feedback during the search, except for the automatic selection of the searched item if found 223051 4 55503 apelete 2010-05-09 11:13:42 -0700 Created attachment 55503 PopupMenu "find as you type" search Handling of modifiers and some special keys have been improved for the moment; should work better at least. The search algorithm has been improved too, now filtering the list as the user enter more keys. 225598 5 56039 apelete 2010-05-13 18:03:03 -0700 Created attachment 56039 PopupMenu "find as you type" search I spotted a mistake in the search algorithm, making it not to work right. Put it right now, it should work ok :). You can now reset the search without closing the popup by pressing the "Delete" key on the keyboard. 230969 6 57170 apelete 2010-05-26 15:35:13 -0700 Created attachment 57170 Find-as-you-type proposed patch Added searching inside indented "tree lists". This should complete the patch, it nows seems to fix the bug. 230972 7 webkit.review.bot 2010-05-26 15:36:56 -0700 Attachment 57170 did not pass style-queue: Failed to run "['WebKitTools/Scripts/check-webkit-style', '--no-squash']" exit_code: 1 WebCore/platform/gtk/PopupMenuGtk.cpp:34: Streams are highly discouraged. [readability/streams] [3] WebCore/platform/gtk/PopupMenuGtk.cpp:168: Extra space before ( in function call [whitespace/parens] [4] WebCore/platform/gtk/PopupMenuGtk.cpp:211: Tests for true/false, null/non-null, and zero/non-zero should all be done without equality comparisons. [readability/comparison_to_zero] [5] WebCore/platform/gtk/PopupMenuGtk.cpp:231: Use 0 instead of NULL. [readability/null] [5] WebCore/platform/gtk/PopupMenuGtk.cpp:243: Tests for true/false, null/non-null, and zero/non-zero should all be done without equality comparisons. [readability/comparison_to_zero] [5] WebCore/platform/gtk/PopupMenuGtk.cpp:262: Use 0 instead of NULL. [readability/null] [5] WebCore/platform/gtk/PopupMenuGtk.cpp:273: Missing space before { [whitespace/braces] [5] WebCore/platform/PopupMenu.h:53: Alphabetical sorting problem. [build/include_order] [4] Total errors found: 8 in 3 files If any of these errors are false positives, please file a bug against check-webkit-style. 231053 8 webkit.review.bot 2010-05-26 20:16:28 -0700 Attachment 57170 did not build on chromium: Build output: http://webkit-commit-queue.appspot.com/results/2460044 231104 9 webkit.review.bot 2010-05-26 22:14:32 -0700 Attachment 57170 did not build on win: Build output: http://webkit-commit-queue.appspot.com/results/2506055 231251 10 a.butenka 2010-05-27 05:56:23 -0700 (In reply to comment #6) > Created an attachment (id=57170) [details] > Find-as-you-type proposed patch > > Added searching inside indented "tree lists". > This should complete the patch, it nows seems to fix the bug. Im not a reviewer, but as a quick followup: --- a/WebCore/platform/PopupMenu.h +++ b/WebCore/platform/PopupMenu.h @@ -50,7 +50,10 @@ typedef struct _GtkMenuItem GtkMenuItem; typedef struct _GtkWidget GtkWidget; #include "GRefPtrGtk.h" #include <wtf/HashMap.h> +#include <gdk/gdk.h> #include <glib.h> +#include <list> +#include <string> u cant include gdk.h in platform independent files without platform guard coz it will break all the platforms except gtk. patch is awesome, will simplify life a lot. 239060 11 57170 gustavo 2010-06-16 13:48:55 -0700 Comment on attachment 57170 Find-as-you-type proposed patch WebCore/platform/gtk/PopupMenuGtk.cpp:31 + #include <algorithm> Includes must be ordered, please take a look at http://webkit.org/coding/coding-style.html WebCore/platform/PopupMenu.h:77 + void trim(std::string&); We should protect all of the code with the platform checks. Having said that, I don't like having a trim implementation solely for this case. Aren't there other trim implementations in standard libraries we can use? I know pango has pango_trim_string, for example, could we not use it? In case there is no, I'd prefer having that code go into one of WebKit's string classes, and that class should be used here instead of std::string. WebCore/platform/gtk/PopupMenuGtk.cpp:236 + ++i) { This construct is very unusual in WebKit, please use a single line for code like this. WebCore/platform/gtk/PopupMenuGtk.cpp:266 + searchDomain = GTK_MENU_SHELL(that->m_popup.get())->children; We are avoiding using struct fields directly. Please use the same method used here: http://trac.webkit.org/changeset/61206 Have you considered contributing something similar to GTK+ directly? 246654 12 60537 apelete 2010-07-05 08:11:08 -0700 Created attachment 60537 Find-as-you-type proposed patch I hope this one build on all platforms :). About contibuting to something similar in GTK+ I actually thought the feature was missing in GTK+ at first, but I was told to implement it directly inside WebKit. Is it okay for me to continue working on the patch in order to get it approved in WebKit ? 251742 13 60537 pnormand 2010-07-15 02:08:06 -0700 Comment on attachment 60537 Find-as-you-type proposed patch >+// Test keypresses to see if they are to be passed to the event handler >+bool PopupMenu::isKeyPressToZap(GdkEventKey* event, PopupMenu* that) >+{ >+ guint keyval = gdk_unicode_to_keyval(event->keyval); >+ >+ if (keyval == (event->keyval | 0x01000000)) { >+ if (event->keyval == GDK_Delete) >+ resetWord(that); >+ return true; >+ } >+ >+ return false; >+} I'm not sure to understand the purpose of the first test, maybe adding a comment about it would be good? > >+// Search the word typed on the keyboard in the PopupMenu and select the >+// correspnding menuItem if found >+bool PopupMenu::menuSearchItem(GtkWidget* widget, GdkEventKey* event, PopupMenu* that) >+{ >+ ASSERT(that->m_popup); >+ >+ GList* searchDomain = 0, *searchDomainNext = 0; >+ >+ if (!isKeyPressToZap(event, that)) { >+ if (that->searchedWord.empty()) { >+ searchDomain = gtk_container_get_children(GTK_CONTAINER(that->m_popup.get())); >+ that->searchDomainList.push_front(searchDomain); >+ } >+ >+ that->searchedWord += event->keyval; >+ std::list<GList*>::iterator it = that->searchDomainList.begin(); >+ >+ if (search(*it, that->searchedWord, searchDomain)) { >+ GList* p = searchDomain; >+ gtk_menu_shell_select_item(GTK_MENU_SHELL(that->m_popup.get()), GTK_WIDGET(p->data)); >+ if (buildDomain(searchDomain, that->searchedWord, *it, searchDomainNext)) >+ that->searchDomainList.push_front(searchDomainNext); >+ return true; >+ } >+ } >+ >+ return false; >+} what about an early check here? Something like if (isKeyPressToZap(event, that)) return false; I'm no reviewer, this is just some feedback on your patch :) 253192 14 60537 gustavo 2010-07-19 07:32:07 -0700 Comment on attachment 60537 Find-as-you-type proposed patch  181 std::string searchedWord;  182 std::list<GList*> searchDomainList; As you can see from the other member variables, these should have m_ preffixing their names.  144 resetWord(that); This could be turned into that->resetWord();, which would make this look much more natural: [...]  160 // Clear the search and the associated domain list  161 void PopupMenu::resetWord(PopupMenu* that)  162 {  163 that->searchedWord.clear();  164 that->searchDomainList.clear();  165 } So you'd make this be a non-static private method, remove the argument, and use the member variables directly instead of through "that". The same could be the case for all the other functions that are coded like this only because they are callbacks. I would prefer having the callbacks be small, and just cause the object methods to be called. So you would have a keyPressEventCallback static method that would do if (!that->isKeyPressToZap(event)) { that->searchItem(event), which should make the bulk of the code more natural.  167 // Test keypresses to see if they are to be passed to the event handler  168 bool PopupMenu::isKeyPressToZap(GdkEventKey* event, PopupMenu* that)  169 {  170 guint keyval = gdk_unicode_to_keyval(event->keyval);  171  172 if (keyval == (event->keyval | 0x01000000)) {  173 if (event->keyval == GDK_Delete)  174 resetWord(that);  175 return true;  176 }  177  178 return false;  179 } It doesn't make too much sense to have a "conditional" call actually change stuff. The call to resetWord should go in the else block in the code that calls isKeyPressToZap. Also, this function seems to be overloaded for its name, as the comment above it implies. It's more a function to decide whether the press should be passed to the handler or not, though I am not positive what you're trying to do by returning true on this condition: keyval == (event->keyval | 0x01000000), what is that testing? Is this code based on some other code, btw? I'll say r- so we can get those issues resolved, thanks! 254316 15 62186 apelete 2010-07-21 08:40:41 -0700 Created attachment 62186 Find-as-you-type proposed patch Submitting again after taking into account the feedback above, thanks everyone. The patch was written from scratch, it's not based on some other code AFAIC. 254724 16 62186 xan.lopez 2010-07-22 04:28:04 -0700 Comment on attachment 62186 Find-as-you-type proposed patch >+ std::string m_searchedWord; I don't think std::string is commonly used in WebKit, check CString in WTF. >+ std::list<GList*> m_searchDomainList; Same for this, mixing two list implementations seems a bit weird. Maybe just stick to GList? >+// Test keypresses to see if they are to be passed to the event handler >+bool PopupMenu::isKeyPressToZap(GdkEventKey* event) The method name should be what the method does, not what it's used for IMHO. Since you seem to check if it's a modifier, the name should go along those lines. >+{ >+ guint keyval = gdk_unicode_to_keyval(event->keyval); So... isn't this already a key symbol? I'm confused. >+ >+ // If the key is a modifier it should be zapped >+ if (keyval == (event->keyval | 0x01000000)) >+ return true; In any case you should mention that this is what the function returns if there's no corresponding symbol, otherwise it's difficult to know what's going on. >+ >+ return false; >+} >+ >+// Search for a menuItem in a domain and returns the menuItem if found >+// searchDomain: the domain searched >+// word: the menuItem label >+// resultItem: the menuItem if found >+bool PopupMenu::search(GList* searchDomain, const std::string& word, GList*& resultItem) >+{ >+ ASSERT(searchDomain); >+ >+ std::string label; >+ unsigned int size = g_list_length(searchDomain); >+ >+ for (unsigned int i = 0; i < size; ++i) { >+ label = gtk_menu_item_get_label(GTK_MENU_ITEM(searchDomain->data)); >+ if (!label.empty()) >+ label = pango_trim_string(label.c_str()); >+ if (label.size() > word.size()) >+ label.erase(word.size()); >+ >+ if ((label.c_str() && word.c_str()) && !strcasecmp(label.c_str(), word.c_str())) { >+ resultItem = searchDomain; >+ return true; >+ } I think you should use the GLib UTF8 collate functions here, and just compare by prefix using the word length, seems more straightforward. >+ searchDomain = g_list_next(searchDomain); >+ } Micro-optimization time! You don't really need to go through the list once to get the size and then iterate again, just iterate until NEXT is NULL. >+ >+ return false; >+} >+ >+// Build a search domain containing menuItems starting with 'word' >+// startingFrom: starting position in the current search domain >+// word: prefix of menuItem label looked for >+// currentDomain: current search domain >+// result: builded search domain if currentDomain has been reduced >+bool PopupMenu::buildDomain(GList* startingFrom, const std::string& word, GList* currentDomain, GList*& result) >+{ >+ ASSERT(startingFrom); >+ >+ std::string label; >+ GList* newDomain = 0; >+ unsigned int size = g_list_length(startingFrom); >+ >+ for (unsigned int i = g_list_index(startingFrom, startingFrom->data); i < size; ++i) { >+ label = gtk_menu_item_get_label(GTK_MENU_ITEM(startingFrom->data)); >+ if (!label.empty()) >+ label = pango_trim_string(label.c_str()); >+ if (label.size() > word.size()) >+ label.erase(word.size()); >+ >+ if ((label.c_str() && word.c_str()) && !strcasecmp(label.c_str(), word.c_str())) >+ newDomain = g_list_prepend(newDomain, startingFrom->data); >+ startingFrom = g_list_next(startingFrom); >+ } All the comments for the previous method apply. >+ >+ if (g_list_length(newDomain) < g_list_length(currentDomain)) { >+ result = g_list_reverse(newDomain); Mmm, why do we need to reverse it? >+ return true; >+ } >+ >+ return false; >+} >+ >+// Search the word typed on the keyboard in the PopupMenu and select the >+// correspnding menuItem if found typo in 'correspnding'. 254727 17 xan.lopez 2010-07-22 04:38:11 -0700 Another comment: not sure why we need a list of search domains, seems to me just the current one should be more than enough, at least for what this patch does. 260225 18 63496 apelete 2010-08-04 14:54:51 -0700 Created attachment 63496 Find-as-you-type proposed patch Now using GLib types instead of STL ones, plus the few changes suggested above. 261772 19 63496 mrobinson 2010-08-07 14:20:54 -0700 Comment on attachment 63496 Find-as-you-type proposed patch Thanks for working on this patch. I agree that this functionality is very important to have and I'm glad you're tackling it. > #elif PLATFORM(GTK) > + GList* m_searchDomain; > + GString* m_searchedWord; Please use GOwnPtr for these types and be sure to write template specializations for them if they do not exist yet. This will reduce the risk of memory leaks greatly. I'm not sure I understand exactly why you are caching the menu items here (m_searchDomain), is the performance gain worth it? If you didn't, it seems like you could get rid of the filterDomain method. Take a look at PopupListBox::typeAheadFind in the chromium directory for where they implement this same behavior in one method. Maybe we should match that? > + void resetWord(); > + bool isPrintable(GdkEventKey*); > + bool search(GList*, GString*&, GList*&); > + bool filterDomain(GList*, GString*&, GList*, GList*&); > + void searchItem(GdkEventKey*, PopupMenu*); > + static bool keyPressEventCallback(GtkWidget*, GdkEventKey*, PopupMenu*); In my opinion, these method names are too general. There is no way to tell by looking at them they pertain to find-as-you-type. I don't mean to nit too hard, but "Domain" has a fairly overloaded meaning in web browsers. Maybe it could be "PossibleTypeAheadFindResults." Bytes are very cheap! :) > + g_list_free(m_searchDomain); > + g_string_free(m_searchedWord, TRUE); This kind of stuff can be omitted entirely if you switch to GOwnPtr, or even switching to using WebCore types (though I know that you just switched it to GObject types, so maybe that kind of change could happen in a later cleanup). > g_list_free(children); > gtk_menu_popup(m_popup.get(), 0, 0, reinterpret_cast<GtkMenuPositionFunc>(menuPositionFunction), this, 0, gtk_get_current_event_time()); > + m_searchedWord = g_string_new(NULL); Isn't it possible at this point for m_searchWord to already exist? Again using GOwnPtr here would prevent a memory leak. > + for (; searchDomain; searchDomain = g_list_next(searchDomain)) { > + g_string_assign(label, gtk_menu_item_get_label(GTK_MENU_ITEM(searchDomain->data))); > + if (label->len) > + g_string_assign(label, pango_trim_string(label->str)); In my opinion, it isn't worth using pango here, just to use pango_trim_string. It probably makes much more sense to use WebCore::String and just call stripWhiteSpace(). You would avoid any need for manual memory management that way. Remember to handle the conversion from UTF8 properly (fromUTF8). Including here: > + g_string_free(label, TRUE); and here: > + g_string_free(label, TRUE); :) > +bool PopupMenu::filterDomain(GList* startingFrom, GString*& word, GList* currentDomain, GList*& result) I'm still not convinced this is necessary. What happens if the menu changes while the user is typing? Is that possible? Why is the "word" parameter a reference to a pointer? That's very confusing and could lead to errors. > +// Search the word typed on the keyboard in the PopupMenu and select the > +// corresponding menuItem if found > +void PopupMenu::searchItem(GdkEventKey* event, PopupMenu* that) Why are you passing in "that" to the method here? that == this! > +bool PopupMenu::keyPressEventCallback(GtkWidget* widget, GdkEventKey* event, PopupMenu* that) > +{ > + if (that->isPrintable(event)) { > + that->searchItem(event, that); > + return true; > + } > + // Reset the search on Delete key press > + if (event->keyval == GDK_Delete) > + that->resetWord(); I feel like these if statement should be folded into searchItem, since this effectively splits up the logic of find-as-you-type between the outside of the class and the inside. You could just give the method a more general name, much like Chromium's typeAheadFind. So you could just do: > +bool PopupMenu::keyPressEventCallback(GtkWidget* widget, GdkEventKey* event, PopupMenu* that) > +{ > + return that->typeAheadFind(event); 261864 20 xan.lopez 2010-08-08 01:27:22 -0700 (In reply to comment #19) > > #elif PLATFORM(GTK) > > + GList* m_searchDomain; > > + GString* m_searchedWord; > > Please use GOwnPtr for these types and be sure to write template > specializations for them if they do not exist yet. This will reduce > the risk of memory leaks greatly. > (...) > > + g_list_free(m_searchDomain); > > + g_string_free(m_searchedWord, TRUE); > > This kind of stuff can be omitted entirely if you switch to > GOwnPtr, or even switching to using WebCore types (though I > know that you just switched it to GObject types, so maybe that > kind of change could happen in a later cleanup). I suggested moving to glib string types (from a previous suggestion where I said to use the WebCore types :D)), because here we are going to be doing substring comparison against glib utf8 C strings all the time, and going back and forth between webcore types and that seems a bit pointless. I think using GString + GOwnPtr is the best compromise. > I'm not sure I understand exactly why you are caching the menu items > here (m_searchDomain), is the performance gain worth it? If you didn't, > it seems like you could get rid of the filterDomain method. Take a look > at PopupListBox::typeAheadFind in the chromium directory for where they > implement this same behavior in one method. Maybe we should match that? > I'm not sure if the gain is noticeable (it might be in big combos, since this code should be filtering the list in ~real-time) but now that this is written, and since it's not that complex, I think it's reasonable to just keep it. We could do a first version without it and then add the optimization in a follow-up (I think I might have suggested this at some point), but no strong feelings here. 263537 21 mrobinson 2010-08-11 17:45:01 -0700 > I'm not sure if the gain is noticeable (it might be in big combos, since this code should be filtering the list in ~real-time) but now that this is written, and since it's not that complex, I think it's reasonable to just keep it. We could do a first version without it and then add the optimization in a follow-up (I think I might have suggested this at some point), but no strong feelings here. There's an out-standing bug about big combos that's related, by the way: https://bugzilla.gnome.org/show_bug.cgi?id=153605 263544 22 63496 mrobinson 2010-08-11 18:10:02 -0700 Comment on attachment 63496 Find-as-you-type proposed patch r- for the issues I mentioned before. 314962 23 75127 mrobinson 2010-11-30 05:17:45 -0800 Created attachment 75127 Patch for this issue 315019 24 75127 xan.lopez 2010-11-30 07:07:34 -0800 Comment on attachment 75127 Patch for this issue View in context: https://bugs.webkit.org/attachment.cgi?id=75127&action=review > WebCore/platform/gtk/PopupMenuGtk.cpp:168 > + bool repeatingCharacter = unicodeCharacter != m_previousKeyEventCharacter; Can we mention here we are matching the WebCore behavior when the menulist is closed? 315666 25 mrobinson 2010-12-01 08:47:08 -0800 Committed r73025: <http://trac.webkit.org/changeset/73025> 53605 2010-04-17 12:18:27 -0700 2010-05-09 11:13:42 -0700 PopupMenu "find as you type" search patch.txt text/plain 4213 apelete Y29tbWl0IDE4MzdhMGQyYTBkYjljMTJiMzBlMTM5Y2ZiZTlhYzRkMTA4MTk5NGIKQXV0aG9yOiBB cGVsZXRlIFNla2V0ZWxpIDxhcGVsZXRlQHNla2V0ZWxpLm9yZz4KRGF0ZTogICBTYXQgQXByIDE3 IDE2OjE0OjM3IDIwMTAgKzAyMDAKCiAgICBBZGQgUG9wdXBNZW51ICJmaW5kIGFzIHlvdSB0eXBl IiBzZWFyY2ggKCMyNzQ0MykKICAgIAogICAgV2ViQ29yZS9wbGF0ZWZvcm0vZ3RrL1BvcHVwTWVu dUd0ay5jcHA6CiAgICAgICAgKmlzS2V5UHJlc3NUb1phcDogaGVscGVyIGZ1bmN0aW9uIGZvciBt ZW51U2VhcmNoSXRlbS4KICAgICAgICAgICAgcmV0dXJucyBGQUxTRSBpZiB0aGUga2V5cHJlc3Mg aXMgdG8gYmUgdXNlZCBieSB0aGUgZXZlbnQgaGFuZGxlcgogICAgICAgICAgICAobWVudVNlYXJj aEl0ZW0pLCBUUlVFIG90aGVyd2lzZS4KICAgICAgICAqbWVudVNlYXJjaEl0ZW06IHNlYXJjaCBm b3Igc29tZXRoaW5nIHR5cGVkIG9uIHRoZSBrZXlib2FyZCBpbiB0aGUgUG9wdXBNZW51CiAgICAg ICAgbGlzdCBvZiBpdGVtcyBhbmQgc2VsZWN0IHRoZSBjb3JyZXNwb25kaW5nIGVudHJ5LgogICAg ICAgICAgICByZXR1cm5zIFRSVUUgaWYgdGhlIGVudGVyZWQgd29yZCBpcyBmb3VuZCBpbiB0aGUg UG9wdXBNZW51LCBGQUxTRSBpZiBub3QKICAgICAgICAgICAgZm91bmQuCgpkaWZmIC0tZ2l0IGEv V2ViQ29yZS9wbGF0Zm9ybS9Qb3B1cE1lbnUuaCBiL1dlYkNvcmUvcGxhdGZvcm0vUG9wdXBNZW51 LmgKaW5kZXggNGRmMGRjZC4uNTc4ODRjYyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9Q b3B1cE1lbnUuaAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL1BvcHVwTWVudS5oCkBAIC01MCw3ICs1 MCw5IEBAIHR5cGVkZWYgc3RydWN0IF9HdGtNZW51SXRlbSBHdGtNZW51SXRlbTsKIHR5cGVkZWYg c3RydWN0IF9HdGtXaWRnZXQgR3RrV2lkZ2V0OwogI2luY2x1ZGUgIkdSZWZQdHJHdGsuaCIKICNp bmNsdWRlIDx3dGYvSGFzaE1hcC5oPgorI2luY2x1ZGUgPGdkay9nZGsuaD4KICNpbmNsdWRlIDxn bGliLmg+CisjaW5jbHVkZSA8c3RyaW5nPgogI2VsaWYgUExBVEZPUk0oV1gpCiAjaWZkZWYgX19X WE1TV19fCiAjaW5jbHVkZSA8d3gvbXN3L3dpbnVuZGVmLmg+CkBAIC0xNzUsNiArMTc3LDcgQEAg cHJpdmF0ZToKICAgICBib29sIG1fc2Nyb2xsYmFyQ2FwdHVyaW5nTW91c2U7CiAgICAgYm9vbCBt X3Nob3dQb3B1cDsKICNlbGlmIFBMQVRGT1JNKEdUSykKKyAgICBzdGQ6OnN0cmluZyBzZWFyY2hl ZFdvcmQ7CiAgICAgSW50UG9pbnQgbV9tZW51UG9zaXRpb247CiAgICAgR1JlZlB0cjxHdGtNZW51 PiBtX3BvcHVwOwogICAgIEhhc2hNYXA8R3RrV2lkZ2V0KiwgaW50PiBtX2luZGV4TWFwOwpAQCAt MTgyLDYgKzE4NSw4IEBAIHByaXZhdGU6CiAgICAgc3RhdGljIHZvaWQgbWVudVVubWFwcGVkKEd0 a1dpZGdldCosIFBvcHVwTWVudSopOwogICAgIHN0YXRpYyB2b2lkIG1lbnVQb3NpdGlvbkZ1bmN0 aW9uKEd0a01lbnUqLCBnaW50KiwgZ2ludCosIGdib29sZWFuKiwgUG9wdXBNZW51Kik7CiAgICAg c3RhdGljIHZvaWQgbWVudVJlbW92ZUl0ZW0oR3RrV2lkZ2V0KiwgUG9wdXBNZW51Kik7CisgICAg c3RhdGljIGJvb2wgaXNLZXlQcmVzc1RvWmFwKEdka0V2ZW50S2V5KiBldmVudCk7CisgICAgc3Rh dGljIGJvb2wgbWVudVNlYXJjaEl0ZW0oR3RrV2lkZ2V0KiB3aWRnZXQsIEdka0V2ZW50S2V5KiBl dmVudCwgUG9wdXBNZW51Kik7CiAjZWxpZiBQTEFURk9STShXWCkKICAgICB3eE1lbnUqIG1fbWVu dTsKICAgICB2b2lkIE9uTWVudUl0ZW1TZWxlY3RlZCh3eENvbW1hbmRFdmVudCYpOwpkaWZmIC0t Z2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvUG9wdXBNZW51R3RrLmNwcCBiL1dlYkNvcmUvcGxh dGZvcm0vZ3RrL1BvcHVwTWVudUd0ay5jcHAKaW5kZXggMDM2M2FjNC4uODI3YzFmMiAxMDA2NDQK LS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvUG9wdXBNZW51R3RrLmNwcAorKysgYi9XZWJDb3Jl L3BsYXRmb3JtL2d0ay9Qb3B1cE1lbnVHdGsuY3BwCkBAIC0zMCw2ICszMCw5IEBACiAjaW5jbHVk ZSAiSG9zdFdpbmRvdy5oIgogI2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCiAjaW5jbHVkZSA8 Z3RrL2d0ay5oPgorI2luY2x1ZGUgPGlvc3RyZWFtPgorI2luY2x1ZGUgPGN0eXBlLmg+CisjaW5j bHVkZSA8c3RyaW5ncy5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKQEAgLTUzLDYgKzU2LDcg QEAgdm9pZCBQb3B1cE1lbnU6OnNob3coY29uc3QgSW50UmVjdCYgcmVjdCwgRnJhbWVWaWV3KiB2 aWV3LCBpbnQgaW5kZXgpCiAgICAgaWYgKCFtX3BvcHVwKSB7CiAgICAgICAgIG1fcG9wdXAgPSBH VEtfTUVOVShndGtfbWVudV9uZXcoKSk7CiAgICAgICAgIGdfc2lnbmFsX2Nvbm5lY3QobV9wb3B1 cC5nZXQoKSwgInVubWFwIiwgR19DQUxMQkFDSyhtZW51VW5tYXBwZWQpLCB0aGlzKTsKKwlnX3Np Z25hbF9jb25uZWN0KG1fcG9wdXAuZ2V0KCksICJrZXktcHJlc3MtZXZlbnQiLCBHX0NBTExCQUNL KG1lbnVTZWFyY2hJdGVtKSwgdGhpcyk7CiAgICAgfSBlbHNlCiAgICAgICAgIGd0a19jb250YWlu ZXJfZm9yZWFjaChHVEtfQ09OVEFJTkVSKG1fcG9wdXAuZ2V0KCkpLCByZWludGVycHJldF9jYXN0 PEd0a0NhbGxiYWNrPihtZW51UmVtb3ZlSXRlbSksIHRoaXMpOwogCkBAIC0xMzQsNiArMTM4LDcg QEAgdm9pZCBQb3B1cE1lbnU6Om1lbnVVbm1hcHBlZChHdGtXaWRnZXQqLCBQb3B1cE1lbnUqIHRo YXQpCiB7CiAgICAgQVNTRVJUKHRoYXQtPmNsaWVudCgpKTsKICAgICB0aGF0LT5jbGllbnQoKS0+ cG9wdXBEaWRIaWRlKCk7CisgICAgdGhhdC0+c2VhcmNoZWRXb3JkID0gIiI7CiB9CiAKIHZvaWQg UG9wdXBNZW51OjptZW51UG9zaXRpb25GdW5jdGlvbihHdGtNZW51KiwgZ2ludCogeCwgZ2ludCog eSwgZ2Jvb2xlYW4qIHB1c2hJbiwgUG9wdXBNZW51KiB0aGF0KQpAQCAtMTQ5LDUgKzE1NCwzOSBA QCB2b2lkIFBvcHVwTWVudTo6bWVudVJlbW92ZUl0ZW0oR3RrV2lkZ2V0KiB3aWRnZXQsIFBvcHVw TWVudSogdGhhdCkKICAgICBndGtfY29udGFpbmVyX3JlbW92ZShHVEtfQ09OVEFJTkVSKHRoYXQt Pm1fcG9wdXAuZ2V0KCkpLCB3aWRnZXQpOwogfQogCitib29sIFBvcHVwTWVudTo6aXNLZXlQcmVz c1RvWmFwKEdka0V2ZW50S2V5KiBldmVudCkKK3sKKyAgICBpZiAoZXZlbnQtPmlzX21vZGlmaWVy KQorICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICByZXR1cm4gZmFsc2U7Cit9CisKK2Jvb2wgUG9w dXBNZW51OjptZW51U2VhcmNoSXRlbShHdGtXaWRnZXQqIHdpZGdldCwgR2RrRXZlbnRLZXkqIGV2 ZW50LCBQb3B1cE1lbnUqIHRoYXQpCit7CisgICAgQVNTRVJUKHRoYXQtPmNsaWVudCgpKTsKKyAg ICBBU1NFUlQodGhhdC0+bV9wb3B1cCk7CisKKyAgICBpZiAoIWlzS2V5UHJlc3NUb1phcChldmVu dCkpIHsKKyAgICAgICAgdGhhdC0+c2VhcmNoZWRXb3JkICs9IGV2ZW50LT5rZXl2YWw7CisKKyAg ICAgICAgc3RkOjpzdHJpbmcgbGFiZWw7CisgICAgICAgIGNvbnN0IGludCBzaXplID0gdGhhdC0+ Y2xpZW50KCktPmxpc3RTaXplKCk7CisgICAgICAgIEdMaXN0KiBjaGlsZHJlbiA9IEdUS19NRU5V X1NIRUxMKHRoYXQtPm1fcG9wdXAuZ2V0KCkpLT5jaGlsZHJlbjsKKworICAgICAgICBmb3IgKGlu dCBpID0gMDsgaSA8IHNpemU7ICsraSkgeworICAgICAgICAgICAgbGFiZWwgPSBndGtfbWVudV9p dGVtX2dldF9sYWJlbChHVEtfTUVOVV9JVEVNKGNoaWxkcmVuLT5kYXRhKSk7CisgICAgICAgICAg ICAvLyBTZWFyY2hpbmcgZm9yIGlucHV0IGluIHN1YnN0cmluZyBvZiBsYWJlbAorICAgICAgICAg ICAgbGFiZWwgPSBsYWJlbC5zdWJzdHIoMCwgdGhhdC0+c2VhcmNoZWRXb3JkLnNpemUoKSk7Cisg ICAgICAgICAgICBpZiAoc3RyY2FzZWNtcChsYWJlbC5jX3N0cigpLCB0aGF0LT5zZWFyY2hlZFdv cmQuY19zdHIoKSkgPT0gMCkgeworICAgICAgICAgICAgICAgIGd0a19tZW51X3NoZWxsX3NlbGVj dF9pdGVtKEdUS19NRU5VX1NIRUxMKHRoYXQtPm1fcG9wdXAuZ2V0KCkpLCBHVEtfV0lER0VUKGNo aWxkcmVuLT5kYXRhKSk7CisgICAgICAgICAgICAgICAgcmV0dXJuIHRydWU7CisgICAgICAgICAg ICB9IGVsc2UKKyAgICAgICAgICAgICAgICBjaGlsZHJlbiA9IGdfbGlzdF9uZXh0KGNoaWxkcmVu KTsKKyAgICAgICAgfQorICAgIH0KKworICAgIHJldHVybiBmYWxzZTsKK30KKwogfQogCg== 55503 2010-05-09 11:13:42 -0700 2010-05-13 18:03:03 -0700 PopupMenu "find as you type" search patch.txt text/plain 8462 apelete Y29tbWl0IDBiZGYzYjRhODFhMWEzMTcwMTg3OTcxMjZjMjMzYWM1ZWI1ZjEwODUKQXV0aG9yOiBB cGVsZXRlIFNla2V0ZWxpIDxhcGVsZXRlQHNla2V0ZWxpLm9yZz4KRGF0ZTogICBTYXQgQXByIDE3 IDE2OjE0OjM3IDIwMTAgKzAyMDAKCiAgICBBZGQgUG9wdXBNZW51ICJmaW5kIGFzIHlvdSB0eXBl IiBzZWFyY2ggKCMyNzQ0MykKICAgIAogICAgSW1wcm92ZWQgdGhlIHNlYXJjaCBieSBwcm9ncmVz c2l2ZWx5IGZpbHRlciB0aGUgbGlzdCBhcyB1c2VyIGVudGVyIG1vcmUga2V5cy4KICAgIFJlZmVy IHRvIHRoZSBjaGFuZ2Vsb2cgYmVsb3cgZm9yIG1vcmUgZGV0YWlscy4KCmRpZmYgLS1naXQgYS9X ZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IGFjYmNlN2YuLjUwOGU1 MGIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1dlYkNvcmUvQ2hhbmdlTG9n CkBAIC0xLDMgKzEsMzEgQEAKKzIwMTAtMDUtMDggIEFwZWxldGUgU2VrZXRlbGkgIDxhcGVsZXRl QHNla2V0ZWxpLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBCdWcgMjc0NDM6IENvbWJvYm94IHNob3VsZCBzdXBwb3J0ICJmaW5kLWFzLXlvdS10 eXBlIiBzZWFyY2gKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTI3NDQzCisKKyAgICAgICAgTm8gbmV3IHRlc3RzIGFzIHRoZXJlIGlzIG5vIG5ldyBmdW5j dGlvbmFsaXR5LgorCisgICAgICAgICogcGxhdGZvcm0vUG9wdXBNZW51Lmg6CisgICAgICAgICog cGxhdGZvcm0vZ3RrL1BvcHVwTWVudUd0ay5jcHA6CisgICAgICAgIChXZWJDb3JlOjpQb3B1cE1l bnU6OnNob3cpOgorICAgICAgICAoV2ViQ29yZTo6UG9wdXBNZW51OjptZW51VW5tYXBwZWQpOgor ICAgICAgICAoV2ViQ29yZTo6UG9wdXBNZW51Ojppc0tleVByZXNzVG9aYXApOgorICAgICAgICAg ICAgSGVscGVyIGZ1bmN0aW9uIGZvciBtZW51U2FlcmNoSXRlbS4KKyAgICAgICAgICAgIFJldHVy bnMgRkFMU0UgaWYgdGhlIGtleXByZXNzIGlzIHRvIGJlIHVzZWQgYnkgdGhlIGV2ZW50IGhhbmRs ZXIgKG1lbnVTZWFyY2hJdGVtKSwgVFJVRSBvdGhlcndpc2UuCisgICAgICAgIChXZWJDb3JlOjpQ b3B1cE1lbnU6OnNlYXJjaCk6CisgICAgICAgICAgICBIZWxwZXIgZnVuY3Rpb24gZm9yIG1lbnVT ZWFyY2hJdGVtLgorICAgICAgICAgICAgUmV0dXJucyBUUlVFIGlmIHNlYXJjaGVkIGVudHJ5IGhh cyBiZWVuIGZvdW5kLgorICAgICAgICAgICAgUmV0dXJucyB0aGUgZW50cnkgdG8gYmUgc2VsZWN0 ZWQgaW4gdGhlIHRoaXJkIHBhcmFtZXRlciBpZiBUUlVFLgorICAgICAgICAoV2ViQ29yZTo6UG9w dXBNZW51OjpidWlsZERvbWFpbik6CisgICAgICAgICAgICBIZWxwZXIgZnVuY3Rpb24gZm9yIG1l bnVTZWFyY2hJdGVtLgorICAgICAgICAgICAgUmV0dXJucyBUUlVFIGlmIHNlYXJjaCBkb21haW4g aGFzIGJlZW4gc3VjY2Vzc2Z1bGx5IHJlZHVjZWQuCisgICAgICAgICAgICBSZXR1cm5zIHRoZSBu ZXcgc2VhcmNoIGRvbWFpbiBpbiB0aGUgdGhpcmQgcGFyYW1ldGVyIGlmIFRSVUUuCisgICAgICAg IChXZWJDb3JlOjpQb3B1cE1lbnU6Om1lbnVTZWFyY2hJdGVtKToKKyAgICAgICAgICAgIFNlYXJj aCBmb3Igc29tZXRoaW5nIHR5cGVkIG9uIHRoZSBrZXlib2FyZCBpbiB0aGUgUG9wdXBNZW51IGxp c3Qgb2YgaXRlbXMgYW5kIHNlbGVjdCB0aGUgY29ycmVzcG9uZGluZyBlbnRyeS4KKyAgICAgICAg ICAgIFJldHVybnMgVFJVRSBpZiB0aGUgZW50ZXJlZCB3b3JkIGlzIGZvdW5kIGluIHRoZSBQb3B1 cE1lbnUsIEZBTFNFIGlmIG5vdC4KKwogMjAxMC0wMy0yOCAgTGFzemxvIEdvbWJvcyAgPGxhc3ps by4xLmdvbWJvc0Bub2tpYS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgU2ltb24gSGF1c21h bm4uCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL1BvcHVwTWVudS5oIGIvV2ViQ29yZS9w bGF0Zm9ybS9Qb3B1cE1lbnUuaAppbmRleCA0ZGYwZGNkLi43MWVlMTEyIDEwMDY0NAotLS0gYS9X ZWJDb3JlL3BsYXRmb3JtL1BvcHVwTWVudS5oCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vUG9wdXBN ZW51LmgKQEAgLTUwLDcgKzUwLDEwIEBAIHR5cGVkZWYgc3RydWN0IF9HdGtNZW51SXRlbSBHdGtN ZW51SXRlbTsKIHR5cGVkZWYgc3RydWN0IF9HdGtXaWRnZXQgR3RrV2lkZ2V0OwogI2luY2x1ZGUg IkdSZWZQdHJHdGsuaCIKICNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgorI2luY2x1ZGUgPGdkay9n ZGsuaD4KICNpbmNsdWRlIDxnbGliLmg+CisjaW5jbHVkZSA8bGlzdD4KKyNpbmNsdWRlIDxzdHJp bmc+CiAjZWxpZiBQTEFURk9STShXWCkKICNpZmRlZiBfX1dYTVNXX18KICNpbmNsdWRlIDx3eC9t c3cvd2ludW5kZWYuaD4KQEAgLTE3NSw2ICsxNzgsOCBAQCBwcml2YXRlOgogICAgIGJvb2wgbV9z Y3JvbGxiYXJDYXB0dXJpbmdNb3VzZTsKICAgICBib29sIG1fc2hvd1BvcHVwOwogI2VsaWYgUExB VEZPUk0oR1RLKQorICAgIHN0ZDo6c3RyaW5nIHNlYXJjaGVkV29yZDsKKyAgICBzdGQ6Omxpc3Q8 R0xpc3QqPiBzZWFyY2hEb21haW5MaXN0OwogICAgIEludFBvaW50IG1fbWVudVBvc2l0aW9uOwog ICAgIEdSZWZQdHI8R3RrTWVudT4gbV9wb3B1cDsKICAgICBIYXNoTWFwPEd0a1dpZGdldCosIGlu dD4gbV9pbmRleE1hcDsKQEAgLTE4Miw2ICsxODcsMTAgQEAgcHJpdmF0ZToKICAgICBzdGF0aWMg dm9pZCBtZW51VW5tYXBwZWQoR3RrV2lkZ2V0KiwgUG9wdXBNZW51Kik7CiAgICAgc3RhdGljIHZv aWQgbWVudVBvc2l0aW9uRnVuY3Rpb24oR3RrTWVudSosIGdpbnQqLCBnaW50KiwgZ2Jvb2xlYW4q LCBQb3B1cE1lbnUqKTsKICAgICBzdGF0aWMgdm9pZCBtZW51UmVtb3ZlSXRlbShHdGtXaWRnZXQq LCBQb3B1cE1lbnUqKTsKKyAgICBzdGF0aWMgYm9vbCBpc0tleVByZXNzVG9aYXAoR2RrRXZlbnRL ZXkqIGV2ZW50KTsKKyAgICBzdGF0aWMgYm9vbCBzZWFyY2goR0xpc3QqIHNlYXJjaERvbWFpbiwg Y29uc3Qgc3RkOjpzdHJpbmcmIHdvcmQsIEdMaXN0KiYgcmVzdWx0SXRlbSk7CisgICAgc3RhdGlj IGJvb2wgYnVpbGREb21haW4oR0xpc3QqIGluaXRpYWxEb21haW4sIGNvbnN0IHN0ZDo6c3RyaW5n JiB3b3JkLCBHTGlzdComIHJlc3VsdCk7CisgICAgc3RhdGljIGJvb2wgbWVudVNlYXJjaEl0ZW0o R3RrV2lkZ2V0KiB3aWRnZXQsIEdka0V2ZW50S2V5KiBldmVudCwgUG9wdXBNZW51Kik7CiAjZWxp ZiBQTEFURk9STShXWCkKICAgICB3eE1lbnUqIG1fbWVudTsKICAgICB2b2lkIE9uTWVudUl0ZW1T ZWxlY3RlZCh3eENvbW1hbmRFdmVudCYpOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9n dGsvUG9wdXBNZW51R3RrLmNwcCBiL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1BvcHVwTWVudUd0ay5j cHAKaW5kZXggMDM2M2FjNC4uZDJhMDRjMiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9n dGsvUG9wdXBNZW51R3RrLmNwcAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Qb3B1cE1lbnVH dGsuY3BwCkBAIC0yOSw3ICsyOSwxMCBAQAogI2luY2x1ZGUgIkZyYW1lVmlldy5oIgogI2luY2x1 ZGUgIkhvc3RXaW5kb3cuaCIKICNpbmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgorI2luY2x1ZGUg PGdkay9nZGtrZXlzeW1zLmg+CiAjaW5jbHVkZSA8Z3RrL2d0ay5oPgorI2luY2x1ZGUgPGlvc3Ry ZWFtPgorI2luY2x1ZGUgPHN0cmluZ3MuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCkBAIC01 Myw2ICs1Niw3IEBAIHZvaWQgUG9wdXBNZW51OjpzaG93KGNvbnN0IEludFJlY3QmIHJlY3QsIEZy YW1lVmlldyogdmlldywgaW50IGluZGV4KQogICAgIGlmICghbV9wb3B1cCkgewogICAgICAgICBt X3BvcHVwID0gR1RLX01FTlUoZ3RrX21lbnVfbmV3KCkpOwogICAgICAgICBnX3NpZ25hbF9jb25u ZWN0KG1fcG9wdXAuZ2V0KCksICJ1bm1hcCIsIEdfQ0FMTEJBQ0sobWVudVVubWFwcGVkKSwgdGhp cyk7CisgICAgICAgIGdfc2lnbmFsX2Nvbm5lY3QobV9wb3B1cC5nZXQoKSwgImtleS1wcmVzcy1l dmVudCIsIEdfQ0FMTEJBQ0sobWVudVNlYXJjaEl0ZW0pLCB0aGlzKTsKICAgICB9IGVsc2UKICAg ICAgICAgZ3RrX2NvbnRhaW5lcl9mb3JlYWNoKEdUS19DT05UQUlORVIobV9wb3B1cC5nZXQoKSks IHJlaW50ZXJwcmV0X2Nhc3Q8R3RrQ2FsbGJhY2s+KG1lbnVSZW1vdmVJdGVtKSwgdGhpcyk7CiAK QEAgLTEzNCw2ICsxMzgsNyBAQCB2b2lkIFBvcHVwTWVudTo6bWVudVVubWFwcGVkKEd0a1dpZGdl dCosIFBvcHVwTWVudSogdGhhdCkKIHsKICAgICBBU1NFUlQodGhhdC0+Y2xpZW50KCkpOwogICAg IHRoYXQtPmNsaWVudCgpLT5wb3B1cERpZEhpZGUoKTsKKyAgICB0aGF0LT5zZWFyY2hlZFdvcmQu Y2xlYXIoKTsKIH0KIAogdm9pZCBQb3B1cE1lbnU6Om1lbnVQb3NpdGlvbkZ1bmN0aW9uKEd0a01l bnUqLCBnaW50KiB4LCBnaW50KiB5LCBnYm9vbGVhbiogcHVzaEluLCBQb3B1cE1lbnUqIHRoYXQp CkBAIC0xNDksNSArMTU0LDEwNiBAQCB2b2lkIFBvcHVwTWVudTo6bWVudVJlbW92ZUl0ZW0oR3Rr V2lkZ2V0KiB3aWRnZXQsIFBvcHVwTWVudSogdGhhdCkKICAgICBndGtfY29udGFpbmVyX3JlbW92 ZShHVEtfQ09OVEFJTkVSKHRoYXQtPm1fcG9wdXAuZ2V0KCkpLCB3aWRnZXQpOwogfQogCitib29s IFBvcHVwTWVudTo6aXNLZXlQcmVzc1RvWmFwKEdka0V2ZW50S2V5KiBldmVudCkKK3sKKworICAg IGlmIChldmVudC0+aXNfbW9kaWZpZXIpIHsKKyAgICAgICAgcmV0dXJuIHRydWU7CisgICAgfQor CisgICAgaWYgKGV2ZW50LT5rZXl2YWwgPT0gR0RLX1RhYgorICAgICAgICB8fCBldmVudC0+a2V5 dmFsID09IEdES19QYXVzZQorICAgICAgICB8fCBldmVudC0+a2V5dmFsID09IEdES19QcmludAor ICAgICAgICB8fCBldmVudC0+a2V5dmFsID09IEdES19Fc2NhcGUKKyAgICAgICAgfHwgZXZlbnQt PmtleXZhbCA9PSBHREtfRGVsZXRlCisgICAgICAgIHx8IGV2ZW50LT5rZXl2YWwgPT0gR0RLX0lu c2VydAorICAgICAgICB8fCBldmVudC0+a2V5dmFsID09IEdES19SZXR1cm4KKyAgICAgICAgfHwg ZXZlbnQtPmtleXZhbCA9PSBHREtfU3lzX1JlcQorICAgICAgICB8fCBldmVudC0+a2V5dmFsID09 IEdES19CYWNrU3BhY2UKKyAgICAgICAgfHwgZXZlbnQtPmtleXZhbCA9PSBHREtfU2Nyb2xsX0xv Y2sKKyAgICAgICAgfHwgZXZlbnQtPmtleXZhbCA9PSBHREtfSVNPX0xldmVsM19TaGlmdAorICAg ICAgICB8fCBldmVudC0+a2V5dmFsID09IEdES19Ib21lIHx8IGV2ZW50LT5rZXl2YWwgPT0gR0RL X0VuZAorICAgICAgICB8fCBldmVudC0+a2V5dmFsID09IEdES19VcCB8fCBldmVudC0+a2V5dmFs ID09IEdES19LUF9VcAorICAgICAgICB8fCBldmVudC0+a2V5dmFsID09IEdES19Eb3duIHx8IGV2 ZW50LT5rZXl2YWwgPT0gR0RLX0tQX0Rvd24KKyAgICAgICAgfHwgZXZlbnQtPmtleXZhbCA9PSBH REtfTGVmdCB8fCBldmVudC0+a2V5dmFsID09IEdES19LUF9MZWZ0CisgICAgICAgIHx8IGV2ZW50 LT5rZXl2YWwgPT0gR0RLX1JpZ2h0IHx8IGV2ZW50LT5rZXl2YWwgPT0gR0RLX0tQX1JpZ2h0Cisg ICAgICAgIHx8IGV2ZW50LT5rZXl2YWwgPT0gR0RLX1BhZ2VfVXAgfHwgZXZlbnQtPmtleXZhbCA9 PSBHREtfUGFnZV9Eb3duCisgICAgICAgIHx8IGV2ZW50LT5rZXl2YWwgPT0gR0RLX0YxIHx8IGV2 ZW50LT5rZXl2YWwgPT0gR0RLX0YyIHx8IGV2ZW50LT5rZXl2YWwgPT0gR0RLX0YzIHx8IGV2ZW50 LT5rZXl2YWwgPT0gR0RLX0Y0CisgICAgICAgIHx8IGV2ZW50LT5rZXl2YWwgPT0gR0RLX0Y1IHx8 IGV2ZW50LT5rZXl2YWwgPT0gR0RLX0Y2IHx8IGV2ZW50LT5rZXl2YWwgPT0gR0RLX0Y3IHx8IGV2 ZW50LT5rZXl2YWwgPT0gR0RLX0Y4CisgICAgICAgIHx8IGV2ZW50LT5rZXl2YWwgPT0gR0RLX0Y5 IHx8IGV2ZW50LT5rZXl2YWwgPT0gR0RLX0YxMCB8fCBldmVudC0+a2V5dmFsID09IEdES19GMTEg fHwgZXZlbnQtPmtleXZhbCA9PSBHREtfRjEyCisgICAgICAgIHx8IGV2ZW50LT5rZXl2YWwgPT0g R0RLX0tQX0YxIHx8IGV2ZW50LT5rZXl2YWwgPT0gR0RLX0tQX0YyIHx8IGV2ZW50LT5rZXl2YWwg PT0gR0RLX0tQX0YzIHx8IGV2ZW50LT5rZXl2YWwgPT0gR0RLX0tQX0Y0KSB7CisgICAgICAgIHJl dHVybiB0cnVlOworICAgIH0KKworICAgIHJldHVybiBmYWxzZTsKK30KKworYm9vbCBQb3B1cE1l bnU6OnNlYXJjaChHTGlzdCogc2VhcmNoRG9tYWluLCBjb25zdCBzdGQ6OnN0cmluZyYgd29yZCwg R0xpc3QqJiByZXN1bHRJdGVtKQoreworICAgIHN0ZDo6c3RyaW5nIGxhYmVsOworICAgIGludCBz aXplID0gZ19saXN0X2xlbmd0aChzZWFyY2hEb21haW4pOworCisgICAgZm9yIChpbnQgaSA9IDA7 IGkgPCBzaXplOyArK2kpIHsKKyAgICAgICAgbGFiZWwgPSBndGtfbWVudV9pdGVtX2dldF9sYWJl bChHVEtfTUVOVV9JVEVNKHNlYXJjaERvbWFpbi0+ZGF0YSkpOworICAgICAgICBsYWJlbCA9IGxh YmVsLnN1YnN0cigwLCB3b3JkLnNpemUoKSk7CisgICAgICAgIGlmIChzdHJjYXNlY21wKGxhYmVs LmNfc3RyKCksIHdvcmQuY19zdHIoKSkgPT0gMCkgeworICAgICAgICAgICAgcmVzdWx0SXRlbSA9 IHNlYXJjaERvbWFpbjsKKyAgICAgICAgICAgIHJldHVybiB0cnVlOworICAgICAgICB9CisgICAg ICAgIHNlYXJjaERvbWFpbiA9IGdfbGlzdF9uZXh0KHNlYXJjaERvbWFpbik7CisgICAgfQorCisg ICAgcmV0dXJuIGZhbHNlOworfQorCitib29sIFBvcHVwTWVudTo6YnVpbGREb21haW4oR0xpc3Qq IGluaXRpYWxEb21haW4sIGNvbnN0IHN0ZDo6c3RyaW5nJiB3b3JkLCBHTGlzdComIHJlc3VsdCkK K3sKKyAgICBzdGQ6OnN0cmluZyBsYWJlbDsKKyAgICBHTGlzdCogbmV3RG9tYWluID0gTlVMTDsK KyAgICB1bnNpZ25lZCBpbnQgc2l6ZSA9IGdfbGlzdF9sZW5ndGgoaW5pdGlhbERvbWFpbik7CisK KyAgICBmb3IgKHVuc2lnbmVkIGludCBpID0gZ19saXN0X2luZGV4KGluaXRpYWxEb21haW4sIGlu aXRpYWxEb21haW4tPmRhdGEpOyBpIDwgc2l6ZTsgKytpKSB7CisgICAgICAgIGxhYmVsID0gZ3Rr X21lbnVfaXRlbV9nZXRfbGFiZWwoR1RLX01FTlVfSVRFTShpbml0aWFsRG9tYWluLT5kYXRhKSk7 CisgICAgICAgIGxhYmVsID0gbGFiZWwuc3Vic3RyKDAsIHdvcmQuc2l6ZSgpKTsKKworICAgICAg ICBpZiAoc3RyY2FzZWNtcChsYWJlbC5jX3N0cigpLCB3b3JkLmNfc3RyKCkpID09IDApCisgICAg ICAgICAgICBuZXdEb21haW4gPSBnX2xpc3RfcHJlcGVuZChuZXdEb21haW4sIGluaXRpYWxEb21h aW4tPmRhdGEpOworICAgICAgICBlbHNlIGluaXRpYWxEb21haW4gPSBnX2xpc3RfbmV4dChpbml0 aWFsRG9tYWluKTsKKyAgICB9CisKKyAgICBpZiAoZ19saXN0X2xlbmd0aChuZXdEb21haW4pIDwg c2l6ZSkgeworICAgICAgICByZXN1bHQgPSBnX2xpc3RfcmV2ZXJzZShuZXdEb21haW4pOworICAg ICAgICByZXR1cm4gdHJ1ZTsKKyAgICB9CisKKyAgICByZXR1cm4gZmFsc2U7CiB9CiAKK2Jvb2wg UG9wdXBNZW51OjptZW51U2VhcmNoSXRlbShHdGtXaWRnZXQqIHdpZGdldCwgR2RrRXZlbnRLZXkq IGV2ZW50LCBQb3B1cE1lbnUqIHRoYXQpCit7CisgICAgQVNTRVJUKHRoYXQtPmNsaWVudCgpKTsK KyAgICBBU1NFUlQodGhhdC0+bV9wb3B1cCk7CisKKyAgICBHTGlzdCogc2VhcmNoRG9tYWluLCAq c2VhcmNoRG9tYWluTmV4dDsKKworICAgIGlmICghaXNLZXlQcmVzc1RvWmFwKGV2ZW50KSkgewor ICAgICAgICBpZiAodGhhdC0+c2VhcmNoZWRXb3JkLmVtcHR5KCkpIHsKKyAgICAgICAgICAgIHNl YXJjaERvbWFpbiA9IEdUS19NRU5VX1NIRUxMKHRoYXQtPm1fcG9wdXAuZ2V0KCkpLT5jaGlsZHJl bjsKKyAgICAgICAgICAgIHRoYXQtPnNlYXJjaERvbWFpbkxpc3QucHVzaF9mcm9udChzZWFyY2hE b21haW4pOworICAgICAgICB9CisKKyAgICAgICAgdGhhdC0+c2VhcmNoZWRXb3JkICs9IGV2ZW50 LT5rZXl2YWw7CisgICAgICAgIHN0ZDo6bGlzdDxHTGlzdCo+OjppdGVyYXRvciBpdCA9IHRoYXQt PnNlYXJjaERvbWFpbkxpc3QuYmVnaW4oKTsKKworICAgICAgICBpZiAoc2VhcmNoKCppdCwgdGhh dC0+c2VhcmNoZWRXb3JkLCBzZWFyY2hEb21haW4pKXsKKyAgICAgICAgICAgIGd0a19tZW51X3No ZWxsX3NlbGVjdF9pdGVtKEdUS19NRU5VX1NIRUxMKHRoYXQtPm1fcG9wdXAuZ2V0KCkpLCBHVEtf V0lER0VUKHNlYXJjaERvbWFpbi0+ZGF0YSkpOworICAgICAgICAgICAgaWYgKGJ1aWxkRG9tYWlu KHNlYXJjaERvbWFpbiwgdGhhdC0+c2VhcmNoZWRXb3JkLCBzZWFyY2hEb21haW5OZXh0KSkKKyAg ICAgICAgICAgICAgICB0aGF0LT5zZWFyY2hEb21haW5MaXN0LnB1c2hfZnJvbnQoc2VhcmNoRG9t YWluTmV4dCk7CisgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICAgICAgfQorICAgIH0KKwor ICAgIHJldHVybiBmYWxzZTsKK30KKworfQo= 56039 2010-05-13 18:03:03 -0700 2010-05-26 15:35:13 -0700 PopupMenu "find as you type" search patch.txt text/plain 7789 apelete Y29tbWl0IDJiYzU1MjdlZDVmMjJmMjhkZGE0OWRmMDhmYWVlOGQ3NDA1OTcxMmIKQXV0aG9yOiBB cGVsZXRlIFNla2V0ZWxpIDxhcGVsZXRlQHNla2V0ZWxpLm9yZz4KRGF0ZTogICBTYXQgQXByIDE3 IDE2OjE0OjM3IDIwMTAgKzAyMDAKCiAgICBBZGQgUG9wdXBNZW51ICJmaW5kIGFzIHlvdSB0eXBl IiBzZWFyY2ggKCMyNzQ0MykKICAgIAogICAgVGhlcmUgd2FzIGEgbWlzdGFrZSBpbiB0aGUgc2Vh cmNoIGZpbHRlcmluZyBtZWNhbmlzbSwgaXQgc2hvdWxkIHdvcmsgbm93LgogICAgQWxzbyBhZGRl ZCBhIHdheSB0byByZXNldCB0aGUgc2VhcmNoLCB1c2luZyB0aGUgIkRlbGV0ZSIga2V5IG9uIHRo ZSBrZXlib2FyZC4KCmRpZmYgLS1naXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUvQ2hh bmdlTG9nCmluZGV4IGFjYmNlN2YuLmFiNzRmZTkgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hhbmdl TG9nCisrKyBiL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzYgQEAKKzIwMTAtMDUtMTMg IEFwZWxldGUgU2VrZXRlbGkgIDxhcGVsZXRlQHNla2V0ZWxpLm9yZz4KKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBCdWcgMjc0NDM6IENvbWJvYm94IHNo b3VsZCBzdXBwb3J0ICJmaW5kLWFzLXlvdS10eXBlIiBzZWFyY2gKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI3NDQzCisKKyAgICAgICAgQ29ycmVjdGVk IHRoZSBzZWFyY2ggYWxnb3JpdGhtIGFuZCBhZGQgYSB3YXkgdG8gcmVzZXQgdGhlIHNlYXJjaC4K KworICAgICAgICBObyBuZXcgdGVzdHMgYXMgdGhlcmUgaXMgbm8gbmV3IGZ1bmN0aW9uYWxpdHku CisKKyAgICAgICAgKiBwbGF0Zm9ybS9Qb3B1cE1lbnUuaDoKKyAgICAgICAgKiBwbGF0Zm9ybS9n dGsvUG9wdXBNZW51R3RrLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlBvcHVwTWVudTo6bWVudVVu bWFwcGVkKToKKyAgICAgICAgICAgIEFkZGVkIGEgZnVuY3Rpb24gY2FsbCB0byByZXNldFdvcmQu CisgICAgICAgIChXZWJDb3JlOjpQb3B1cE1lbnU6OnJlc2V0V29yZCk6CisgICAgICAgICAgICBI ZWxwZXIgZnVuY3Rpb24gZm9yIGlzS2V5UHJlc3NUb1phcCBhbmQgbWVudVVubWFwcGVkLgorICAg ICAgICAgICAgQ2xlYXJzIHRoZSBzZWFyY2ggYW5kIHRoZSBhc3NvY2lhdGVkIHNlYXJjaCBkb21h aW4uCisgICAgICAgIChXZWJDb3JlOjpQb3B1cE1lbnU6OmlzS2V5UHJlc3NUb1phcCk6CisgICAg ICAgICAgICBIZWxwZXIgZnVuY3Rpb24gZm9yIG1lbnVTYWVyY2hJdGVtLCBjbGVhcnMgdGhlIHNl YXJjaCBvbiBHREtfRGVsZXRlIGtleWJvYXJkIGV2ZW50LgorICAgICAgICAgICAgUmV0dXJucyBG QUxTRSBpZiB0aGUga2V5cHJlc3MgaXMgdG8gYmUgdXNlZCBieSB0aGUgZXZlbnQgaGFuZGxlciAo bWVudVNlYXJjaEl0ZW0pLCBUUlVFIG90aGVyd2lzZS4KKyAgICAgICAgKFdlYkNvcmU6OlBvcHVw TWVudTo6c2VhcmNoKToKKyAgICAgICAgICAgIEhlbHBlciBmdW5jdGlvbiBmb3IgbWVudVNlYXJj aEl0ZW0uCisgICAgICAgICAgICBSZXR1cm5zIFRSVUUgaWYgc2VhcmNoZWQgZW50cnkgaGFzIGJl ZW4gZm91bmQuCisgICAgICAgICAgICBSZXR1cm5zIHRoZSBlbnRyeSB0byBiZSBzZWxlY3RlZCBp biB0aGUgdGhpcmQgcGFyYW1ldGVyIGlmIFRSVUUuCisgICAgICAgIChXZWJDb3JlOjpQb3B1cE1l bnU6OmJ1aWxkRG9tYWluKToKKyAgICAgICAgICAgIEhlbHBlciBmdW5jdGlvbiBmb3IgbWVudVNl YXJjaEl0ZW0uCisgICAgICAgICAgICBSZXR1cm5zIFRSVUUgaWYgc2VhcmNoIGRvbWFpbiBoYXMg YmVlbiBzdWNjZXNzZnVsbHkgcmVkdWNlZC4KKyAgICAgICAgICAgIFJldHVybnMgdGhlIG5ldyBz ZWFyY2ggZG9tYWluIGluIHRoZSB0aGlyZCBwYXJhbWV0ZXIgaWYgVFJVRS4KKyAgICAgICAgKFdl YkNvcmU6OlBvcHVwTWVudTo6bWVudVNlYXJjaEl0ZW0pOgorICAgICAgICAgICAgU2VhcmNoIGZv ciBzb21ldGhpbmcgdHlwZWQgb24gdGhlIGtleWJvYXJkIGluIHRoZSBQb3B1cE1lbnUgbGlzdCBv ZiBpdGVtcyBhbmQgc2VsZWN0IHRoZSBjb3JyZXNwb25kaW5nIGVudHJ5LgorICAgICAgICAgICAg UmV0dXJucyBUUlVFIGlmIHRoZSBlbnRlcmVkIHdvcmQgaXMgZm91bmQgaW4gdGhlIFBvcHVwTWVu dSwgRkFMU0UgaWYgbm90LgorCiAyMDEwLTAzLTI4ICBMYXN6bG8gR29tYm9zICA8bGFzemxvLjEu Z29tYm9zQG5va2lhLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBTaW1vbiBIYXVzbWFubi4K ZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vUG9wdXBNZW51LmggYi9XZWJDb3JlL3BsYXRm b3JtL1BvcHVwTWVudS5oCmluZGV4IDRkZjBkY2QuLjE2NDUzMjcgMTAwNjQ0Ci0tLSBhL1dlYkNv cmUvcGxhdGZvcm0vUG9wdXBNZW51LmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9Qb3B1cE1lbnUu aApAQCAtNTAsNyArNTAsMTAgQEAgdHlwZWRlZiBzdHJ1Y3QgX0d0a01lbnVJdGVtIEd0a01lbnVJ dGVtOwogdHlwZWRlZiBzdHJ1Y3QgX0d0a1dpZGdldCBHdGtXaWRnZXQ7CiAjaW5jbHVkZSAiR1Jl ZlB0ckd0ay5oIgogI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CisjaW5jbHVkZSA8Z2RrL2dkay5o PgogI2luY2x1ZGUgPGdsaWIuaD4KKyNpbmNsdWRlIDxsaXN0PgorI2luY2x1ZGUgPHN0cmluZz4K ICNlbGlmIFBMQVRGT1JNKFdYKQogI2lmZGVmIF9fV1hNU1dfXwogI2luY2x1ZGUgPHd4L21zdy93 aW51bmRlZi5oPgpAQCAtMTc1LDYgKzE3OCw4IEBAIHByaXZhdGU6CiAgICAgYm9vbCBtX3Njcm9s bGJhckNhcHR1cmluZ01vdXNlOwogICAgIGJvb2wgbV9zaG93UG9wdXA7CiAjZWxpZiBQTEFURk9S TShHVEspCisgICAgc3RkOjpzdHJpbmcgc2VhcmNoZWRXb3JkOworICAgIHN0ZDo6bGlzdDxHTGlz dCo+IHNlYXJjaERvbWFpbkxpc3Q7CiAgICAgSW50UG9pbnQgbV9tZW51UG9zaXRpb247CiAgICAg R1JlZlB0cjxHdGtNZW51PiBtX3BvcHVwOwogICAgIEhhc2hNYXA8R3RrV2lkZ2V0KiwgaW50PiBt X2luZGV4TWFwOwpAQCAtMTgyLDYgKzE4NywxMSBAQCBwcml2YXRlOgogICAgIHN0YXRpYyB2b2lk IG1lbnVVbm1hcHBlZChHdGtXaWRnZXQqLCBQb3B1cE1lbnUqKTsKICAgICBzdGF0aWMgdm9pZCBt ZW51UG9zaXRpb25GdW5jdGlvbihHdGtNZW51KiwgZ2ludCosIGdpbnQqLCBnYm9vbGVhbiosIFBv cHVwTWVudSopOwogICAgIHN0YXRpYyB2b2lkIG1lbnVSZW1vdmVJdGVtKEd0a1dpZGdldCosIFBv cHVwTWVudSopOworICAgIHN0YXRpYyB2b2lkIHJlc2V0V29yZChQb3B1cE1lbnUqKTsKKyAgICBz dGF0aWMgYm9vbCBpc0tleVByZXNzVG9aYXAoR2RrRXZlbnRLZXkqIGV2ZW50LCBQb3B1cE1lbnUq KTsKKyAgICBzdGF0aWMgYm9vbCBzZWFyY2goR0xpc3QqIHNlYXJjaERvbWFpbiwgY29uc3Qgc3Rk OjpzdHJpbmcmIHdvcmQsIEdMaXN0KiYgcmVzdWx0SXRlbSk7CisgICAgc3RhdGljIGJvb2wgYnVp bGREb21haW4oR0xpc3QqIGluaXRpYWxEb21haW4sIGNvbnN0IHN0ZDo6c3RyaW5nJiB3b3JkLCBH TGlzdComIHJlc3VsdCk7CisgICAgc3RhdGljIGJvb2wgbWVudVNlYXJjaEl0ZW0oR3RrV2lkZ2V0 KiB3aWRnZXQsIEdka0V2ZW50S2V5KiBldmVudCwgUG9wdXBNZW51Kik7CiAjZWxpZiBQTEFURk9S TShXWCkKICAgICB3eE1lbnUqIG1fbWVudTsKICAgICB2b2lkIE9uTWVudUl0ZW1TZWxlY3RlZCh3 eENvbW1hbmRFdmVudCYpOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvUG9wdXBN ZW51R3RrLmNwcCBiL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1BvcHVwTWVudUd0ay5jcHAKaW5kZXgg MDM2M2FjNC4uOGE0ZDVkNCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvUG9wdXBN ZW51R3RrLmNwcAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Qb3B1cE1lbnVHdGsuY3BwCkBA IC0yOSw3ICsyOSwxMCBAQAogI2luY2x1ZGUgIkZyYW1lVmlldy5oIgogI2luY2x1ZGUgIkhvc3RX aW5kb3cuaCIKICNpbmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgorI2luY2x1ZGUgPGdkay9nZGtr ZXlzeW1zLmg+CiAjaW5jbHVkZSA8Z3RrL2d0ay5oPgorI2luY2x1ZGUgPGlvc3RyZWFtPgorI2lu Y2x1ZGUgPHN0cmluZ3MuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCkBAIC01Myw2ICs1Niw3 IEBAIHZvaWQgUG9wdXBNZW51OjpzaG93KGNvbnN0IEludFJlY3QmIHJlY3QsIEZyYW1lVmlldyog dmlldywgaW50IGluZGV4KQogICAgIGlmICghbV9wb3B1cCkgewogICAgICAgICBtX3BvcHVwID0g R1RLX01FTlUoZ3RrX21lbnVfbmV3KCkpOwogICAgICAgICBnX3NpZ25hbF9jb25uZWN0KG1fcG9w dXAuZ2V0KCksICJ1bm1hcCIsIEdfQ0FMTEJBQ0sobWVudVVubWFwcGVkKSwgdGhpcyk7CisgICAg ICAgIGdfc2lnbmFsX2Nvbm5lY3QobV9wb3B1cC5nZXQoKSwgImtleS1wcmVzcy1ldmVudCIsIEdf Q0FMTEJBQ0sobWVudVNlYXJjaEl0ZW0pLCB0aGlzKTsKICAgICB9IGVsc2UKICAgICAgICAgZ3Rr X2NvbnRhaW5lcl9mb3JlYWNoKEdUS19DT05UQUlORVIobV9wb3B1cC5nZXQoKSksIHJlaW50ZXJw cmV0X2Nhc3Q8R3RrQ2FsbGJhY2s+KG1lbnVSZW1vdmVJdGVtKSwgdGhpcyk7CiAKQEAgLTEzNCw2 ICsxMzgsNyBAQCB2b2lkIFBvcHVwTWVudTo6bWVudVVubWFwcGVkKEd0a1dpZGdldCosIFBvcHVw TWVudSogdGhhdCkKIHsKICAgICBBU1NFUlQodGhhdC0+Y2xpZW50KCkpOwogICAgIHRoYXQtPmNs aWVudCgpLT5wb3B1cERpZEhpZGUoKTsKKyAgICByZXNldFdvcmQodGhhdCk7CiB9CiAKIHZvaWQg UG9wdXBNZW51OjptZW51UG9zaXRpb25GdW5jdGlvbihHdGtNZW51KiwgZ2ludCogeCwgZ2ludCog eSwgZ2Jvb2xlYW4qIHB1c2hJbiwgUG9wdXBNZW51KiB0aGF0KQpAQCAtMTQ5LDUgKzE1NCw5NCBA QCB2b2lkIFBvcHVwTWVudTo6bWVudVJlbW92ZUl0ZW0oR3RrV2lkZ2V0KiB3aWRnZXQsIFBvcHVw TWVudSogdGhhdCkKICAgICBndGtfY29udGFpbmVyX3JlbW92ZShHVEtfQ09OVEFJTkVSKHRoYXQt Pm1fcG9wdXAuZ2V0KCkpLCB3aWRnZXQpOwogfQogCit2b2lkIFBvcHVwTWVudTo6cmVzZXRXb3Jk KFBvcHVwTWVudSogdGhhdCkKK3sKKyAgICB0aGF0LT5zZWFyY2hlZFdvcmQuY2xlYXIoKTsKKyAg ICB0aGF0LT5zZWFyY2hEb21haW5MaXN0LmNsZWFyKCk7Cit9CisKK2Jvb2wgUG9wdXBNZW51Ojpp c0tleVByZXNzVG9aYXAoR2RrRXZlbnRLZXkqIGV2ZW50LCBQb3B1cE1lbnUqIHRoYXQpCit7Cisg ICAgZ3VpbnQga2V5dmFsID0gIGdka191bmljb2RlX3RvX2tleXZhbCAoZXZlbnQtPmtleXZhbCk7 CisKKyAgICBpZiAoa2V5dmFsID09IChldmVudC0+a2V5dmFsIHwgMHgwMTAwMDAwMCkpIHsKKyAg ICAgICAgaWYgKGV2ZW50LT5rZXl2YWwgPT0gR0RLX0RlbGV0ZSkKKyAgICAgICAgICAgIHJlc2V0 V29yZCh0aGF0KTsKKyAgICAgICAgcmV0dXJuIHRydWU7CisgICAgfQorCisgICAgcmV0dXJuIGZh bHNlOworfQorCitib29sIFBvcHVwTWVudTo6c2VhcmNoKEdMaXN0KiBzZWFyY2hEb21haW4sIGNv bnN0IHN0ZDo6c3RyaW5nJiB3b3JkLCBHTGlzdComIHJlc3VsdEl0ZW0pCit7CisgICAgQVNTRVJU KHNlYXJjaERvbWFpbik7CisKKyAgICBzdGQ6OnN0cmluZyBsYWJlbDsKKyAgICBpbnQgc2l6ZSA9 IGdfbGlzdF9sZW5ndGgoc2VhcmNoRG9tYWluKTsKKworICAgIGZvciAoaW50IGkgPSAwOyBpIDwg c2l6ZTsgKytpKSB7CisgICAgICAgIGxhYmVsID0gZ3RrX21lbnVfaXRlbV9nZXRfbGFiZWwoR1RL X01FTlVfSVRFTShzZWFyY2hEb21haW4tPmRhdGEpKTsKKyAgICAgICAgbGFiZWwgPSBsYWJlbC5z dWJzdHIoMCwgd29yZC5zaXplKCkpOworICAgICAgICBpZiAoc3RyY2FzZWNtcChsYWJlbC5jX3N0 cigpLCB3b3JkLmNfc3RyKCkpID09IDApIHsKKyAgICAgICAgICAgIHJlc3VsdEl0ZW0gPSBzZWFy Y2hEb21haW47CisgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICAgICAgfQorICAgICAgICBz ZWFyY2hEb21haW4gPSBnX2xpc3RfbmV4dChzZWFyY2hEb21haW4pOworICAgIH0KKworICAgIHJl dHVybiBmYWxzZTsKK30KKworYm9vbCBQb3B1cE1lbnU6OmJ1aWxkRG9tYWluKEdMaXN0KiBpbml0 aWFsRG9tYWluLCBjb25zdCBzdGQ6OnN0cmluZyYgd29yZCwgR0xpc3QqJiByZXN1bHQpCit7Cisg ICAgQVNTRVJUKGluaXRpYWxEb21haW4pOworCisgICAgc3RkOjpzdHJpbmcgbGFiZWw7CisgICAg R0xpc3QqIG5ld0RvbWFpbiA9IE5VTEw7CisgICAgdW5zaWduZWQgaW50IHNpemUgPSBnX2xpc3Rf bGVuZ3RoKGluaXRpYWxEb21haW4pOworCisgICAgZm9yICh1bnNpZ25lZCBpbnQgaSA9IGdfbGlz dF9pbmRleChpbml0aWFsRG9tYWluLCBpbml0aWFsRG9tYWluLT5kYXRhKTsgaSA8IHNpemU7ICsr aSkgeworICAgICAgICBsYWJlbCA9IGd0a19tZW51X2l0ZW1fZ2V0X2xhYmVsKEdUS19NRU5VX0lU RU0oaW5pdGlhbERvbWFpbi0+ZGF0YSkpOworICAgICAgICBsYWJlbCA9IGxhYmVsLnN1YnN0cigw LCB3b3JkLnNpemUoKSk7CisKKyAgICAgICAgaWYgKHN0cmNhc2VjbXAobGFiZWwuY19zdHIoKSwg d29yZC5jX3N0cigpKSA9PSAwKQorICAgICAgICAgICAgbmV3RG9tYWluID0gZ19saXN0X3ByZXBl bmQobmV3RG9tYWluLCBpbml0aWFsRG9tYWluLT5kYXRhKTsKKyAgICAgICAgaW5pdGlhbERvbWFp biA9IGdfbGlzdF9uZXh0KGluaXRpYWxEb21haW4pOworICAgIH0KKworICAgIGlmIChnX2xpc3Rf bGVuZ3RoKG5ld0RvbWFpbikgPCBzaXplKSB7CisgICAgICAgIHJlc3VsdCA9IGdfbGlzdF9yZXZl cnNlKG5ld0RvbWFpbik7CisgICAgICAgIHJldHVybiB0cnVlOworICAgIH0KKworICAgIHJldHVy biBmYWxzZTsKK30KKworYm9vbCBQb3B1cE1lbnU6Om1lbnVTZWFyY2hJdGVtKEd0a1dpZGdldCog d2lkZ2V0LCBHZGtFdmVudEtleSogZXZlbnQsIFBvcHVwTWVudSogdGhhdCkKK3sKKyAgICBBU1NF UlQodGhhdC0+bV9wb3B1cCk7CisKKyAgICBHTGlzdCogc2VhcmNoRG9tYWluID0gTlVMTCwgKnNl YXJjaERvbWFpbk5leHQgPSBOVUxMOworCisgICAgaWYgKCFpc0tleVByZXNzVG9aYXAoZXZlbnQs IHRoYXQpKSB7CisgICAgICAgIGlmICh0aGF0LT5zZWFyY2hlZFdvcmQuZW1wdHkoKSkgeworICAg ICAgICAgICAgc2VhcmNoRG9tYWluID0gR1RLX01FTlVfU0hFTEwodGhhdC0+bV9wb3B1cC5nZXQo KSktPmNoaWxkcmVuOworICAgICAgICAgICAgdGhhdC0+c2VhcmNoRG9tYWluTGlzdC5wdXNoX2Zy b250KHNlYXJjaERvbWFpbik7CisgICAgICAgIH0KKworICAgICAgICB0aGF0LT5zZWFyY2hlZFdv cmQgKz0gZXZlbnQtPmtleXZhbDsKKyAgICAgICAgc3RkOjpsaXN0PEdMaXN0Kj46Oml0ZXJhdG9y IGl0ID0gdGhhdC0+c2VhcmNoRG9tYWluTGlzdC5iZWdpbigpOworCisgICAgICAgIGlmIChzZWFy Y2goKml0LCB0aGF0LT5zZWFyY2hlZFdvcmQsIHNlYXJjaERvbWFpbikpeworICAgICAgICAgICAg Z3RrX21lbnVfc2hlbGxfc2VsZWN0X2l0ZW0oR1RLX01FTlVfU0hFTEwodGhhdC0+bV9wb3B1cC5n ZXQoKSksIEdUS19XSURHRVQoc2VhcmNoRG9tYWluLT5kYXRhKSk7CisgICAgICAgICAgICBpZiAo YnVpbGREb21haW4oc2VhcmNoRG9tYWluLCB0aGF0LT5zZWFyY2hlZFdvcmQsIHNlYXJjaERvbWFp bk5leHQpKQorICAgICAgICAgICAgICAgIHRoYXQtPnNlYXJjaERvbWFpbkxpc3QucHVzaF9mcm9u dChzZWFyY2hEb21haW5OZXh0KTsKKyAgICAgICAgICAgIHJldHVybiB0cnVlOworICAgICAgICB9 CisgICAgfQorCisgICAgcmV0dXJuIGZhbHNlOwogfQogCit9Cg== 57170 2010-05-26 15:35:13 -0700 2010-07-05 08:11:08 -0700 Find-as-you-type proposed patch patch.txt text/plain 9690 apelete Y29tbWl0IDZkNTA5OTc2OGZjNDE5ZTQ1ZGJkNjEyMjliMTFmYWRmN2YxNzVmMzkKQXV0aG9yOiBB cGVsZXRlIFNla2V0ZWxpIDxhcGVsZXRlQHNla2V0ZWxpLm9yZz4KRGF0ZTogICBTYXQgQXByIDE3 IDE2OjE0OjM3IDIwMTAgKzAyMDAKCiAgICBBZGQgUG9wdXBNZW51ICJmaW5kIGFzIHlvdSB0eXBl IiBzZWFyY2ggKCMyNzQ0MykKICAgIAogICAgSW1wbGVtZW50IGEgcHJvZ3Jlc3NpdmUgc2VhcmNo IG1lY2FuaXNtIHRvIHNlbGVjdCBhbiBpdGVtIGluIGEKICAgIFBvcHVwTWVudSBieSB0eXBpbmcg YSB3b3JkIG9uIHRoZSBrZXlib2FyZC4gVGhlIHNlYXJjaCBjYW4gYmUgcmVzZXRlZCBhdAogICAg YW55IG1vbWVudCBieSBwcmVzc2luZyB0aGUgIkRlbGV0ZSIga2V5LgoKZGlmZiAtLWdpdCBhL1dl YkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYTY4NmJhOC4uOWEyNWZl NCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cK QEAgLTEsMyArMSw0NCBAQAorMjAxMC0wNS0yNiAgQXBlbGV0ZSBTZWtldGVsaSAgPGFwZWxldGVA c2VrZXRlbGkub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIEJ1ZyAyNzQ0MzogQ29tYm9ib3ggc2hvdWxkIHN1cHBvcnQgImZpbmQtYXMteW91LXR5 cGUiIHNlYXJjaAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9Mjc0NDMKKworICAgICAgICBJbXBsZW1lbnQgYSBwcm9ncmVzc2l2ZSBzZWFyY2ggbWVjYW5p c20gdG8gc2VsZWN0IGFuIGl0ZW0gaW4gYQorICAgICAgICBQb3B1cE1lbnUgYnkgdHlwaW5nIGEg d29yZCBvbiB0aGUga2V5Ym9hcmQuIFRoZSBzZWFyY2ggY2FuIGJlCisgICAgICAgIHJlc2V0ZWQg YXQgYW55IG1vbWVudCBieSBwcmVzc2luZyB0aGUgIkRlbGV0ZSIga2V5LgorCisgICAgICAgIE5v IG5ldyB0ZXN0cyBhcyB0aGVyZSBpcyBubyBuZXcgZnVuY3Rpb25uYWxpdHkuCisKKyAgICAgICAg KiBwbGF0Zm9ybS9Qb3B1cE1lbnUuaDoKKyAgICAgICAgKiBwbGF0Zm9ybS9ndGsvUG9wdXBNZW51 R3RrLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlBvcHVwTWVudTo6bWVudVVubWFwcGVkKToKKyAg ICAgICAgICAgIEFkZGVkIGEgZnVuY3Rpb24gY2FsbCB0byByZXNldFdvcmQuCisgICAgICAgIChX ZWJDb3JlOjpQb3B1cE1lbnU6OnJlc2V0V29yZCk6CisgICAgICAgICAgICBIZWxwZXIgZnVuY3Rp b24gZm9yIGlzS2V5UHJlc3NUb1phcCBhbmQgbWVudVVubWFwcGVkLgorICAgICAgICAgICAgQ2xl YXJzIHRoZSBzZWFyY2ggYW5kIHRoZSBhc3NvY2lhdGVkIHNlYXJjaCBkb21haW4uCisgICAgICAg IChXZWJDb3JlOjpQb3B1cE1lbnU6OmlzS2V5UHJlc3NUb1phcCk6CisgICAgICAgICAgICBIZWxw ZXIgZnVuY3Rpb24gZm9yIG1lbnVTZWFyY2hJdGVtLCBjbGVhcnMgc2VhcmNoIG9uCisgICAgICAg ICAgICBHREtfRGVsZXRlIGtleWJvYXJkIGV2ZW50LgorICAgICAgICAgICAgUmV0dXJucyBGQUxT RSBpZiBrZXlwcmVzcyBpcyB0byBiZSB1c2VkIGJ5IGV2ZW50IGhhbmRsZXIsCisgICAgICAgICAg ICBtZW51U2VhcmNoSXRlbSwgVFJVRSBvdGhlcndpc2UuCisgICAgICAgIChXZWJDb3JlOjpQb3B1 cE1lbnU6OnRyaW0pOgorICAgICAgICAgICAgSGVscGVyIGZ1bmN0aW9uIGZvciBzZWFyY2ggYW5k IGJ1aWxkRG9tYWluLgorICAgICAgICAgICAgVHJpbXMgbGVhZGluZyBhbmQgdHJhaWxpbmcgc3Bh Y2VzIGluIGEgd29yZC4KKyAgICAgICAgKFdlYkNvcmU6OlBvcHVwTWVudTo6c2VhcmNoKToKKyAg ICAgICAgICAgIEhlbHBlciBmdW5jdGlvbiBmb3IgbWVudVNlYXJjaEl0ZW0uCisgICAgICAgICAg ICBSZXR1cm5zIFRSVUUgaWYgc2VhcmNoZWQgZW50cnkgaGFzIGJlZW4gZm91bmQuCisgICAgICAg ICAgICBSZXR1cm5zIGVudHJ5IHRvIGJlIHNlbGVjdGVkIGluIHRoaXJkIHBhcmFtZXRlciBpZiBU UlVFLgorICAgICAgICAoV2ViQ29yZTo6UG9wdXBNZW51OjpidWlsZERvbWFpbik6CisgICAgICAg ICAgICBIZWxwZXIgZnVuY3Rpb24gZm9yIG1lbnVTZWFyY2hJdGVtLgorICAgICAgICAgICAgUmV0 dXJucyBUUlVFIGlmIHNlYXJjaCBkb21haW4gaGFzIGJlZW4gcmVkdWNlZC4KKyAgICAgICAgICAg IFJldHVybnMgbmV3IHNlYXJjaCBkb21haW4gaW4gdGhpcmQgcGFyYW1ldGVyIGlmIFRSVUUuCisg ICAgICAgIChXZWJDb3JlOjpQb3B1cE1lbnU6Om1lbnVTZWFyY2hJdGVtKToKKyAgICAgICAgICAg IFNlYXJjaCBmb3Igc29tZXRoaW5nIHR5cGVkIG9uIGtleWJvYXJkIGluIFBvcHVwTWVudSBsaXN0 IG9mCisgICAgICAgICAgICBpdGVtcyBhbmQgc2VsZWN0IGNvcnJlc3BvbmRpbmcgZW50cnkuCisg ICAgICAgICAgICBSZXR1cm5zIFRSVUUgaWYgZW50ZXJlZCB3b3JkIGlzIGZvdW5kLCBGQUxTRSBp ZiBub3QuCisKIDIwMTAtMDUtMjMgIEVyaWMgU2VpZGVsICA8ZXJpY0B3ZWJraXQub3JnPgogCiAg ICAgICAgIFJldmlld2VkIGJ5IEFkYW0gQmFydGguCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRm b3JtL1BvcHVwTWVudS5oIGIvV2ViQ29yZS9wbGF0Zm9ybS9Qb3B1cE1lbnUuaAppbmRleCA0ZGYw ZGNkLi42ZjA5Y2Y4IDEwMDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL1BvcHVwTWVudS5oCisr KyBiL1dlYkNvcmUvcGxhdGZvcm0vUG9wdXBNZW51LmgKQEAgLTUwLDcgKzUwLDEwIEBAIHR5cGVk ZWYgc3RydWN0IF9HdGtNZW51SXRlbSBHdGtNZW51SXRlbTsKIHR5cGVkZWYgc3RydWN0IF9HdGtX aWRnZXQgR3RrV2lkZ2V0OwogI2luY2x1ZGUgIkdSZWZQdHJHdGsuaCIKICNpbmNsdWRlIDx3dGYv SGFzaE1hcC5oPgorI2luY2x1ZGUgPGdkay9nZGsuaD4KICNpbmNsdWRlIDxnbGliLmg+CisjaW5j bHVkZSA8bGlzdD4KKyNpbmNsdWRlIDxzdHJpbmc+CiAjZWxpZiBQTEFURk9STShXWCkKICNpZmRl ZiBfX1dYTVNXX18KICNpbmNsdWRlIDx3eC9tc3cvd2ludW5kZWYuaD4KQEAgLTcxLDYgKzc0LDgg QEAgbmFtZXNwYWNlIFdlYkNvcmUgewogY2xhc3MgRnJhbWVWaWV3OwogY2xhc3MgU2Nyb2xsYmFy OwogCit2b2lkIHRyaW0oc3RkOjpzdHJpbmcmKTsKKwogY2xhc3MgUG9wdXBNZW51IDogcHVibGlj IFJlZkNvdW50ZWQ8UG9wdXBNZW51PgogI2lmIFBMQVRGT1JNKFdJTikKICAgICAgICAgICAgICAg ICAsIHByaXZhdGUgU2Nyb2xsYmFyQ2xpZW50CkBAIC0xNzUsNiArMTgwLDggQEAgcHJpdmF0ZToK ICAgICBib29sIG1fc2Nyb2xsYmFyQ2FwdHVyaW5nTW91c2U7CiAgICAgYm9vbCBtX3Nob3dQb3B1 cDsKICNlbGlmIFBMQVRGT1JNKEdUSykKKyAgICBzdGQ6OnN0cmluZyBzZWFyY2hlZFdvcmQ7Cisg ICAgc3RkOjpsaXN0PEdMaXN0Kj4gc2VhcmNoRG9tYWluTGlzdDsKICAgICBJbnRQb2ludCBtX21l bnVQb3NpdGlvbjsKICAgICBHUmVmUHRyPEd0a01lbnU+IG1fcG9wdXA7CiAgICAgSGFzaE1hcDxH dGtXaWRnZXQqLCBpbnQ+IG1faW5kZXhNYXA7CkBAIC0xODIsNiArMTg5LDExIEBAIHByaXZhdGU6 CiAgICAgc3RhdGljIHZvaWQgbWVudVVubWFwcGVkKEd0a1dpZGdldCosIFBvcHVwTWVudSopOwog ICAgIHN0YXRpYyB2b2lkIG1lbnVQb3NpdGlvbkZ1bmN0aW9uKEd0a01lbnUqLCBnaW50KiwgZ2lu dCosIGdib29sZWFuKiwgUG9wdXBNZW51Kik7CiAgICAgc3RhdGljIHZvaWQgbWVudVJlbW92ZUl0 ZW0oR3RrV2lkZ2V0KiwgUG9wdXBNZW51Kik7CisgICAgc3RhdGljIHZvaWQgcmVzZXRXb3JkKFBv cHVwTWVudSopOworICAgIHN0YXRpYyBib29sIGlzS2V5UHJlc3NUb1phcChHZGtFdmVudEtleSog ZXZlbnQsIFBvcHVwTWVudSopOworICAgIHN0YXRpYyBib29sIHNlYXJjaChHTGlzdCosIGNvbnN0 IHN0ZDo6c3RyaW5nJiwgR0xpc3QqJik7CisgICAgc3RhdGljIGJvb2wgYnVpbGREb21haW4oR0xp c3QqLCBjb25zdCBzdGQ6OnN0cmluZyYsIEdMaXN0KiwgR0xpc3QqJik7CisgICAgc3RhdGljIGJv b2wgbWVudVNlYXJjaEl0ZW0oR3RrV2lkZ2V0KiwgR2RrRXZlbnRLZXkqLCBQb3B1cE1lbnUqKTsK ICNlbGlmIFBMQVRGT1JNKFdYKQogICAgIHd4TWVudSogbV9tZW51OwogICAgIHZvaWQgT25NZW51 SXRlbVNlbGVjdGVkKHd4Q29tbWFuZEV2ZW50Jik7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRm b3JtL2d0ay9Qb3B1cE1lbnVHdGsuY3BwIGIvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvUG9wdXBNZW51 R3RrLmNwcAppbmRleCAxNjIwYjNiLi45YWZlYzVlIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BsYXRm b3JtL2d0ay9Qb3B1cE1lbnVHdGsuY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1BvcHVw TWVudUd0ay5jcHAKQEAgLTI4LDggKzI4LDExIEBACiAjaW5jbHVkZSAiRnJhbWVWaWV3LmgiCiAj aW5jbHVkZSAiSG9zdFdpbmRvdy5oIgogI2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCi0jaW5j bHVkZSA8d3RmL3RleHQvQ1N0cmluZy5oPgorI2luY2x1ZGUgPGFsZ29yaXRobT4KKyNpbmNsdWRl IDxnZGsvZ2Rra2V5c3ltcy5oPgogI2luY2x1ZGUgPGd0ay9ndGsuaD4KKyNpbmNsdWRlIDxpb3N0 cmVhbT4KKyNpbmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3Jl IHsKIApAQCAtNTMsNiArNTYsNyBAQCB2b2lkIFBvcHVwTWVudTo6c2hvdyhjb25zdCBJbnRSZWN0 JiByZWN0LCBGcmFtZVZpZXcqIHZpZXcsIGludCBpbmRleCkKICAgICBpZiAoIW1fcG9wdXApIHsK ICAgICAgICAgbV9wb3B1cCA9IEdUS19NRU5VKGd0a19tZW51X25ldygpKTsKICAgICAgICAgZ19z aWduYWxfY29ubmVjdChtX3BvcHVwLmdldCgpLCAidW5tYXAiLCBHX0NBTExCQUNLKG1lbnVVbm1h cHBlZCksIHRoaXMpOworICAgICAgICBnX3NpZ25hbF9jb25uZWN0KG1fcG9wdXAuZ2V0KCksICJr ZXktcHJlc3MtZXZlbnQiLCBHX0NBTExCQUNLKG1lbnVTZWFyY2hJdGVtKSwgdGhpcyk7CiAgICAg fSBlbHNlCiAgICAgICAgIGd0a19jb250YWluZXJfZm9yZWFjaChHVEtfQ09OVEFJTkVSKG1fcG9w dXAuZ2V0KCkpLCByZWludGVycHJldF9jYXN0PEd0a0NhbGxiYWNrPihtZW51UmVtb3ZlSXRlbSks IHRoaXMpOwogCkBAIC0xMzQsNiArMTM4LDggQEAgdm9pZCBQb3B1cE1lbnU6Om1lbnVVbm1hcHBl ZChHdGtXaWRnZXQqLCBQb3B1cE1lbnUqIHRoYXQpCiB7CiAgICAgQVNTRVJUKHRoYXQtPmNsaWVu dCgpKTsKICAgICB0aGF0LT5jbGllbnQoKS0+cG9wdXBEaWRIaWRlKCk7CisgICAgLy8gQ2xlYXIg dGhlIHNlYXJjaCBhbmQgdGhlIGFzc29jaWF0ZWQgZG9tYWluIGxpc3QKKyAgICByZXNldFdvcmQo dGhhdCk7CiB9CiAKIHZvaWQgUG9wdXBNZW51OjptZW51UG9zaXRpb25GdW5jdGlvbihHdGtNZW51 KiwgZ2ludCogeCwgZ2ludCogeSwgZ2Jvb2xlYW4qIHB1c2hJbiwgUG9wdXBNZW51KiB0aGF0KQpA QCAtMTQ5LDUgKzE1NSwxMzAgQEAgdm9pZCBQb3B1cE1lbnU6Om1lbnVSZW1vdmVJdGVtKEd0a1dp ZGdldCogd2lkZ2V0LCBQb3B1cE1lbnUqIHRoYXQpCiAgICAgZ3RrX2NvbnRhaW5lcl9yZW1vdmUo R1RLX0NPTlRBSU5FUih0aGF0LT5tX3BvcHVwLmdldCgpKSwgd2lkZ2V0KTsKIH0KIAorLy8gQ2xl YXIgdGhlIHNlYXJjaCBhbmQgdGhlIGFzc29jaWF0ZWQgZG9tYWluIGxpc3QKK3ZvaWQgUG9wdXBN ZW51OjpyZXNldFdvcmQoUG9wdXBNZW51KiB0aGF0KQoreworICAgIHRoYXQtPnNlYXJjaGVkV29y ZC5jbGVhcigpOworICAgIHRoYXQtPnNlYXJjaERvbWFpbkxpc3QuY2xlYXIoKTsKK30KKworLy8g VGVzdCBrZXlwcmVzc2VzIHRvIHNlZSBpZiB0aGV5IGFyZSB0byBiZSBwYXNzZWQgdG8gdGhlIGV2 ZW50IGhhbmRsZXIKK2Jvb2wgUG9wdXBNZW51Ojppc0tleVByZXNzVG9aYXAoR2RrRXZlbnRLZXkq IGV2ZW50LCBQb3B1cE1lbnUqIHRoYXQpCit7CisgICAgZ3VpbnQga2V5dmFsID0gIGdka191bmlj b2RlX3RvX2tleXZhbCAoZXZlbnQtPmtleXZhbCk7CisKKyAgICBpZiAoa2V5dmFsID09IChldmVu dC0+a2V5dmFsIHwgMHgwMTAwMDAwMCkpIHsKKyAgICAgICAgaWYgKGV2ZW50LT5rZXl2YWwgPT0g R0RLX0RlbGV0ZSkKKyAgICAgICAgICAgIHJlc2V0V29yZCh0aGF0KTsKKyAgICAgICAgcmV0dXJu IHRydWU7CisgICAgfQorCisgICAgcmV0dXJuIGZhbHNlOworfQorCisvLyBUcmltIGxlYWRpbmcg YW5kIHRyYWlsaW5nIHNwYWNlcyBpbiBhIHdvcmQKK3ZvaWQgdHJpbShzdGQ6OnN0cmluZyYgd29y ZCkKK3sKKyAgICBzdGQ6OnN0cmluZyBzcGFjZXMgPSAiIFx0IjsKKyAgICBzdGQ6OnN0cmluZzo6 c2l6ZV90eXBlIHBvcyA9IHdvcmQuZmluZF9sYXN0X25vdF9vZihzcGFjZXMpOworCisgICAgaWYg KHBvcyAhPSBzdGQ6OnN0cmluZzo6bnBvcykgeworICAgICAgICB3b3JkLmVyYXNlKHBvcyArIDEp OworICAgICAgICBwb3MgPSB3b3JkLmZpbmRfZmlyc3Rfbm90X29mKHNwYWNlcyk7CisgICAgICAg IGlmIChwb3MgIT0gc3RkOjpzdHJpbmc6Om5wb3MpCisgICAgICAgICAgICB3b3JkLmVyYXNlKDAs IHBvcyk7CisgICAgfQorfQorCisvLyBTZWFyY2ggZm9yIGEgbWVudUl0ZW0gaW4gYSBkb21haW4g YW5kIHJldHVybnMgdGhlIG1lbnVJdGVtIGlmIGZvdW5kCisvLyBzZWFyY2hEb21haW46IHRoZSBk b21haW4gc2VhcmNoZWQKKy8vIHdvcmQ6IHRoZSBtZW51SXRlbSBsYWJlbAorLy8gcmVzdWx0SXRl bTogdGhlIG1lbnVJdGVtIGlmIGZvdW5kCitib29sIFBvcHVwTWVudTo6c2VhcmNoKEdMaXN0KiBz ZWFyY2hEb21haW4sIGNvbnN0IHN0ZDo6c3RyaW5nJiB3b3JkLCBHTGlzdComIHJlc3VsdEl0ZW0p Cit7CisgICAgQVNTRVJUKHNlYXJjaERvbWFpbik7CisKKyAgICBzdGQ6OnN0cmluZyBsYWJlbDsK KyAgICB1bnNpZ25lZCBpbnQgc2l6ZSA9IGdfbGlzdF9sZW5ndGgoc2VhcmNoRG9tYWluKTsKKwor ICAgIGZvciAodW5zaWduZWQgaW50IGkgPSAwOyBpIDwgc2l6ZTsgKytpKSB7CisgICAgICAgIGxh YmVsID0gZ3RrX21lbnVfaXRlbV9nZXRfbGFiZWwoR1RLX01FTlVfSVRFTShzZWFyY2hEb21haW4t PmRhdGEpKTsKKyAgICAgICAgdHJpbShsYWJlbCk7CisgICAgICAgIGlmIChsYWJlbC5zaXplKCkg PiB3b3JkLnNpemUoKSkKKyAgICAgICAgICAgIGxhYmVsLmVyYXNlKHdvcmQuc2l6ZSgpKTsKKwor ICAgICAgICBpZiAoKGxhYmVsLmNfc3RyKCkgJiYgd29yZC5jX3N0cigpKQorICAgICAgICAgICAg JiYgKHN0cmNhc2VjbXAobGFiZWwuY19zdHIoKSwgd29yZC5jX3N0cigpKSA9PSAwKSkgeworICAg ICAgICAgICAgcmVzdWx0SXRlbSA9IHNlYXJjaERvbWFpbjsKKyAgICAgICAgICAgIHJldHVybiB0 cnVlOworICAgICAgICB9CisgICAgICAgIHNlYXJjaERvbWFpbiA9IGdfbGlzdF9uZXh0KHNlYXJj aERvbWFpbik7CisgICAgfQorCisgICAgcmV0dXJuIGZhbHNlOwogfQogCisvLyBCdWlsZCBhIHNl YXJjaCBkb21haW4gY29udGFpbmluZyBtZW51SXRlbXMgc3RhcnRpbmcgd2l0aCAnd29yZCcKKy8v IHN0YXJ0aW5nRnJvbTogc3RhcnRpbmcgcG9zaXRpb24gaW4gdGhlIGN1cnJlbnQgc2VhcmNoIGRv bWFpbgorLy8gd29yZDogcHJlZml4IG9mIG1lbnVJdGVtIGxhYmVsIGxvb2tlZCBmb3IKKy8vIGN1 cnJlbnREb21haW46IGN1cnJlbnQgc2VhcmNoIGRvbWFpbgorLy8gcmVzdWx0OiBidWlsZGVkIHNl YXJjaCBkb21haW4gaWYgY3VycmVudERvbWFpbiBoYXMgYmVlbiByZWR1Y2VkCitib29sIFBvcHVw TWVudTo6YnVpbGREb21haW4oR0xpc3QqIHN0YXJ0aW5nRnJvbSwgY29uc3Qgc3RkOjpzdHJpbmcm IHdvcmQsIEdMaXN0KiBjdXJyZW50RG9tYWluLCBHTGlzdComIHJlc3VsdCkKK3sKKyAgICBBU1NF UlQoc3RhcnRpbmdGcm9tKTsKKworICAgIHN0ZDo6c3RyaW5nIGxhYmVsOworICAgIEdMaXN0KiBu ZXdEb21haW4gPSBOVUxMOworICAgIHVuc2lnbmVkIGludCBzaXplID0gZ19saXN0X2xlbmd0aChz dGFydGluZ0Zyb20pOworCisgICAgZm9yICh1bnNpZ25lZCBpbnQgaSA9IGdfbGlzdF9pbmRleChz dGFydGluZ0Zyb20sIHN0YXJ0aW5nRnJvbS0+ZGF0YSk7CisgICAgICAgICBpIDwgc2l6ZTsKKyAg ICAgICAgICsraSkgeworICAgICAgICBsYWJlbCA9IGd0a19tZW51X2l0ZW1fZ2V0X2xhYmVsKEdU S19NRU5VX0lURU0oc3RhcnRpbmdGcm9tLT5kYXRhKSk7CisgICAgICAgIHRyaW0obGFiZWwpOwor ICAgICAgICBpZiAobGFiZWwuc2l6ZSgpID4gd29yZC5zaXplKCkpCisgICAgICAgICAgICBsYWJl bC5lcmFzZSh3b3JkLnNpemUoKSk7CisKKyAgICAgICAgaWYgKChsYWJlbC5jX3N0cigpICYmIHdv cmQuY19zdHIoKSkKKyAgICAgICAgICAgICYmIChzdHJjYXNlY21wKGxhYmVsLmNfc3RyKCksIHdv cmQuY19zdHIoKSkgPT0gMCkpCisgICAgICAgICAgICBuZXdEb21haW4gPSBnX2xpc3RfcHJlcGVu ZChuZXdEb21haW4sIHN0YXJ0aW5nRnJvbS0+ZGF0YSk7CisgICAgICAgIHN0YXJ0aW5nRnJvbSA9 IGdfbGlzdF9uZXh0KHN0YXJ0aW5nRnJvbSk7CisgICAgfQorCisgICAgaWYgKGdfbGlzdF9sZW5n dGgobmV3RG9tYWluKSA8IGdfbGlzdF9sZW5ndGgoY3VycmVudERvbWFpbikpIHsKKyAgICAgICAg cmVzdWx0ID0gZ19saXN0X3JldmVyc2UobmV3RG9tYWluKTsKKyAgICAgICAgcmV0dXJuIHRydWU7 CisgICAgfQorCisgICAgcmV0dXJuIGZhbHNlOworfQorCisvLyBTZWFyY2ggdGhlIHdvcmQgdHlw ZWQgb24gdGhlIGtleWJvYXJkIGluIHRoZSBQb3B1cE1lbnUgYW5kIHNlbGVjdCB0aGUKKy8vIGNv cnJlc3BuZGluZyBtZW51SXRlbSBpZiBmb3VuZAorYm9vbCBQb3B1cE1lbnU6Om1lbnVTZWFyY2hJ dGVtKEd0a1dpZGdldCogd2lkZ2V0LCBHZGtFdmVudEtleSogZXZlbnQsIFBvcHVwTWVudSogdGhh dCkKK3sKKyAgICBBU1NFUlQodGhhdC0+bV9wb3B1cCk7CisKKyAgICBHTGlzdCogc2VhcmNoRG9t YWluID0gTlVMTCwgKnNlYXJjaERvbWFpbk5leHQgPSBOVUxMOworCisgICAgaWYgKCFpc0tleVBy ZXNzVG9aYXAoZXZlbnQsIHRoYXQpKSB7CisgICAgICAgIGlmICh0aGF0LT5zZWFyY2hlZFdvcmQu ZW1wdHkoKSkgeworICAgICAgICAgICAgc2VhcmNoRG9tYWluID0gR1RLX01FTlVfU0hFTEwodGhh dC0+bV9wb3B1cC5nZXQoKSktPmNoaWxkcmVuOworICAgICAgICAgICAgdGhhdC0+c2VhcmNoRG9t YWluTGlzdC5wdXNoX2Zyb250KHNlYXJjaERvbWFpbik7CisgICAgICAgIH0KKworICAgICAgICB0 aGF0LT5zZWFyY2hlZFdvcmQgKz0gZXZlbnQtPmtleXZhbDsKKyAgICAgICAgc3RkOjpsaXN0PEdM aXN0Kj46Oml0ZXJhdG9yIGl0ID0gdGhhdC0+c2VhcmNoRG9tYWluTGlzdC5iZWdpbigpOworCisg ICAgICAgIGlmIChzZWFyY2goKml0LCB0aGF0LT5zZWFyY2hlZFdvcmQsIHNlYXJjaERvbWFpbikp eworICAgICAgICAgICAgZ3RrX21lbnVfc2hlbGxfc2VsZWN0X2l0ZW0oR1RLX01FTlVfU0hFTEwo dGhhdC0+bV9wb3B1cC5nZXQoKSksIEdUS19XSURHRVQoc2VhcmNoRG9tYWluLT5kYXRhKSk7Cisg ICAgICAgICAgICBpZiAoYnVpbGREb21haW4oc2VhcmNoRG9tYWluLCB0aGF0LT5zZWFyY2hlZFdv cmQsICppdCwgc2VhcmNoRG9tYWluTmV4dCkpCisgICAgICAgICAgICAgICAgdGhhdC0+c2VhcmNo RG9tYWluTGlzdC5wdXNoX2Zyb250KHNlYXJjaERvbWFpbk5leHQpOworICAgICAgICAgICAgcmV0 dXJuIHRydWU7CisgICAgICAgIH0KKyAgICB9CisKKyAgICByZXR1cm4gZmFsc2U7Cit9CisKK30K 60537 2010-07-05 08:11:08 -0700 2010-07-21 08:40:41 -0700 Find-as-you-type proposed patch patch.txt text/plain 9095 apelete Y29tbWl0IDAyZDI4ZjYxYTVjM2JlODNmNTk5YzkwZmE1MDZmYWQxMzQ2NzE5MzkKQXV0aG9yOiBB cGVsZXRlIFNla2V0ZWxpIDxhcGVsZXRlQHNla2V0ZWxpLm9yZz4KRGF0ZTogICBTYXQgQXByIDE3 IDE2OjE0OjM3IDIwMTAgKzAyMDAKCiAgICBBZGQgUG9wdXBNZW51ICJmaW5kIGFzIHlvdSB0eXBl IiBzZWFyY2ggKCMyNzQ0MykKICAgIAogICAgSW1wbGVtZW50IGEgcHJvZ3Jlc3NpdmUgc2VhcmNo IG1lY2FuaXNtIHRvIHNlbGVjdCBhbiBpdGVtIGluIGEKICAgIFBvcHVwTWVudSBieSB0eXBpbmcg YSB3b3JkIG9uIHRoZSBrZXlib2FyZC4gVGhlIHNlYXJjaCBjYW4gYmUgcmVzZXRlZCBhdAogICAg YW55IG1vbWVudCBieSBwcmVzc2luZyB0aGUgIkRlbGV0ZSIga2V5LgoKZGlmZiAtLWdpdCBhL1dl YkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMmQ2MGYwNC4uY2YxYWZi MSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cK QEAgLTEsMyArMSw0MSBAQAorMjAxMC0wNy0wNSAgQXBlbGV0ZSBTZWtldGVsaSAgPGFwZWxldGVA c2VrZXRlbGkub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIEJ1ZyAyNzQ0MzogQ29tYm9ib3ggc2hvdWxkIHN1cHBvcnQgImZpbmQtYXMteW91LXR5 cGUiIHNlYXJjaAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9Mjc0NDMKKworICAgICAgICBJbXBsZW1lbnQgYSBwcm9ncmVzc2l2ZSBzZWFyY2ggbWVjYW5p c20gdG8gc2VsZWN0IGFuIGl0ZW0gaW4gYQorICAgICAgICBQb3B1cE1lbnUgYnkgdHlwaW5nIGEg d29yZCBvbiB0aGUga2V5Ym9hcmQuIFRoZSBzZWFyY2ggY2FuIGJlCisgICAgICAgIHJlc2V0ZWQg YXQgYW55IG1vbWVudCBieSBwcmVzc2luZyB0aGUgIkRlbGV0ZSIga2V5LgorCisgICAgICAgIE5v IG5ldyB0ZXN0cyBhcyB0aGVyZSBpcyBubyBuZXcgZnVuY3Rpb25uYWxpdHkuCisKKyAgICAgICAg KiBwbGF0Zm9ybS9Qb3B1cE1lbnUuaDoKKyAgICAgICAgKiBwbGF0Zm9ybS9ndGsvUG9wdXBNZW51 R3RrLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlBvcHVwTWVudTo6bWVudVVubWFwcGVkKToKKyAg ICAgICAgICAgIEFkZGVkIGEgZnVuY3Rpb24gY2FsbCB0byByZXNldFdvcmQuCisgICAgICAgIChX ZWJDb3JlOjpQb3B1cE1lbnU6OnJlc2V0V29yZCk6CisgICAgICAgICAgICBIZWxwZXIgZnVuY3Rp b24gZm9yIGlzS2V5UHJlc3NUb1phcCBhbmQgbWVudVVubWFwcGVkLgorICAgICAgICAgICAgQ2xl YXJzIHRoZSBzZWFyY2ggYW5kIHRoZSBhc3NvY2lhdGVkIHNlYXJjaCBkb21haW4uCisgICAgICAg IChXZWJDb3JlOjpQb3B1cE1lbnU6OmlzS2V5UHJlc3NUb1phcCk6CisgICAgICAgICAgICBIZWxw ZXIgZnVuY3Rpb24gZm9yIG1lbnVTZWFyY2hJdGVtLCBjbGVhcnMgc2VhcmNoIG9uCisgICAgICAg ICAgICBHREtfRGVsZXRlIGtleWJvYXJkIGV2ZW50LgorICAgICAgICAgICAgUmV0dXJucyBGQUxT RSBpZiBrZXlwcmVzcyBpcyB0byBiZSB1c2VkIGJ5IGV2ZW50IGhhbmRsZXIsCisgICAgICAgICAg ICBtZW51U2VhcmNoSXRlbSwgVFJVRSBvdGhlcndpc2UuCisgICAgICAgIChXZWJDb3JlOjpQb3B1 cE1lbnU6OnNlYXJjaCk6CisgICAgICAgICAgICBIZWxwZXIgZnVuY3Rpb24gZm9yIG1lbnVTZWFy Y2hJdGVtLgorICAgICAgICAgICAgUmV0dXJucyBUUlVFIGlmIHNlYXJjaGVkIGVudHJ5IGhhcyBi ZWVuIGZvdW5kLgorICAgICAgICAgICAgUmV0dXJucyBlbnRyeSB0byBiZSBzZWxlY3RlZCBpbiB0 aGlyZCBwYXJhbWV0ZXIgaWYgVFJVRS4KKyAgICAgICAgKFdlYkNvcmU6OlBvcHVwTWVudTo6YnVp bGREb21haW4pOgorICAgICAgICAgICAgSGVscGVyIGZ1bmN0aW9uIGZvciBtZW51U2VhcmNoSXRl bS4KKyAgICAgICAgICAgIFJldHVybnMgVFJVRSBpZiBzZWFyY2ggZG9tYWluIGhhcyBiZWVuIHJl ZHVjZWQuCisgICAgICAgICAgICBSZXR1cm5zIG5ldyBzZWFyY2ggZG9tYWluIGluIHRoaXJkIHBh cmFtZXRlciBpZiBUUlVFLgorICAgICAgICAoV2ViQ29yZTo6UG9wdXBNZW51OjptZW51U2VhcmNo SXRlbSk6CisgICAgICAgICAgICBTZWFyY2ggZm9yIHNvbWV0aGluZyB0eXBlZCBvbiBrZXlib2Fy ZCBpbiBQb3B1cE1lbnUgbGlzdCBvZgorICAgICAgICAgICAgaXRlbXMgYW5kIHNlbGVjdCBjb3Jy ZXNwb25kaW5nIGVudHJ5LgorICAgICAgICAgICAgUmV0dXJucyBUUlVFIGlmIGVudGVyZWQgd29y ZCBpcyBmb3VuZCwgRkFMU0UgaWYgbm90LgorCiAyMDEwLTA3LTA0ICBBbGljZSBMaXUgIDxhbGlj ZS5saXVAYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERhbiBCZXJuc3RlaW4uCmRp ZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL1BvcHVwTWVudS5oIGIvV2ViQ29yZS9wbGF0Zm9y bS9Qb3B1cE1lbnUuaAppbmRleCBkOWQyNzQwLi5lMTk4MmI4IDEwMDY0NAotLS0gYS9XZWJDb3Jl L3BsYXRmb3JtL1BvcHVwTWVudS5oCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vUG9wdXBNZW51LmgK QEAgLTQ5LDggKzQ5LDExIEBAIHR5cGVkZWYgc3RydWN0IF9HdGtNZW51IEd0a01lbnU7CiB0eXBl ZGVmIHN0cnVjdCBfR3RrTWVudUl0ZW0gR3RrTWVudUl0ZW07CiB0eXBlZGVmIHN0cnVjdCBfR3Rr V2lkZ2V0IEd0a1dpZGdldDsKICNpbmNsdWRlICJHUmVmUHRyR3RrLmgiCi0jaW5jbHVkZSA8d3Rm L0hhc2hNYXAuaD4KKyNpbmNsdWRlIDxnZGsvZ2RrLmg+CiAjaW5jbHVkZSA8Z2xpYi5oPgorI2lu Y2x1ZGUgPGxpc3Q+CisjaW5jbHVkZSA8c3RyaW5nPgorI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+ CiAjZWxpZiBQTEFURk9STShXWCkKICNpZmRlZiBfX1dYTVNXX18KICNpbmNsdWRlIDx3eC9tc3cv d2ludW5kZWYuaD4KQEAgLTE3NSw2ICsxNzgsOCBAQCBwcml2YXRlOgogICAgIGJvb2wgbV9zY3Jv bGxiYXJDYXB0dXJpbmdNb3VzZTsKICAgICBib29sIG1fc2hvd1BvcHVwOwogI2VsaWYgUExBVEZP Uk0oR1RLKQorICAgIHN0ZDo6c3RyaW5nIHNlYXJjaGVkV29yZDsKKyAgICBzdGQ6Omxpc3Q8R0xp c3QqPiBzZWFyY2hEb21haW5MaXN0OwogICAgIEludFBvaW50IG1fbWVudVBvc2l0aW9uOwogICAg IEdSZWZQdHI8R3RrTWVudT4gbV9wb3B1cDsKICAgICBIYXNoTWFwPEd0a1dpZGdldCosIGludD4g bV9pbmRleE1hcDsKQEAgLTE4Miw2ICsxODcsMTEgQEAgcHJpdmF0ZToKICAgICBzdGF0aWMgdm9p ZCBtZW51VW5tYXBwZWQoR3RrV2lkZ2V0KiwgUG9wdXBNZW51Kik7CiAgICAgc3RhdGljIHZvaWQg bWVudVBvc2l0aW9uRnVuY3Rpb24oR3RrTWVudSosIGdpbnQqLCBnaW50KiwgZ2Jvb2xlYW4qLCBQ b3B1cE1lbnUqKTsKICAgICBzdGF0aWMgdm9pZCBtZW51UmVtb3ZlSXRlbShHdGtXaWRnZXQqLCBQ b3B1cE1lbnUqKTsKKyAgICBzdGF0aWMgdm9pZCByZXNldFdvcmQoUG9wdXBNZW51Kik7CisgICAg c3RhdGljIGJvb2wgaXNLZXlQcmVzc1RvWmFwKEdka0V2ZW50S2V5KiBldmVudCwgUG9wdXBNZW51 Kik7CisgICAgc3RhdGljIGJvb2wgc2VhcmNoKEdMaXN0KiwgY29uc3Qgc3RkOjpzdHJpbmcmLCBH TGlzdComKTsKKyAgICBzdGF0aWMgYm9vbCBidWlsZERvbWFpbihHTGlzdCosIGNvbnN0IHN0ZDo6 c3RyaW5nJiwgR0xpc3QqLCBHTGlzdComKTsKKyAgICBzdGF0aWMgYm9vbCBtZW51U2VhcmNoSXRl bShHdGtXaWRnZXQqLCBHZGtFdmVudEtleSosIFBvcHVwTWVudSopOwogI2VsaWYgUExBVEZPUk0o RUZMKSB8fCBQTEFURk9STShCUkVXTVApCiAgICAgRnJhbWVWaWV3KiBtX3ZpZXc7CiAjZWxpZiBQ TEFURk9STShXWCkKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1BvcHVwTWVudUd0 ay5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Qb3B1cE1lbnVHdGsuY3BwCmluZGV4IGJmOGNm YjQuLjM5M2QwMmQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1BvcHVwTWVudUd0 ay5jcHAKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvUG9wdXBNZW51R3RrLmNwcApAQCAtMjks OCArMjksMTAgQEAKICNpbmNsdWRlICJHdGtWZXJzaW9uaW5nLmgiCiAjaW5jbHVkZSAiSG9zdFdp bmRvdy5oIgogI2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCi0jaW5jbHVkZSA8d3RmL3RleHQv Q1N0cmluZy5oPgorI2luY2x1ZGUgPGdkay9nZGtrZXlzeW1zLmg+CiAjaW5jbHVkZSA8Z3RrL2d0 ay5oPgorI2luY2x1ZGUgPHBhbmdvL3BhbmdvLmg+CisjaW5jbHVkZSA8d3RmL3RleHQvQ1N0cmlu Zy5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKQEAgLTU0LDYgKzU2LDcgQEAgdm9pZCBQb3B1 cE1lbnU6OnNob3coY29uc3QgSW50UmVjdCYgcmVjdCwgRnJhbWVWaWV3KiB2aWV3LCBpbnQgaW5k ZXgpCiAgICAgaWYgKCFtX3BvcHVwKSB7CiAgICAgICAgIG1fcG9wdXAgPSBHVEtfTUVOVShndGtf bWVudV9uZXcoKSk7CiAgICAgICAgIGdfc2lnbmFsX2Nvbm5lY3QobV9wb3B1cC5nZXQoKSwgInVu bWFwIiwgR19DQUxMQkFDSyhtZW51VW5tYXBwZWQpLCB0aGlzKTsKKyAgICAgICAgZ19zaWduYWxf Y29ubmVjdChtX3BvcHVwLmdldCgpLCAia2V5LXByZXNzLWV2ZW50IiwgR19DQUxMQkFDSyhtZW51 U2VhcmNoSXRlbSksIHRoaXMpOwogICAgIH0gZWxzZQogICAgICAgICBndGtfY29udGFpbmVyX2Zv cmVhY2goR1RLX0NPTlRBSU5FUihtX3BvcHVwLmdldCgpKSwgcmVpbnRlcnByZXRfY2FzdDxHdGtD YWxsYmFjaz4obWVudVJlbW92ZUl0ZW0pLCB0aGlzKTsKIApAQCAtMTM3LDYgKzE0MCw4IEBAIHZv aWQgUG9wdXBNZW51OjptZW51VW5tYXBwZWQoR3RrV2lkZ2V0KiwgUG9wdXBNZW51KiB0aGF0KQog ewogICAgIEFTU0VSVCh0aGF0LT5jbGllbnQoKSk7CiAgICAgdGhhdC0+Y2xpZW50KCktPnBvcHVw RGlkSGlkZSgpOworICAgIC8vIENsZWFyIHRoZSBzZWFyY2ggYW5kIHRoZSBhc3NvY2lhdGVkIGRv bWFpbiBsaXN0CisgICAgcmVzZXRXb3JkKHRoYXQpOwogfQogCiB2b2lkIFBvcHVwTWVudTo6bWVu dVBvc2l0aW9uRnVuY3Rpb24oR3RrTWVudSosIGdpbnQqIHgsIGdpbnQqIHksIGdib29sZWFuKiBw dXNoSW4sIFBvcHVwTWVudSogdGhhdCkKQEAgLTE1Miw1ICsxNTcsMTE1IEBAIHZvaWQgUG9wdXBN ZW51OjptZW51UmVtb3ZlSXRlbShHdGtXaWRnZXQqIHdpZGdldCwgUG9wdXBNZW51KiB0aGF0KQog ICAgIGd0a19jb250YWluZXJfcmVtb3ZlKEdUS19DT05UQUlORVIodGhhdC0+bV9wb3B1cC5nZXQo KSksIHdpZGdldCk7CiB9CiAKKy8vIENsZWFyIHRoZSBzZWFyY2ggYW5kIHRoZSBhc3NvY2lhdGVk IGRvbWFpbiBsaXN0Cit2b2lkIFBvcHVwTWVudTo6cmVzZXRXb3JkKFBvcHVwTWVudSogdGhhdCkK K3sKKyAgICB0aGF0LT5zZWFyY2hlZFdvcmQuY2xlYXIoKTsKKyAgICB0aGF0LT5zZWFyY2hEb21h aW5MaXN0LmNsZWFyKCk7Cit9CisKKy8vIFRlc3Qga2V5cHJlc3NlcyB0byBzZWUgaWYgdGhleSBh cmUgdG8gYmUgcGFzc2VkIHRvIHRoZSBldmVudCBoYW5kbGVyCitib29sIFBvcHVwTWVudTo6aXNL ZXlQcmVzc1RvWmFwKEdka0V2ZW50S2V5KiBldmVudCwgUG9wdXBNZW51KiB0aGF0KQoreworICAg IGd1aW50IGtleXZhbCA9IGdka191bmljb2RlX3RvX2tleXZhbChldmVudC0+a2V5dmFsKTsKKwor ICAgIGlmIChrZXl2YWwgPT0gKGV2ZW50LT5rZXl2YWwgfCAweDAxMDAwMDAwKSkgeworICAgICAg ICBpZiAoZXZlbnQtPmtleXZhbCA9PSBHREtfRGVsZXRlKQorICAgICAgICAgICAgcmVzZXRXb3Jk KHRoYXQpOworICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICB9CisKKyAgICByZXR1cm4gZmFsc2U7 Cit9CisKKy8vIFNlYXJjaCBmb3IgYSBtZW51SXRlbSBpbiBhIGRvbWFpbiBhbmQgcmV0dXJucyB0 aGUgbWVudUl0ZW0gaWYgZm91bmQKKy8vIHNlYXJjaERvbWFpbjogdGhlIGRvbWFpbiBzZWFyY2hl ZAorLy8gd29yZDogdGhlIG1lbnVJdGVtIGxhYmVsCisvLyByZXN1bHRJdGVtOiB0aGUgbWVudUl0 ZW0gaWYgZm91bmQKK2Jvb2wgUG9wdXBNZW51OjpzZWFyY2goR0xpc3QqIHNlYXJjaERvbWFpbiwg Y29uc3Qgc3RkOjpzdHJpbmcmIHdvcmQsIEdMaXN0KiYgcmVzdWx0SXRlbSkKK3sKKyAgICBBU1NF UlQoc2VhcmNoRG9tYWluKTsKKworICAgIHN0ZDo6c3RyaW5nIGxhYmVsOworICAgIHVuc2lnbmVk IGludCBzaXplID0gZ19saXN0X2xlbmd0aChzZWFyY2hEb21haW4pOworCisgICAgZm9yICh1bnNp Z25lZCBpbnQgaSA9IDA7IGkgPCBzaXplOyArK2kpIHsKKyAgICAgICAgbGFiZWwgPSBndGtfbWVu dV9pdGVtX2dldF9sYWJlbChHVEtfTUVOVV9JVEVNKHNlYXJjaERvbWFpbi0+ZGF0YSkpOworICAg ICAgICBpZiAoIWxhYmVsLmVtcHR5KCkpCisgICAgICAgICAgICBsYWJlbCA9IHBhbmdvX3RyaW1f c3RyaW5nKGxhYmVsLmNfc3RyKCkpOworICAgICAgICBpZiAobGFiZWwuc2l6ZSgpID4gd29yZC5z aXplKCkpCisgICAgICAgICAgICBsYWJlbC5lcmFzZSh3b3JkLnNpemUoKSk7CisKKyAgICAgICAg aWYgKChsYWJlbC5jX3N0cigpICYmIHdvcmQuY19zdHIoKSkgJiYgIXN0cmNhc2VjbXAobGFiZWwu Y19zdHIoKSwgd29yZC5jX3N0cigpKSkgeworICAgICAgICAgICAgcmVzdWx0SXRlbSA9IHNlYXJj aERvbWFpbjsKKyAgICAgICAgICAgIHJldHVybiB0cnVlOworICAgICAgICB9CisgICAgICAgIHNl YXJjaERvbWFpbiA9IGdfbGlzdF9uZXh0KHNlYXJjaERvbWFpbik7CisgICAgfQorCisgICAgcmV0 dXJuIGZhbHNlOworfQorCisvLyBCdWlsZCBhIHNlYXJjaCBkb21haW4gY29udGFpbmluZyBtZW51 SXRlbXMgc3RhcnRpbmcgd2l0aCAnd29yZCcKKy8vIHN0YXJ0aW5nRnJvbTogc3RhcnRpbmcgcG9z aXRpb24gaW4gdGhlIGN1cnJlbnQgc2VhcmNoIGRvbWFpbgorLy8gd29yZDogcHJlZml4IG9mIG1l bnVJdGVtIGxhYmVsIGxvb2tlZCBmb3IKKy8vIGN1cnJlbnREb21haW46IGN1cnJlbnQgc2VhcmNo IGRvbWFpbgorLy8gcmVzdWx0OiBidWlsZGVkIHNlYXJjaCBkb21haW4gaWYgY3VycmVudERvbWFp biBoYXMgYmVlbiByZWR1Y2VkCitib29sIFBvcHVwTWVudTo6YnVpbGREb21haW4oR0xpc3QqIHN0 YXJ0aW5nRnJvbSwgY29uc3Qgc3RkOjpzdHJpbmcmIHdvcmQsIEdMaXN0KiBjdXJyZW50RG9tYWlu LCBHTGlzdComIHJlc3VsdCkKK3sKKyAgICBBU1NFUlQoc3RhcnRpbmdGcm9tKTsKKworICAgIHN0 ZDo6c3RyaW5nIGxhYmVsOworICAgIEdMaXN0KiBuZXdEb21haW4gPSAwOworICAgIHVuc2lnbmVk IGludCBzaXplID0gZ19saXN0X2xlbmd0aChzdGFydGluZ0Zyb20pOworCisgICAgZm9yICh1bnNp Z25lZCBpbnQgaSA9IGdfbGlzdF9pbmRleChzdGFydGluZ0Zyb20sIHN0YXJ0aW5nRnJvbS0+ZGF0 YSk7IGkgPCBzaXplOyArK2kpIHsKKyAgICAgICAgbGFiZWwgPSBndGtfbWVudV9pdGVtX2dldF9s YWJlbChHVEtfTUVOVV9JVEVNKHN0YXJ0aW5nRnJvbS0+ZGF0YSkpOworICAgICAgICBpZiAoIWxh YmVsLmVtcHR5KCkpCisgICAgICAgICAgICBsYWJlbCA9IHBhbmdvX3RyaW1fc3RyaW5nKGxhYmVs LmNfc3RyKCkpOworICAgICAgICBpZiAobGFiZWwuc2l6ZSgpID4gd29yZC5zaXplKCkpCisgICAg ICAgICAgICBsYWJlbC5lcmFzZSh3b3JkLnNpemUoKSk7CisKKyAgICAgICAgaWYgKChsYWJlbC5j X3N0cigpICYmIHdvcmQuY19zdHIoKSkgJiYgIXN0cmNhc2VjbXAobGFiZWwuY19zdHIoKSwgd29y ZC5jX3N0cigpKSkKKyAgICAgICAgICAgIG5ld0RvbWFpbiA9IGdfbGlzdF9wcmVwZW5kKG5ld0Rv bWFpbiwgc3RhcnRpbmdGcm9tLT5kYXRhKTsKKyAgICAgICAgc3RhcnRpbmdGcm9tID0gZ19saXN0 X25leHQoc3RhcnRpbmdGcm9tKTsKKyAgICB9CisKKyAgICBpZiAoZ19saXN0X2xlbmd0aChuZXdE b21haW4pIDwgZ19saXN0X2xlbmd0aChjdXJyZW50RG9tYWluKSkgeworICAgICAgICByZXN1bHQg PSBnX2xpc3RfcmV2ZXJzZShuZXdEb21haW4pOworICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICB9 CisKKyAgICByZXR1cm4gZmFsc2U7CiB9CiAKKy8vIFNlYXJjaCB0aGUgd29yZCB0eXBlZCBvbiB0 aGUga2V5Ym9hcmQgaW4gdGhlIFBvcHVwTWVudSBhbmQgc2VsZWN0IHRoZQorLy8gY29ycmVzcG5k aW5nIG1lbnVJdGVtIGlmIGZvdW5kCitib29sIFBvcHVwTWVudTo6bWVudVNlYXJjaEl0ZW0oR3Rr V2lkZ2V0KiB3aWRnZXQsIEdka0V2ZW50S2V5KiBldmVudCwgUG9wdXBNZW51KiB0aGF0KQorewor ICAgIEFTU0VSVCh0aGF0LT5tX3BvcHVwKTsKKworICAgIEdMaXN0KiBzZWFyY2hEb21haW4gPSAw LCAqc2VhcmNoRG9tYWluTmV4dCA9IDA7CisKKyAgICBpZiAoIWlzS2V5UHJlc3NUb1phcChldmVu dCwgdGhhdCkpIHsKKyAgICAgICAgaWYgKHRoYXQtPnNlYXJjaGVkV29yZC5lbXB0eSgpKSB7Cisg ICAgICAgICAgICBzZWFyY2hEb21haW4gPSBndGtfY29udGFpbmVyX2dldF9jaGlsZHJlbihHVEtf Q09OVEFJTkVSKHRoYXQtPm1fcG9wdXAuZ2V0KCkpKTsKKyAgICAgICAgICAgIHRoYXQtPnNlYXJj aERvbWFpbkxpc3QucHVzaF9mcm9udChzZWFyY2hEb21haW4pOworICAgICAgICB9CisKKyAgICAg ICAgdGhhdC0+c2VhcmNoZWRXb3JkICs9IGV2ZW50LT5rZXl2YWw7CisgICAgICAgIHN0ZDo6bGlz dDxHTGlzdCo+OjppdGVyYXRvciBpdCA9IHRoYXQtPnNlYXJjaERvbWFpbkxpc3QuYmVnaW4oKTsK KworICAgICAgICBpZiAoc2VhcmNoKCppdCwgdGhhdC0+c2VhcmNoZWRXb3JkLCBzZWFyY2hEb21h aW4pKSB7CisgICAgICAgICAgICBHTGlzdCogcCA9IHNlYXJjaERvbWFpbjsKKyAgICAgICAgICAg IGd0a19tZW51X3NoZWxsX3NlbGVjdF9pdGVtKEdUS19NRU5VX1NIRUxMKHRoYXQtPm1fcG9wdXAu Z2V0KCkpLCBHVEtfV0lER0VUKHAtPmRhdGEpKTsKKyAgICAgICAgICAgIGlmIChidWlsZERvbWFp bihzZWFyY2hEb21haW4sIHRoYXQtPnNlYXJjaGVkV29yZCwgKml0LCBzZWFyY2hEb21haW5OZXh0 KSkKKyAgICAgICAgICAgICAgICB0aGF0LT5zZWFyY2hEb21haW5MaXN0LnB1c2hfZnJvbnQoc2Vh cmNoRG9tYWluTmV4dCk7CisgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICAgICAgfQorICAg IH0KKworICAgIHJldHVybiBmYWxzZTsKK30KKworfQo= 62186 2010-07-21 08:40:41 -0700 2010-08-04 14:54:51 -0700 Find-as-you-type proposed patch patch.txt text/plain 9414 apelete Y29tbWl0IDI0YzYxMDg4ZGEwMzhiMWY5M2FhMjczMGUwM2VlOGQ3ZTM0Yjc5N2YKQXV0aG9yOiBB cGVsZXRlIFNla2V0ZWxpIDxhcGVsZXRlQHNla2V0ZWxpLm9yZz4KRGF0ZTogICBXZWQgSnVsIDIx IDE3OjA5OjAyIDIwMTAgKzAyMDAKCiAgICBBZGQgUG9wdXBNZW51ICJmaW5kIGFzIHlvdSB0eXBl IiBzZWFyY2ggKCMyNzQ0MykKICAgIAogICAgSW1wbGVtZW50IGEgcHJvZ3Jlc3NpdmUgc2VhcmNo IG1lY2FuaXNtIHRvIHNlbGVjdCBhbiBpdGVtIGluIGEgUG9wdXBNZW51CiAgICBieSB0eXBpbmcg YSB3b3JkIG9uIHRoZSBrZXlib2FyZC4gVGhlIHNlYXJjaCBjYW4gYmUgcmVzZXRlZCBhdCBhbnkK ICAgIG1vbWVudCBieSBwcmVzc2luZyB0aGUgIkRlbGV0ZSIga2V5LgoKZGlmZiAtLWdpdCBhL1dl YkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNTM1Y2QwYy4uZjkwNzJh NyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cK QEAgLTEsMyArMSw0NSBAQAorMjAxMC0wNy0yMSAgQXBlbGV0ZSBTZWtldGVsaSAgPGFwZWxldGVA c2VrZXRlbGkub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIEJ1ZyAyNzQ0MzogQ29tYm9ib3ggc2hvdWxkIHN1cHBvcnQgImZpbmQtYXMteW91LXR5 cGUiIHNlYXJjaAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9Mjc0NDMKKworICAgICAgICBJbXBsZW1lbnQgYSBwcm9ncmVzc2l2ZSBzZWFyY2ggbWVjYW5p c20gdG8gc2VsZWN0IGFuIGl0ZW0gaW4gYQorICAgICAgICBQb3B1cE1lbnUgYnkgdHlwaW5nIGEg d29yZCBvbiB0aGUga2V5Ym9hcmQuIFRoZSBzZWFyY2ggY2FuIGJlCisgICAgICAgIHJlc2V0ZWQg YXQgYW55IG1vbWVudCBieSBwcmVzc2luZyB0aGUgIkRlbGV0ZSIga2V5LgorCisgICAgICAgICog cGxhdGZvcm0vUG9wdXBNZW51Lmg6CisgICAgICAgICogcGxhdGZvcm0vZ3RrL1BvcHVwTWVudUd0 ay5jcHA6CisgICAgICAgIChXZWJDb3JlOjpQb3B1cE1lbnU6OnNob3cpOgorICAgICAgICAgICAg QWRkZWQgYSBjYWxsYmFjayB0byBoYW5kbGUga2V5cHJlc3MgZXZlbnRzLgorICAgICAgICAoV2Vi Q29yZTo6UG9wdXBNZW51OjptZW51VW5tYXBwZWQpOgorICAgICAgICAgICAgQWRkZWQgYSBmdW5j dGlvbiBjYWxsIHRvIHJlc2V0V29yZC4KKyAgICAgICAgKFdlYkNvcmU6OlBvcHVwTWVudTo6cmVz ZXRXb3JkKToKKyAgICAgICAgICAgIEhlbHBlciBmdW5jdGlvbiBmb3IgaXNLZXlQcmVzc1RvWmFw IGFuZCBtZW51VW5tYXBwZWQKKyAgICAgICAgICAgIENsZWFycyB0aGUgc2VhcmNoIGFuZCB0aGUg YXNzb2NpYXRlZCBzZWFyY2ggZG9tYWluLgorICAgICAgICAoV2ViQ29yZTo6UG9wdXBNZW51Ojpp c0tleVByZXNzVG9aYXApOgorICAgICAgICAgICAgSGVscGVyIGZ1bmN0aW9uIGZvciBldmVudCBo YW5kbGVyLgorICAgICAgICAgICAgUmV0dXJucyBGQUxTRSBpZiBrZXlwcmVzcyBpcyB0byBiZSB1 c2VkIGJ5IGV2ZW50IGhhbmRsZXIsCisgICAgICAgICAgICBUUlVFIG90aGVyd2lzZS4KKyAgICAg ICAgKFdlYkNvcmU6OlBvcHVwTWVudTo6c2VhcmNoKToKKyAgICAgICAgICAgIEhlbHBlciBmdW5j dGlvbiBmb3Igc2VhcmNoSXRlbS4KKyAgICAgICAgICAgIFJldHVybnMgVFJVRSBpZiBzZWFyY2hl ZCBlbnRyeSBoYXMgYmVlbiBmb3VuZC4KKyAgICAgICAgICAgIFJldHVybnMgZW50cnkgdG8gYmUg c2VsZWN0ZWQgaW4gdGhpcmQgcGFyYW1ldGVyIGlmIFRSVUUuCisgICAgICAgIChXZWJDb3JlOjpQ b3B1cE1lbnU6OmJ1aWxkRG9tYWluKToKKyAgICAgICAgICAgIEhlbHBlciBmdW5jdGlvbiBmb3Ig c2VhcmNoSXRlbS4KKyAgICAgICAgICAgIFJldHVybnMgVFJVRSBpZiBzZWFyY2ggZG9tYWluIGhh cyBiZWVuIHJlZHVjZWQuCisgICAgICAgICAgICBSZXR1cm5zIG5ldyBzZWFyY2ggZG9tYWluIGlu IHRoaXJkIHBhcmFtZXRlciBpZiBUUlVFLgorICAgICAgICAoV2ViQ29yZTo6UG9wdXBNZW51Ojpz ZWFyY2hJdGVtKToKKyAgICAgICAgICAgIEhlbHBlciBmdW5jdGlvbiBmb3IgZXZlbnQgaGFuZGxl ci4KKyAgICAgICAgICAgIFNlYXJjaCBmb3Igc29tZXRoaW5nIHR5cGVkIG9uIGtleWJvYXJkIGlu IFBvcHVwTWVudSBsaXN0IG9mCisgICAgICAgICAgICBpdGVtcyBhbmQgc2VsZWN0IGNvcnJlc3Bv bmRpbmcgZW50cnkuCisgICAgICAgIChXZWJDb3JlOjpQb3B1cE1lbnU6OmtleVByZXNzRXZlbnRD YWxsYmFjayk6CisgICAgICAgICAgICBLZXlwcmVzcyBldmVudHMgaGFuZGxlci4KKyAgICAgICAg ICAgIFN0YXJ0cyBhIHNlYXJjaCBpZiB0aGUga2V5IGlzIG5vdCBhIG1vZGlmaWVyLCBhbmQgcmVz ZXRzIHRoZQorICAgICAgICAgICAgc2VhcmNoIGJ5IGNhbGxpbmcgcmVzZXRXb3JkIGlmIERlbGV0 ZSBrZXkgaXMgcHJlc3NlZC4KKyAgICAgICAgICAgIFJldHVybnMgVFJVRSBpZiB0aGUga2V5IGhh cyBiZWVuIGhhbmRsZWQsIEZBTFNFIGlmIG5vdC4KKwogMjAxMC0wNy0xNyAgTmlraXRhIFZhc2ls eWV2ICA8bWVAZWx2MXMucnU+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgUGF2ZWwgRmVsZG1hbi4K ZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vUG9wdXBNZW51LmggYi9XZWJDb3JlL3BsYXRm b3JtL1BvcHVwTWVudS5oCmluZGV4IGQ5ZDI3NDAuLmRhZGZiYTggMTAwNjQ0Ci0tLSBhL1dlYkNv cmUvcGxhdGZvcm0vUG9wdXBNZW51LmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9Qb3B1cE1lbnUu aApAQCAtNDksOCArNDksMTEgQEAgdHlwZWRlZiBzdHJ1Y3QgX0d0a01lbnUgR3RrTWVudTsKIHR5 cGVkZWYgc3RydWN0IF9HdGtNZW51SXRlbSBHdGtNZW51SXRlbTsKIHR5cGVkZWYgc3RydWN0IF9H dGtXaWRnZXQgR3RrV2lkZ2V0OwogI2luY2x1ZGUgIkdSZWZQdHJHdGsuaCIKLSNpbmNsdWRlIDx3 dGYvSGFzaE1hcC5oPgorI2luY2x1ZGUgPGdkay9nZGsuaD4KICNpbmNsdWRlIDxnbGliLmg+Cisj aW5jbHVkZSA8bGlzdD4KKyNpbmNsdWRlIDxzdHJpbmc+CisjaW5jbHVkZSA8d3RmL0hhc2hNYXAu aD4KICNlbGlmIFBMQVRGT1JNKFdYKQogI2lmZGVmIF9fV1hNU1dfXwogI2luY2x1ZGUgPHd4L21z dy93aW51bmRlZi5oPgpAQCAtMTc1LDYgKzE3OCw4IEBAIHByaXZhdGU6CiAgICAgYm9vbCBtX3Nj cm9sbGJhckNhcHR1cmluZ01vdXNlOwogICAgIGJvb2wgbV9zaG93UG9wdXA7CiAjZWxpZiBQTEFU Rk9STShHVEspCisgICAgc3RkOjpzdHJpbmcgbV9zZWFyY2hlZFdvcmQ7CisgICAgc3RkOjpsaXN0 PEdMaXN0Kj4gbV9zZWFyY2hEb21haW5MaXN0OwogICAgIEludFBvaW50IG1fbWVudVBvc2l0aW9u OwogICAgIEdSZWZQdHI8R3RrTWVudT4gbV9wb3B1cDsKICAgICBIYXNoTWFwPEd0a1dpZGdldCos IGludD4gbV9pbmRleE1hcDsKQEAgLTE4Miw2ICsxODcsMTIgQEAgcHJpdmF0ZToKICAgICBzdGF0 aWMgdm9pZCBtZW51VW5tYXBwZWQoR3RrV2lkZ2V0KiwgUG9wdXBNZW51Kik7CiAgICAgc3RhdGlj IHZvaWQgbWVudVBvc2l0aW9uRnVuY3Rpb24oR3RrTWVudSosIGdpbnQqLCBnaW50KiwgZ2Jvb2xl YW4qLCBQb3B1cE1lbnUqKTsKICAgICBzdGF0aWMgdm9pZCBtZW51UmVtb3ZlSXRlbShHdGtXaWRn ZXQqLCBQb3B1cE1lbnUqKTsKKyAgICB2b2lkIHJlc2V0V29yZCgpOworICAgIGJvb2wgaXNLZXlQ cmVzc1RvWmFwKEdka0V2ZW50S2V5Kik7CisgICAgYm9vbCBzZWFyY2goR0xpc3QqLCBjb25zdCBz dGQ6OnN0cmluZyYsIEdMaXN0KiYpOworICAgIGJvb2wgYnVpbGREb21haW4oR0xpc3QqLCBjb25z dCBzdGQ6OnN0cmluZyYsIEdMaXN0KiwgR0xpc3QqJik7CisgICAgdm9pZCBzZWFyY2hJdGVtKEdk a0V2ZW50S2V5KiwgUG9wdXBNZW51Kik7CisgICAgc3RhdGljIGJvb2wga2V5UHJlc3NFdmVudENh bGxiYWNrKEd0a1dpZGdldCosIEdka0V2ZW50S2V5KiwgUG9wdXBNZW51Kik7CiAjZWxpZiBQTEFU Rk9STShFRkwpIHx8IFBMQVRGT1JNKEJSRVdNUCkKICAgICBGcmFtZVZpZXcqIG1fdmlldzsKICNl bGlmIFBMQVRGT1JNKFdYKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvUG9wdXBN ZW51R3RrLmNwcCBiL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1BvcHVwTWVudUd0ay5jcHAKaW5kZXgg YmY4Y2ZiNC4uNjU3NTJkNyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvUG9wdXBN ZW51R3RrLmNwcAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Qb3B1cE1lbnVHdGsuY3BwCkBA IC0yOSw4ICsyOSwxMCBAQAogI2luY2x1ZGUgIkd0a1ZlcnNpb25pbmcuaCIKICNpbmNsdWRlICJI b3N0V2luZG93LmgiCiAjaW5jbHVkZSAiUGxhdGZvcm1TdHJpbmcuaCIKLSNpbmNsdWRlIDx3dGYv dGV4dC9DU3RyaW5nLmg+CisjaW5jbHVkZSA8Z2RrL2dka2tleXN5bXMuaD4KICNpbmNsdWRlIDxn dGsvZ3RrLmg+CisjaW5jbHVkZSA8cGFuZ28vcGFuZ28uaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9D U3RyaW5nLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIApAQCAtNTQsNiArNTYsNyBAQCB2b2lk IFBvcHVwTWVudTo6c2hvdyhjb25zdCBJbnRSZWN0JiByZWN0LCBGcmFtZVZpZXcqIHZpZXcsIGlu dCBpbmRleCkKICAgICBpZiAoIW1fcG9wdXApIHsKICAgICAgICAgbV9wb3B1cCA9IEdUS19NRU5V KGd0a19tZW51X25ldygpKTsKICAgICAgICAgZ19zaWduYWxfY29ubmVjdChtX3BvcHVwLmdldCgp LCAidW5tYXAiLCBHX0NBTExCQUNLKG1lbnVVbm1hcHBlZCksIHRoaXMpOworICAgICAgICBnX3Np Z25hbF9jb25uZWN0KG1fcG9wdXAuZ2V0KCksICJrZXktcHJlc3MtZXZlbnQiLCBHX0NBTExCQUNL KGtleVByZXNzRXZlbnRDYWxsYmFjayksIHRoaXMpOwogICAgIH0gZWxzZQogICAgICAgICBndGtf Y29udGFpbmVyX2ZvcmVhY2goR1RLX0NPTlRBSU5FUihtX3BvcHVwLmdldCgpKSwgcmVpbnRlcnBy ZXRfY2FzdDxHdGtDYWxsYmFjaz4obWVudVJlbW92ZUl0ZW0pLCB0aGlzKTsKIApAQCAtMTM3LDYg KzE0MCw4IEBAIHZvaWQgUG9wdXBNZW51OjptZW51VW5tYXBwZWQoR3RrV2lkZ2V0KiwgUG9wdXBN ZW51KiB0aGF0KQogewogICAgIEFTU0VSVCh0aGF0LT5jbGllbnQoKSk7CiAgICAgdGhhdC0+Y2xp ZW50KCktPnBvcHVwRGlkSGlkZSgpOworICAgIC8vIENsZWFyIHRoZSBzZWFyY2ggYW5kIHRoZSBh c3NvY2lhdGVkIGRvbWFpbiBsaXN0CisgICAgdGhhdC0+cmVzZXRXb3JkKCk7CiB9CiAKIHZvaWQg UG9wdXBNZW51OjptZW51UG9zaXRpb25GdW5jdGlvbihHdGtNZW51KiwgZ2ludCogeCwgZ2ludCog eSwgZ2Jvb2xlYW4qIHB1c2hJbiwgUG9wdXBNZW51KiB0aGF0KQpAQCAtMTUyLDUgKzE1NywxMjEg QEAgdm9pZCBQb3B1cE1lbnU6Om1lbnVSZW1vdmVJdGVtKEd0a1dpZGdldCogd2lkZ2V0LCBQb3B1 cE1lbnUqIHRoYXQpCiAgICAgZ3RrX2NvbnRhaW5lcl9yZW1vdmUoR1RLX0NPTlRBSU5FUih0aGF0 LT5tX3BvcHVwLmdldCgpKSwgd2lkZ2V0KTsKIH0KIAorLy8gQ2xlYXIgdGhlIHNlYXJjaCBhbmQg dGhlIGFzc29jaWF0ZWQgZG9tYWluIGxpc3QKK3ZvaWQgUG9wdXBNZW51OjpyZXNldFdvcmQoKQor eworICAgIG1fc2VhcmNoZWRXb3JkLmNsZWFyKCk7CisgICAgbV9zZWFyY2hEb21haW5MaXN0LmNs ZWFyKCk7Cit9CisKKy8vIFRlc3Qga2V5cHJlc3NlcyB0byBzZWUgaWYgdGhleSBhcmUgdG8gYmUg cGFzc2VkIHRvIHRoZSBldmVudCBoYW5kbGVyCitib29sIFBvcHVwTWVudTo6aXNLZXlQcmVzc1Rv WmFwKEdka0V2ZW50S2V5KiBldmVudCkKK3sKKyAgICBndWludCBrZXl2YWwgPSBnZGtfdW5pY29k ZV90b19rZXl2YWwoZXZlbnQtPmtleXZhbCk7CisKKyAgICAvLyBJZiB0aGUga2V5IGlzIGEgbW9k aWZpZXIgaXQgc2hvdWxkIGJlIHphcHBlZAorICAgIGlmIChrZXl2YWwgPT0gKGV2ZW50LT5rZXl2 YWwgfCAweDAxMDAwMDAwKSkKKyAgICAgICAgcmV0dXJuIHRydWU7CisKKyAgICByZXR1cm4gZmFs c2U7Cit9CisKKy8vIFNlYXJjaCBmb3IgYSBtZW51SXRlbSBpbiBhIGRvbWFpbiBhbmQgcmV0dXJu cyB0aGUgbWVudUl0ZW0gaWYgZm91bmQKKy8vIHNlYXJjaERvbWFpbjogdGhlIGRvbWFpbiBzZWFy Y2hlZAorLy8gd29yZDogdGhlIG1lbnVJdGVtIGxhYmVsCisvLyByZXN1bHRJdGVtOiB0aGUgbWVu dUl0ZW0gaWYgZm91bmQKK2Jvb2wgUG9wdXBNZW51OjpzZWFyY2goR0xpc3QqIHNlYXJjaERvbWFp biwgY29uc3Qgc3RkOjpzdHJpbmcmIHdvcmQsIEdMaXN0KiYgcmVzdWx0SXRlbSkKK3sKKyAgICBB U1NFUlQoc2VhcmNoRG9tYWluKTsKKworICAgIHN0ZDo6c3RyaW5nIGxhYmVsOworICAgIHVuc2ln bmVkIGludCBzaXplID0gZ19saXN0X2xlbmd0aChzZWFyY2hEb21haW4pOworCisgICAgZm9yICh1 bnNpZ25lZCBpbnQgaSA9IDA7IGkgPCBzaXplOyArK2kpIHsKKyAgICAgICAgbGFiZWwgPSBndGtf bWVudV9pdGVtX2dldF9sYWJlbChHVEtfTUVOVV9JVEVNKHNlYXJjaERvbWFpbi0+ZGF0YSkpOwor ICAgICAgICBpZiAoIWxhYmVsLmVtcHR5KCkpCisgICAgICAgICAgICBsYWJlbCA9IHBhbmdvX3Ry aW1fc3RyaW5nKGxhYmVsLmNfc3RyKCkpOworICAgICAgICBpZiAobGFiZWwuc2l6ZSgpID4gd29y ZC5zaXplKCkpCisgICAgICAgICAgICBsYWJlbC5lcmFzZSh3b3JkLnNpemUoKSk7CisKKyAgICAg ICAgaWYgKChsYWJlbC5jX3N0cigpICYmIHdvcmQuY19zdHIoKSkgJiYgIXN0cmNhc2VjbXAobGFi ZWwuY19zdHIoKSwgd29yZC5jX3N0cigpKSkgeworICAgICAgICAgICAgcmVzdWx0SXRlbSA9IHNl YXJjaERvbWFpbjsKKyAgICAgICAgICAgIHJldHVybiB0cnVlOworICAgICAgICB9CisgICAgICAg IHNlYXJjaERvbWFpbiA9IGdfbGlzdF9uZXh0KHNlYXJjaERvbWFpbik7CisgICAgfQorCisgICAg cmV0dXJuIGZhbHNlOworfQorCisvLyBCdWlsZCBhIHNlYXJjaCBkb21haW4gY29udGFpbmluZyBt ZW51SXRlbXMgc3RhcnRpbmcgd2l0aCAnd29yZCcKKy8vIHN0YXJ0aW5nRnJvbTogc3RhcnRpbmcg cG9zaXRpb24gaW4gdGhlIGN1cnJlbnQgc2VhcmNoIGRvbWFpbgorLy8gd29yZDogcHJlZml4IG9m IG1lbnVJdGVtIGxhYmVsIGxvb2tlZCBmb3IKKy8vIGN1cnJlbnREb21haW46IGN1cnJlbnQgc2Vh cmNoIGRvbWFpbgorLy8gcmVzdWx0OiBidWlsZGVkIHNlYXJjaCBkb21haW4gaWYgY3VycmVudERv bWFpbiBoYXMgYmVlbiByZWR1Y2VkCitib29sIFBvcHVwTWVudTo6YnVpbGREb21haW4oR0xpc3Qq IHN0YXJ0aW5nRnJvbSwgY29uc3Qgc3RkOjpzdHJpbmcmIHdvcmQsIEdMaXN0KiBjdXJyZW50RG9t YWluLCBHTGlzdComIHJlc3VsdCkKK3sKKyAgICBBU1NFUlQoc3RhcnRpbmdGcm9tKTsKKworICAg IHN0ZDo6c3RyaW5nIGxhYmVsOworICAgIEdMaXN0KiBuZXdEb21haW4gPSAwOworICAgIHVuc2ln bmVkIGludCBzaXplID0gZ19saXN0X2xlbmd0aChzdGFydGluZ0Zyb20pOworCisgICAgZm9yICh1 bnNpZ25lZCBpbnQgaSA9IGdfbGlzdF9pbmRleChzdGFydGluZ0Zyb20sIHN0YXJ0aW5nRnJvbS0+ ZGF0YSk7IGkgPCBzaXplOyArK2kpIHsKKyAgICAgICAgbGFiZWwgPSBndGtfbWVudV9pdGVtX2dl dF9sYWJlbChHVEtfTUVOVV9JVEVNKHN0YXJ0aW5nRnJvbS0+ZGF0YSkpOworICAgICAgICBpZiAo IWxhYmVsLmVtcHR5KCkpCisgICAgICAgICAgICBsYWJlbCA9IHBhbmdvX3RyaW1fc3RyaW5nKGxh YmVsLmNfc3RyKCkpOworICAgICAgICBpZiAobGFiZWwuc2l6ZSgpID4gd29yZC5zaXplKCkpCisg ICAgICAgICAgICBsYWJlbC5lcmFzZSh3b3JkLnNpemUoKSk7CisKKyAgICAgICAgaWYgKChsYWJl bC5jX3N0cigpICYmIHdvcmQuY19zdHIoKSkgJiYgIXN0cmNhc2VjbXAobGFiZWwuY19zdHIoKSwg d29yZC5jX3N0cigpKSkKKyAgICAgICAgICAgIG5ld0RvbWFpbiA9IGdfbGlzdF9wcmVwZW5kKG5l d0RvbWFpbiwgc3RhcnRpbmdGcm9tLT5kYXRhKTsKKyAgICAgICAgc3RhcnRpbmdGcm9tID0gZ19s aXN0X25leHQoc3RhcnRpbmdGcm9tKTsKKyAgICB9CisKKyAgICBpZiAoZ19saXN0X2xlbmd0aChu ZXdEb21haW4pIDwgZ19saXN0X2xlbmd0aChjdXJyZW50RG9tYWluKSkgeworICAgICAgICByZXN1 bHQgPSBnX2xpc3RfcmV2ZXJzZShuZXdEb21haW4pOworICAgICAgICByZXR1cm4gdHJ1ZTsKKyAg ICB9CisKKyAgICByZXR1cm4gZmFsc2U7Cit9CisKKy8vIFNlYXJjaCB0aGUgd29yZCB0eXBlZCBv biB0aGUga2V5Ym9hcmQgaW4gdGhlIFBvcHVwTWVudSBhbmQgc2VsZWN0IHRoZQorLy8gY29ycmVz cG5kaW5nIG1lbnVJdGVtIGlmIGZvdW5kCit2b2lkIFBvcHVwTWVudTo6c2VhcmNoSXRlbShHZGtF dmVudEtleSogZXZlbnQsIFBvcHVwTWVudSogdGhhdCkKK3sKKyAgICBBU1NFUlQobV9wb3B1cCk7 CisKKyAgICBHTGlzdCogc2VhcmNoRG9tYWluID0gMCwgKnNlYXJjaERvbWFpbk5leHQgPSAwOwor CisgICAgaWYgKG1fc2VhcmNoZWRXb3JkLmVtcHR5KCkpIHsKKyAgICAgICAgc2VhcmNoRG9tYWlu ID0gZ3RrX2NvbnRhaW5lcl9nZXRfY2hpbGRyZW4oR1RLX0NPTlRBSU5FUihtX3BvcHVwLmdldCgp KSk7CisgICAgICAgIG1fc2VhcmNoRG9tYWluTGlzdC5wdXNoX2Zyb250KHNlYXJjaERvbWFpbik7 CisgICAgfQorCisgICAgbV9zZWFyY2hlZFdvcmQgKz0gZXZlbnQtPmtleXZhbDsKKyAgICBzdGQ6 Omxpc3Q8R0xpc3QqPjo6aXRlcmF0b3IgaXQgPSBtX3NlYXJjaERvbWFpbkxpc3QuYmVnaW4oKTsK KworICAgIGlmICh0aGF0LT5zZWFyY2goKml0LCBtX3NlYXJjaGVkV29yZCwgc2VhcmNoRG9tYWlu KSkgeworICAgICAgICBHTGlzdCogcCA9IHNlYXJjaERvbWFpbjsKKyAgICAgICAgZ3RrX21lbnVf c2hlbGxfc2VsZWN0X2l0ZW0oR1RLX01FTlVfU0hFTEwobV9wb3B1cC5nZXQoKSksIEdUS19XSURH RVQocC0+ZGF0YSkpOworICAgICAgICBpZiAodGhhdC0+YnVpbGREb21haW4oc2VhcmNoRG9tYWlu LCBtX3NlYXJjaGVkV29yZCwgKml0LCBzZWFyY2hEb21haW5OZXh0KSkKKyAgICAgICAgICAgIG1f c2VhcmNoRG9tYWluTGlzdC5wdXNoX2Zyb250KHNlYXJjaERvbWFpbk5leHQpOworICAgIH0KK30K KworYm9vbCBQb3B1cE1lbnU6OmtleVByZXNzRXZlbnRDYWxsYmFjayhHdGtXaWRnZXQqIHdpZGdl dCwgR2RrRXZlbnRLZXkqIGV2ZW50LCBQb3B1cE1lbnUqIHRoYXQpCit7CisgICAgaWYgKCF0aGF0 LT5pc0tleVByZXNzVG9aYXAoZXZlbnQpKSB7CisgICAgICAgIHRoYXQtPnNlYXJjaEl0ZW0oZXZl bnQsIHRoYXQpOworICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICB9CisgICAgLy8gUmVzZXQgdGhl IHNlYXJjaCBvbiBEZWxldGUga2V5IHByZXNzCisgICAgaWYgKGV2ZW50LT5rZXl2YWwgPT0gR0RL X0RlbGV0ZSkKKyAgICAgICAgdGhhdC0+cmVzZXRXb3JkKCk7CisKKyAgICByZXR1cm4gZmFsc2U7 CiB9CiAKK30K 63496 2010-08-04 14:54:51 -0700 2010-11-30 05:17:38 -0800 Find-as-you-type proposed patch patch.txt text/plain 9913 apelete Y29tbWl0IGVlY2U3M2RjZmQ3ZTY2ZTZjZTIxYjdhNTVmNWUyYzE0NjIzMmU0YTgKQXV0aG9yOiBB cGVsZXRlIFNla2V0ZWxpIDxhcGVsZXRlQHNla2V0ZWxpLm9yZz4KRGF0ZTogICBXZWQgSnVsIDIx IDE3OjA5OjAyIDIwMTAgKzAyMDAKCiAgICBBZGQgUG9wdXBNZW51ICJmaW5kIGFzIHlvdSB0eXBl IiBzZWFyY2ggKCMyNzQ0MykKICAgIAogICAgSW1wbGVtZW50IGEgcHJvZ3Jlc3NpdmUgc2VhcmNo IG1lY2FuaXNtIHRvIHNlbGVjdCBhbiBpdGVtIGluIGEgUG9wdXBNZW51CiAgICBieSB0eXBpbmcg YSB3b3JkIG9uIHRoZSBrZXlib2FyZC4gVGhlIHNlYXJjaCBjYW4gYmUgcmVzZXRlZCBhdCBhbnkK ICAgIG1vbWVudCBieSBwcmVzc2luZyB0aGUgIkRlbGV0ZSIga2V5LgoKZGlmZiAtLWdpdCBhL1dl YkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNTM1Y2QwYy4uNzAzZmI3 YSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cK QEAgLTEsMyArMSw1MCBAQAorMjAxMC0wOC0wNCAgQXBlbGV0ZSBTZWtldGVsaSAgPGFwZWxldGVA c2VrZXRlbGkub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIEJ1ZyAyNzQ0MzogQ29tYm9ib3ggc2hvdWxkIHN1cHBvcnQgImZpbmQtYXMteW91LXR5 cGUiIHNlYXJjaAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9Mjc0NDMKKworICAgICAgICBJbXBsZW1lbnQgYSBwcm9ncmVzc2l2ZSBzZWFyY2ggbWVjYW5p c20gdG8gc2VsZWN0IGFuIGl0ZW0gaW4gYQorICAgICAgICBQb3B1cE1lbnUgYnkgdHlwaW5nIGEg d29yZCBvbiB0aGUga2V5Ym9hcmQuIFRoZSBzZWFyY2ggY2FuIGJlCisgICAgICAgIHJlc2V0ZWQg YXQgYW55IG1vbWVudCBieSBwcmVzc2luZyB0aGUgIkRlbGV0ZSIga2V5LgorCisgICAgICAgIE5v IG5ldyB0ZXN0cyBhcyB0aGVyZSdzIG5vIG5ldyBmdW5jdGlvbmFsaXR5LgorCisgICAgICAgICog cGxhdGZvcm0vUG9wdXBNZW51Lmg6CisgICAgICAgICogcGxhdGZvcm0vZ3RrL1BvcHVwTWVudUd0 ay5jcHA6CisgICAgICAgIChXZWJDb3JlOjpQb3B1cE1lbnU6On5Qb3B1cE1lbnUpOgorICAgICAg ICAgICAgQWRkZWQgZnVuY3Rpb24gY2FsbHMgdG8gZnJlZSBHTGlzdCBhbmQgR1N0cmluZyBtZW1i ZXIKKyAgICAgICAgICAgIGF0dHJpYnV0ZXMuCisgICAgICAgIChXZWJDb3JlOjpQb3B1cE1lbnU6 OnNob3cpOgorICAgICAgICAgICAgQWRkZWQgYSBjYWxsYmFjayB0byBoYW5kbGUga2V5cHJlc3Mg ZXZlbnRzIGFuZCBhIGZ1bmN0aW9uIHRvCisgICAgICAgICAgICBpbml0aWFsaXplIEdTdHJpbmcg bWVtYmVyIGF0dHJpYnV0ZS4KKyAgICAgICAgKFdlYkNvcmU6OlBvcHVwTWVudTo6bWVudVVubWFw cGVkKToKKyAgICAgICAgICAgIEFkZGVkIGEgZnVuY3Rpb24gY2FsbCB0byByZXNldFdvcmQuCisg ICAgICAgIChXZWJDb3JlOjpQb3B1cE1lbnU6OnJlc2V0V29yZCk6CisgICAgICAgICAgICBIZWxw ZXIgZnVuY3Rpb24gZm9yIGV2ZW50IGhhbmRsZXIgYW5kIG1lbnVVbm1hcHBlZC4KKyAgICAgICAg ICAgIENsZWFycyB0aGUgc2VhcmNoLgorICAgICAgICAoV2ViQ29yZTo6UG9wdXBNZW51Ojppc1By aW50YWJsZSk6CisgICAgICAgICAgICBIZWxwZXIgZnVuY3Rpb24gZm9yIGV2ZW50IGhhbmRsZXIu CisgICAgICAgICAgICBSZXR1cm5zIFRSVUUgaWYgdGhlIGtleSBpcyBhIHByaW50YWJsZSBjaGFy YWN0ZXIuCisgICAgICAgIChXZWJDb3JlOjpQb3B1cE1lbnU6OnNlYXJjaCk6CisgICAgICAgICAg ICBIZWxwZXIgZnVuY3Rpb24gZm9yIHNlYXJjaEl0ZW0uCisgICAgICAgICAgICBSZXR1cm5zIFRS VUUgaWYgc2VhcmNoZWQgZW50cnkgaGFzIGJlZW4gZm91bmQuCisgICAgICAgICAgICBSZXR1cm5z IGVudHJ5IHRvIGJlIHNlbGVjdGVkIGluIHRoaXJkIHBhcmFtZXRlciBpZiBUUlVFLgorICAgICAg ICAoV2ViQ29yZTo6UG9wdXBNZW51OjpmaWx0ZXJEb21haW4pOgorICAgICAgICAgICAgSGVscGVy IGZ1bmN0aW9uIGZvciBzZWFyY2hJdGVtLgorICAgICAgICAgICAgUmV0dXJucyBUUlVFIGlmIHNl YXJjaCBkb21haW4gaGFzIGJlZW4gcmVkdWNlZC4KKyAgICAgICAgICAgIFJldHVybnMgbmV3IHNl YXJjaCBkb21haW4gaW4gdGhpcmQgcGFyYW1ldGVyIGlmIFRSVUUuCisgICAgICAgIChXZWJDb3Jl OjpQb3B1cE1lbnU6OnNlYXJjaEl0ZW0pOgorICAgICAgICAgICAgSGVscGVyIGZ1bmN0aW9uIGZv ciBldmVudCBoYW5kbGVyLgorICAgICAgICAgICAgU2VhcmNoIGZvciBzb21ldGhpbmcgdHlwZWQg b24ga2V5Ym9hcmQgaW4gUG9wdXBNZW51IGxpc3Qgb2YKKyAgICAgICAgICAgIGl0ZW1zIGFuZCBz ZWxlY3QgY29ycmVzcG9uZGluZyBlbnRyeS4KKyAgICAgICAgKFdlYkNvcmU6OlBvcHVwTWVudTo6 a2V5UHJlc3NFdmVudENhbGxiYWNrKToKKyAgICAgICAgICAgIEtleXByZXNzIGV2ZW50cyBoYW5k bGVyLgorICAgICAgICAgICAgU3RhcnRzIGEgc2VhcmNoIGlmIHRoZSBrZXkgaXMgYSBwcmludGFi bGUgY2hhcmFjdGVyLCBhbmQKKyAgICAgICAgICAgIGNsZWFycyB0aGUgc2VhcmNoIGJ5IGNhbGxp bmcgcmVzZXRXb3JkIG9uIERlbGV0ZSBrZXkgcHJlc3MuCisgICAgICAgICAgICBSZXR1cm5zIFRS VUUgaWYgdGhlIGtleSBoYXMgYmVlbiBoYW5kbGVkLCBGQUxTRSBpZiBub3QuCisKIDIwMTAtMDct MTcgIE5pa2l0YSBWYXNpbHlldiAgPG1lQGVsdjFzLnJ1PgogCiAgICAgICAgIFJldmlld2VkIGJ5 IFBhdmVsIEZlbGRtYW4uCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL1BvcHVwTWVudS5o IGIvV2ViQ29yZS9wbGF0Zm9ybS9Qb3B1cE1lbnUuaAppbmRleCBkOWQyNzQwLi44ZDU0MzNiIDEw MDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL1BvcHVwTWVudS5oCisrKyBiL1dlYkNvcmUvcGxh dGZvcm0vUG9wdXBNZW51LmgKQEAgLTQ5LDggKzQ5LDkgQEAgdHlwZWRlZiBzdHJ1Y3QgX0d0a01l bnUgR3RrTWVudTsKIHR5cGVkZWYgc3RydWN0IF9HdGtNZW51SXRlbSBHdGtNZW51SXRlbTsKIHR5 cGVkZWYgc3RydWN0IF9HdGtXaWRnZXQgR3RrV2lkZ2V0OwogI2luY2x1ZGUgIkdSZWZQdHJHdGsu aCIKLSNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgorI2luY2x1ZGUgPGdkay9nZGsuaD4KICNpbmNs dWRlIDxnbGliLmg+CisjaW5jbHVkZSA8d3RmL0hhc2hNYXAuaD4KICNlbGlmIFBMQVRGT1JNKFdY KQogI2lmZGVmIF9fV1hNU1dfXwogI2luY2x1ZGUgPHd4L21zdy93aW51bmRlZi5oPgpAQCAtMTc1 LDYgKzE3Niw4IEBAIHByaXZhdGU6CiAgICAgYm9vbCBtX3Njcm9sbGJhckNhcHR1cmluZ01vdXNl OwogICAgIGJvb2wgbV9zaG93UG9wdXA7CiAjZWxpZiBQTEFURk9STShHVEspCisgICAgR0xpc3Qq IG1fc2VhcmNoRG9tYWluOworICAgIEdTdHJpbmcqIG1fc2VhcmNoZWRXb3JkOwogICAgIEludFBv aW50IG1fbWVudVBvc2l0aW9uOwogICAgIEdSZWZQdHI8R3RrTWVudT4gbV9wb3B1cDsKICAgICBI YXNoTWFwPEd0a1dpZGdldCosIGludD4gbV9pbmRleE1hcDsKQEAgLTE4Miw2ICsxODUsMTIgQEAg cHJpdmF0ZToKICAgICBzdGF0aWMgdm9pZCBtZW51VW5tYXBwZWQoR3RrV2lkZ2V0KiwgUG9wdXBN ZW51Kik7CiAgICAgc3RhdGljIHZvaWQgbWVudVBvc2l0aW9uRnVuY3Rpb24oR3RrTWVudSosIGdp bnQqLCBnaW50KiwgZ2Jvb2xlYW4qLCBQb3B1cE1lbnUqKTsKICAgICBzdGF0aWMgdm9pZCBtZW51 UmVtb3ZlSXRlbShHdGtXaWRnZXQqLCBQb3B1cE1lbnUqKTsKKyAgICB2b2lkIHJlc2V0V29yZCgp OworICAgIGJvb2wgaXNQcmludGFibGUoR2RrRXZlbnRLZXkqKTsKKyAgICBib29sIHNlYXJjaChH TGlzdCosIEdTdHJpbmcqJiwgR0xpc3QqJik7CisgICAgYm9vbCBmaWx0ZXJEb21haW4oR0xpc3Qq LCBHU3RyaW5nKiYsIEdMaXN0KiwgR0xpc3QqJik7CisgICAgdm9pZCBzZWFyY2hJdGVtKEdka0V2 ZW50S2V5KiwgUG9wdXBNZW51Kik7CisgICAgc3RhdGljIGJvb2wga2V5UHJlc3NFdmVudENhbGxi YWNrKEd0a1dpZGdldCosIEdka0V2ZW50S2V5KiwgUG9wdXBNZW51Kik7CiAjZWxpZiBQTEFURk9S TShFRkwpIHx8IFBMQVRGT1JNKEJSRVdNUCkKICAgICBGcmFtZVZpZXcqIG1fdmlldzsKICNlbGlm IFBMQVRGT1JNKFdYKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvUG9wdXBNZW51 R3RrLmNwcCBiL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1BvcHVwTWVudUd0ay5jcHAKaW5kZXggYmY4 Y2ZiNC4uYzZiZDAzYyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvUG9wdXBNZW51 R3RrLmNwcAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Qb3B1cE1lbnVHdGsuY3BwCkBAIC0y OSw4ICsyOSwxMCBAQAogI2luY2x1ZGUgIkd0a1ZlcnNpb25pbmcuaCIKICNpbmNsdWRlICJIb3N0 V2luZG93LmgiCiAjaW5jbHVkZSAiUGxhdGZvcm1TdHJpbmcuaCIKLSNpbmNsdWRlIDx3dGYvdGV4 dC9DU3RyaW5nLmg+CisjaW5jbHVkZSA8Z2RrL2dka2tleXN5bXMuaD4KICNpbmNsdWRlIDxndGsv Z3RrLmg+CisjaW5jbHVkZSA8cGFuZ28vcGFuZ28uaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9DU3Ry aW5nLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIApAQCAtNDIsNiArNDQsOCBAQCBQb3B1cE1l bnU6OlBvcHVwTWVudShQb3B1cE1lbnVDbGllbnQqIGNsaWVudCkKIFBvcHVwTWVudTo6flBvcHVw TWVudSgpCiB7CiAgICAgaWYgKG1fcG9wdXApIHsKKyAgICAgICAgZ19saXN0X2ZyZWUobV9zZWFy Y2hEb21haW4pOworICAgICAgICBnX3N0cmluZ19mcmVlKG1fc2VhcmNoZWRXb3JkLCBUUlVFKTsK ICAgICAgICAgZ19zaWduYWxfaGFuZGxlcnNfZGlzY29ubmVjdF9tYXRjaGVkKG1fcG9wdXAuZ2V0 KCksIEdfU0lHTkFMX01BVENIX0RBVEEsIDAsIDAsIDAsIDAsIHRoaXMpOwogICAgICAgICBoaWRl KCk7CiAgICAgfQpAQCAtNTQsNiArNTgsNyBAQCB2b2lkIFBvcHVwTWVudTo6c2hvdyhjb25zdCBJ bnRSZWN0JiByZWN0LCBGcmFtZVZpZXcqIHZpZXcsIGludCBpbmRleCkKICAgICBpZiAoIW1fcG9w dXApIHsKICAgICAgICAgbV9wb3B1cCA9IEdUS19NRU5VKGd0a19tZW51X25ldygpKTsKICAgICAg ICAgZ19zaWduYWxfY29ubmVjdChtX3BvcHVwLmdldCgpLCAidW5tYXAiLCBHX0NBTExCQUNLKG1l bnVVbm1hcHBlZCksIHRoaXMpOworICAgICAgICBnX3NpZ25hbF9jb25uZWN0KG1fcG9wdXAuZ2V0 KCksICJrZXktcHJlc3MtZXZlbnQiLCBHX0NBTExCQUNLKGtleVByZXNzRXZlbnRDYWxsYmFjayks IHRoaXMpOwogICAgIH0gZWxzZQogICAgICAgICBndGtfY29udGFpbmVyX2ZvcmVhY2goR1RLX0NP TlRBSU5FUihtX3BvcHVwLmdldCgpKSwgcmVpbnRlcnByZXRfY2FzdDxHdGtDYWxsYmFjaz4obWVu dVJlbW92ZUl0ZW0pLCB0aGlzKTsKIApAQCAtMTA4LDYgKzExMyw3IEBAIHZvaWQgUG9wdXBNZW51 OjpzaG93KGNvbnN0IEludFJlY3QmIHJlY3QsIEZyYW1lVmlldyogdmlldywgaW50IGluZGV4KQog CiAgICAgZ19saXN0X2ZyZWUoY2hpbGRyZW4pOwogICAgIGd0a19tZW51X3BvcHVwKG1fcG9wdXAu Z2V0KCksIDAsIDAsIHJlaW50ZXJwcmV0X2Nhc3Q8R3RrTWVudVBvc2l0aW9uRnVuYz4obWVudVBv c2l0aW9uRnVuY3Rpb24pLCB0aGlzLCAwLCBndGtfZ2V0X2N1cnJlbnRfZXZlbnRfdGltZSgpKTsK KyAgICBtX3NlYXJjaGVkV29yZCA9IGdfc3RyaW5nX25ldyhOVUxMKTsKIH0KIAogdm9pZCBQb3B1 cE1lbnU6OmhpZGUoKQpAQCAtMTM3LDYgKzE0Myw4IEBAIHZvaWQgUG9wdXBNZW51OjptZW51VW5t YXBwZWQoR3RrV2lkZ2V0KiwgUG9wdXBNZW51KiB0aGF0KQogewogICAgIEFTU0VSVCh0aGF0LT5j bGllbnQoKSk7CiAgICAgdGhhdC0+Y2xpZW50KCktPnBvcHVwRGlkSGlkZSgpOworICAgIC8vIENs ZWFyIHRoZSBzZWFyY2ggYW5kIHRoZSBhc3NvY2lhdGVkIGRvbWFpbiBsaXN0CisgICAgdGhhdC0+ cmVzZXRXb3JkKCk7CiB9CiAKIHZvaWQgUG9wdXBNZW51OjptZW51UG9zaXRpb25GdW5jdGlvbihH dGtNZW51KiwgZ2ludCogeCwgZ2ludCogeSwgZ2Jvb2xlYW4qIHB1c2hJbiwgUG9wdXBNZW51KiB0 aGF0KQpAQCAtMTUyLDUgKzE2MCwxMTQgQEAgdm9pZCBQb3B1cE1lbnU6Om1lbnVSZW1vdmVJdGVt KEd0a1dpZGdldCogd2lkZ2V0LCBQb3B1cE1lbnUqIHRoYXQpCiAgICAgZ3RrX2NvbnRhaW5lcl9y ZW1vdmUoR1RLX0NPTlRBSU5FUih0aGF0LT5tX3BvcHVwLmdldCgpKSwgd2lkZ2V0KTsKIH0KIAor Ly8gQ2xlYXIgdGhlIHNlYXJjaAordm9pZCBQb3B1cE1lbnU6OnJlc2V0V29yZCgpCit7CisgICAg Z19zdHJpbmdfZXJhc2UobV9zZWFyY2hlZFdvcmQsIDAsIC0xKTsKK30KKworLy8gVGVzdCBrZXlw cmVzc2VzIHRvIHNlZSBpZiB0aGUgcmVzdWx0IGNoYXJhY3RlciBpcyBwcmludGFibGUKK2Jvb2wg UG9wdXBNZW51Ojppc1ByaW50YWJsZShHZGtFdmVudEtleSogZXZlbnQpCit7CisgICAgZ3VpbnQz MiB1bmljb2RlQ2hhciA9IGdka19rZXl2YWxfdG9fdW5pY29kZShldmVudC0+a2V5dmFsKTsKKwor ICAgIC8vIHVuaWNvZGVDaGFyID0gMCBpZiBjaGFyYWN0ZXIgaXMgbm90IHByaW50YWJsZQorICAg IGlmICghdW5pY29kZUNoYXIpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIHJldHVybiB0 cnVlOworfQorCisvLyBTZWFyY2ggZm9yIGEgbWVudUl0ZW0gaW4gYSBkb21haW4gYW5kIHJldHVy bnMgdGhlIG1lbnVJdGVtIGlmIGZvdW5kCisvLyBzZWFyY2hEb21haW46IHRoZSBkb21haW4gc2Vh cmNoZWQKKy8vIHdvcmQ6IHRoZSBtZW51SXRlbSBsYWJlbAorLy8gcmVzdWx0SXRlbTogdGhlIG1l bnVJdGVtIGlmIGZvdW5kCitib29sIFBvcHVwTWVudTo6c2VhcmNoKEdMaXN0KiBzZWFyY2hEb21h aW4sIEdTdHJpbmcqJiB3b3JkLCBHTGlzdComIHJlc3VsdEl0ZW0pCit7CisgICAgQVNTRVJUKHNl YXJjaERvbWFpbik7CisKKyAgICBHU3RyaW5nKiBsYWJlbCA9IGdfc3RyaW5nX25ldyhOVUxMKTsK KworICAgIGZvciAoOyBzZWFyY2hEb21haW47IHNlYXJjaERvbWFpbiA9IGdfbGlzdF9uZXh0KHNl YXJjaERvbWFpbikpIHsKKyAgICAgICAgZ19zdHJpbmdfYXNzaWduKGxhYmVsLCBndGtfbWVudV9p dGVtX2dldF9sYWJlbChHVEtfTUVOVV9JVEVNKHNlYXJjaERvbWFpbi0+ZGF0YSkpKTsKKyAgICAg ICAgaWYgKGxhYmVsLT5sZW4pCisgICAgICAgICAgICBnX3N0cmluZ19hc3NpZ24obGFiZWwsIHBh bmdvX3RyaW1fc3RyaW5nKGxhYmVsLT5zdHIpKTsKKworICAgICAgICBpZiAoKGxhYmVsLT5sZW4g JiYgd29yZC0+bGVuKSAmJiAhc3RybmNhc2VjbXAobGFiZWwtPnN0ciwgd29yZC0+c3RyLCB3b3Jk LT5sZW4pKSB7CisgICAgICAgICAgICByZXN1bHRJdGVtID0gc2VhcmNoRG9tYWluOworICAgICAg ICAgICAgZ19zdHJpbmdfZnJlZShsYWJlbCwgVFJVRSk7CisgICAgICAgICAgICByZXR1cm4gdHJ1 ZTsKKyAgICAgICAgfQorICAgIH0KKworICAgIGdfc3RyaW5nX2ZyZWUobGFiZWwsIFRSVUUpOwor ICAgIHJldHVybiBmYWxzZTsKK30KKworLy8gRmlsdGVyIHNlYXJjaCBkb21haW4gdG8ga2VlcCBv bmx5IG1lbnVJdGVtcyB3aXRoIHByZWZpeCAnd29yZCcKKy8vIHN0YXJ0aW5nRnJvbTogc3RhcnRp bmcgcG9zaXRpb24gaW4gdGhlIGN1cnJlbnQgc2VhcmNoIGRvbWFpbgorLy8gd29yZDogcHJlZml4 IG9mIG1lbnVJdGVtIGxhYmVsIGxvb2tlZCBmb3IKKy8vIGN1cnJlbnREb21haW46IGN1cnJlbnQg c2VhcmNoIGRvbWFpbgorLy8gcmVzdWx0OiBmaWx0ZXJlZCBzZWFyY2ggZG9tYWluIGlmIGN1cnJl bnREb21haW4gaGFzIGJlZW4gcmVkdWNlZAorYm9vbCBQb3B1cE1lbnU6OmZpbHRlckRvbWFpbihH TGlzdCogc3RhcnRpbmdGcm9tLCBHU3RyaW5nKiYgd29yZCwgR0xpc3QqIGN1cnJlbnREb21haW4s IEdMaXN0KiYgcmVzdWx0KQoreworICAgIEFTU0VSVChzdGFydGluZ0Zyb20pOworCisgICAgR0xp c3QqIG5ld0RvbWFpbiA9IDA7CisgICAgR1N0cmluZyogbGFiZWwgPSBnX3N0cmluZ19uZXcoTlVM TCk7CisKKyAgICBmb3IgKDsgc3RhcnRpbmdGcm9tOyBzdGFydGluZ0Zyb20gPSBnX2xpc3RfbmV4 dChzdGFydGluZ0Zyb20pKSB7CisgICAgICAgIGdfc3RyaW5nX2Fzc2lnbihsYWJlbCwgZ3RrX21l bnVfaXRlbV9nZXRfbGFiZWwoR1RLX01FTlVfSVRFTShzdGFydGluZ0Zyb20tPmRhdGEpKSk7Cisg ICAgICAgIGlmIChsYWJlbC0+bGVuKQorICAgICAgICAgICAgZ19zdHJpbmdfYXNzaWduKGxhYmVs LCBwYW5nb190cmltX3N0cmluZyhsYWJlbC0+c3RyKSk7CisKKyAgICAgICAgaWYgKChsYWJlbC0+ bGVuICYmIHdvcmQtPmxlbikgJiYgIXN0cm5jYXNlY21wKGxhYmVsLT5zdHIsIHdvcmQtPnN0ciwg d29yZC0+bGVuKSkKKyAgICAgICAgICAgIC8vIG1pY3JvLW9wdGltaXphdGlvbjogcHJlcHJlbmQg dGhlbiByZXZlcnNlIGlzIGZhc3RlciB0aGFuIGFwcGVuZAorICAgICAgICAgICAgbmV3RG9tYWlu ID0gZ19saXN0X3ByZXBlbmQobmV3RG9tYWluLCBzdGFydGluZ0Zyb20tPmRhdGEpOworICAgIH0K KworICAgIGlmIChnX2xpc3RfbGVuZ3RoKG5ld0RvbWFpbikgPCBnX2xpc3RfbGVuZ3RoKGN1cnJl bnREb21haW4pKSB7CisgICAgICAgIHJlc3VsdCA9IGdfbGlzdF9yZXZlcnNlKG5ld0RvbWFpbik7 CisgICAgICAgIGdfc3RyaW5nX2ZyZWUobGFiZWwsIFRSVUUpOworICAgICAgICByZXR1cm4gdHJ1 ZTsKKyAgICB9CisKKyAgICBnX3N0cmluZ19mcmVlKGxhYmVsLCBUUlVFKTsKKyAgICByZXR1cm4g ZmFsc2U7Cit9CisKKy8vIFNlYXJjaCB0aGUgd29yZCB0eXBlZCBvbiB0aGUga2V5Ym9hcmQgaW4g dGhlIFBvcHVwTWVudSBhbmQgc2VsZWN0IHRoZQorLy8gY29ycmVzcG9uZGluZyBtZW51SXRlbSBp ZiBmb3VuZAordm9pZCBQb3B1cE1lbnU6OnNlYXJjaEl0ZW0oR2RrRXZlbnRLZXkqIGV2ZW50LCBQ b3B1cE1lbnUqIHRoYXQpCit7CisgICAgQVNTRVJUKG1fcG9wdXApOworCisgICAgR0xpc3QqIHNl YXJjaFJlc3VsdCA9IDAsICpuZXdTZWFyY2hEb21haW4gPSAwOworCisgICAgaWYgKCFtX3NlYXJj aGVkV29yZC0+bGVuKQorICAgICAgICBtX3NlYXJjaERvbWFpbiA9IGd0a19jb250YWluZXJfZ2V0 X2NoaWxkcmVuKEdUS19DT05UQUlORVIobV9wb3B1cC5nZXQoKSkpOworCisgICAgZ19zdHJpbmdf YXBwZW5kX2MobV9zZWFyY2hlZFdvcmQsIGV2ZW50LT5rZXl2YWwpOworCisgICAgaWYgKHRoYXQt PnNlYXJjaChtX3NlYXJjaERvbWFpbiwgbV9zZWFyY2hlZFdvcmQsIHNlYXJjaFJlc3VsdCkpIHsK KyAgICAgICAgR0xpc3QqIHAgPSBzZWFyY2hSZXN1bHQ7CisgICAgICAgIGd0a19tZW51X3NoZWxs X3NlbGVjdF9pdGVtKEdUS19NRU5VX1NIRUxMKG1fcG9wdXAuZ2V0KCkpLCBHVEtfV0lER0VUKHAt PmRhdGEpKTsKKyAgICAgICAgaWYgKHRoYXQtPmZpbHRlckRvbWFpbihzZWFyY2hSZXN1bHQsIG1f c2VhcmNoZWRXb3JkLCBtX3NlYXJjaERvbWFpbiwgbmV3U2VhcmNoRG9tYWluKSkKKyAgICAgICAg ICAgIG1fc2VhcmNoRG9tYWluID0gbmV3U2VhcmNoRG9tYWluOworICAgIH0KK30KKworYm9vbCBQ b3B1cE1lbnU6OmtleVByZXNzRXZlbnRDYWxsYmFjayhHdGtXaWRnZXQqIHdpZGdldCwgR2RrRXZl bnRLZXkqIGV2ZW50LCBQb3B1cE1lbnUqIHRoYXQpCit7CisgICAgaWYgKHRoYXQtPmlzUHJpbnRh YmxlKGV2ZW50KSkgeworICAgICAgICB0aGF0LT5zZWFyY2hJdGVtKGV2ZW50LCB0aGF0KTsKKyAg ICAgICAgcmV0dXJuIHRydWU7CisgICAgfQorICAgIC8vIFJlc2V0IHRoZSBzZWFyY2ggb24gRGVs ZXRlIGtleSBwcmVzcworICAgIGlmIChldmVudC0+a2V5dmFsID09IEdES19EZWxldGUpCisgICAg ICAgIHRoYXQtPnJlc2V0V29yZCgpOworCisgICAgcmV0dXJuIGZhbHNlOwogfQogCit9Cg== 75127 2010-11-30 05:17:45 -0800 2010-11-30 07:07:33 -0800 Patch for this issue bug-27443-20101130141743.patch text/plain 12877 mrobinson ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBiOWMxZTVlN2RhYmI4YWYwMDdiM2IwYmQ1OWUwOGNmYWJkZmU4YTQ0Li5kZWIwMzcw MGNiNGIyNTI0ZGZiMDJlNDFjN2M4MjZiODhjMjUzYTU2IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAK KzIwMTAtMTEtMzAgIE1hcnRpbiBSb2JpbnNvbiAgPG1yb2JpbnNvbkBpZ2FsaWEuY29tPgorCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFtHdGtdIE9wZW4g bWVudWxpc3RzIHNob3VsZCBzdXBwb3J0IHR5cGVhaGVhZCBmaW5kCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNzQ0MworCisgICAgICAgIEFkZGVkIGEg R1RLKy1zcGVjaWZpYyBsYXlvdXQgdGVzdCB0byB0cmFjayB0eXBlYWhlYWQgZmluZCBzdGF0ZS4K KworICAgICAgICAqIHBsYXRmb3JtL2d0ay9mYXN0L2Zvcm1zL21lbnVsaXN0LXR5cGVhaGVhZC1m aW5kLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogcGxhdGZvcm0vZ3RrL2Zhc3QvZm9y bXMvbWVudWxpc3QtdHlwZWFoZWFkLWZpbmQuaHRtbDogQWRkZWQuCisKIDIwMTAtMTEtMjYgIFJv YiBCdWlzICA8cndsYnVpc0BnbWFpbC5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgU2ltb24g RnJhc2VyLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3RrL2Zhc3QvZm9ybXMv bWVudWxpc3QtdHlwZWFoZWFkLWZpbmQtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvcGxhdGZv cm0vZ3RrL2Zhc3QvZm9ybXMvbWVudWxpc3QtdHlwZWFoZWFkLWZpbmQtZXhwZWN0ZWQudHh0Cm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAuLmQ4OTk2ZmFhODkwOTBkNDU3OGQ1ZWJlODNlMDk4Y2UzNTkyMzg1MjQKLS0tIC9k ZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvZmFzdC9mb3Jtcy9tZW51bGlz dC10eXBlYWhlYWQtZmluZC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwxMSBAQAorCisKK0Nhbm5v dCBydW4gaW50ZXJhY3RpdmVseS4KK0V4cGVjdGVkIEFwcGxlOiB3YXMgQXBwbGUKK0V4cGVjdGVk IENhcnJvdDogd2FzIENhcnJvdAorRXhwZWN0ZWQgQ2F1bGlmbG93ZXI6IHdhcyBDYXVsaWZsb3dl cgorRXhwZWN0ZWQgQ29ybjogd2FzIENvcm4KK0V4cGVjdGVkIENhcnJvdDogd2FzIENhcnJvdAor RXhwZWN0ZWQgQXBwbGU6IHdhcyBBcHBsZQorRXhwZWN0ZWQgQ2F1bGlmbG93ZXI6IHdhcyBDYXVs aWZsb3dlcgorRXhwZWN0ZWQgU3RhciBmcnVpdDogd2FzIFN0YXIgZnJ1aXQKZGlmZiAtLWdpdCBh L0xheW91dFRlc3RzL3BsYXRmb3JtL2d0ay9mYXN0L2Zvcm1zL21lbnVsaXN0LXR5cGVhaGVhZC1m aW5kLmh0bWwgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvZmFzdC9mb3Jtcy9tZW51bGlzdC10 eXBlYWhlYWQtZmluZC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjA2MjM3MjM1ZTEwYTdiYThiOTAxYzQyNWI4 MWNmZDA1NjNkMTllZDEKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9n dGsvZmFzdC9mb3Jtcy9tZW51bGlzdC10eXBlYWhlYWQtZmluZC5odG1sCkBAIC0wLDAgKzEsNTUg QEAKKzxwPgorPHNlbGVjdCBpZD0ibWVudWxpc3QiPgorICAgIDxvcHRpb24+QXBwbGU8L29wdGlv bj4KKyAgICA8b3B0aW9uPkJhbmFuYTwvb3B0aW9uPgorICAgIDxvcHRpb24+Q2Fycm90PC9vcHRp b24+CisgICAgPG9wdGlvbj5DYXVsaWZsb3dlcjwvb3B0aW9uPgorICAgIDxvcHRpb24+Q29ybjwv b3B0aW9uPgorICAgIDxvcHRpb24+U3RhciBmaXNoPC9vcHRpb24+CisgICAgPG9wdGlvbj5TdGFy IGZydWl0PC9vcHRpb24+Cis8L3NlbGVjdD4KKzwvcD4KKzxkaXYgaWQ9InJlc3VsdCI+Q2Fubm90 IHJ1biBpbnRlcmFjdGl2ZWx5LjwvZGl2PgorCis8c2NyaXB0PgordmFyIHJlc3VsdCA9IGRvY3Vt ZW50LmdldEVsZW1lbnRCeUlkKCdyZXN1bHQnKTsKK3ZhciBtZW51bGlzdCA9IGRvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCdtZW51bGlzdCcpOworCitmdW5jdGlvbiB0ZXN0VHlwZUFoZWFkRmluZChr ZXlzLCBleHBlY3RlZE1lbnVMaXN0VGV4dCkKK3sKKyAgICBpZiAoIXdpbmRvdy5ldmVudFNlbmRl cikKKyAgICAgICAgcmV0dXJuOworCisgICAgZXZlbnRTZW5kZXIubW91c2VNb3ZlVG8obWVudWxp c3Qub2Zmc2V0TGVmdCArIChtZW51bGlzdC5vZmZzZXRXaWR0aCAvIDIpLCBtZW51bGlzdC5vZmZz ZXRUb3AgKyAobWVudWxpc3Qub2Zmc2V0SGVpZ2h0IC8gMikpOworICAgIGV2ZW50U2VuZGVyLm1v dXNlRG93bigpOworICAgIGV2ZW50U2VuZGVyLm1vdXNlVXAoKTsKKworICAgIGZvciAodmFyIGkg PSAwOyBpIDwga2V5cy5sZW5ndGg7IGkrKykKKyAgICAgICAgZXZlbnRTZW5kZXIua2V5RG93bihr ZXlzW2ldKTsKKyAgICBldmVudFNlbmRlci5rZXlEb3duKCdcbicpOworCisgICAgcmVzdWx0Lmlu bmVySFRNTCArPSAiPGJyLz4iICsgIkV4cGVjdGVkICIgKyBleHBlY3RlZE1lbnVMaXN0VGV4dCAr ICI6ICI7CisgICAgcmVzdWx0LmlubmVySFRNTCArPSAid2FzICIgKyBtZW51bGlzdC52YWx1ZTsK K30KKworaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICBsYXlvdXRUZXN0Q29u dHJvbGxlci5kdW1wQXNUZXh0KCk7CisKK3Rlc3RUeXBlQWhlYWRGaW5kKFsnYSddLCAiQXBwbGUi KTsKK3Rlc3RUeXBlQWhlYWRGaW5kKFsnYyddLCAiQ2Fycm90Iik7CisKKy8vIFRoaXMgdGVzdHMg dGhhdCBpdGVyYXRpbmcgdmlhIHByZXNzaW5nIHRoZSBzYW1lIGtleSB3b3Jrcy4KK3Rlc3RUeXBl QWhlYWRGaW5kKFsnYycsICdjJ10sICJDYXVsaWZsb3dlciIpOwordGVzdFR5cGVBaGVhZEZpbmQo WydjJywgJ2MnLCAnYyddLCAiQ29ybiIpOworCisvLyBUaGlzIHRlc3RzIHRoYXQgdGhpcyBhbHNv IHdyYXBzIGFyb3VuZCBwcm9wZXJseS4KK3Rlc3RUeXBlQWhlYWRGaW5kKFsnYycsICdjJywgJ2Mn LCAnYyddLCAiQ2Fycm90Iik7CisKKy8vIFRoaXMgdGVzdHMgdGhhdCB0eXBpbmcgbGFyZ2VyIHNl Z21lbnRzIG9mIHdvcmRzIHdvcmtzLgordGVzdFR5cGVBaGVhZEZpbmQoWydhJywgJ3AnLCAncCdd LCAiQXBwbGUiKTsKK3Rlc3RUeXBlQWhlYWRGaW5kKFsnYycsICdhJywgJ3UnXSwgIkNhdWxpZmxv d2VyIik7CisKKy8vIFRoaXMgdGVzdHMgdGhhdCBhIHNlcXVlbmNlIHdpdGggYSBzcGFjZSB3b3Jr cy4KK3Rlc3RUeXBlQWhlYWRGaW5kKFsnUycsICd0JywgJ2EnLCAncicsICcgJywgJ2YnLCAncidd LCAiU3RhciBmcnVpdCIpOworCis8L3NjcmlwdD4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdl TG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMmNiZWYwNGI4OGY1MWE5ZjM1MGVlYWYwYTQ1 M2Q1ZGI3MmE2MzQzYS4uODlhOWI5OWFiMDc2NjI3ZDVkNjIwNzY2ZWExYjBiMDNlNDQ0ZTc0NSAx MDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAg LTEsMyArMSwyNyBAQAorMjAxMC0xMS0zMCAgTWFydGluIFJvYmluc29uICA8bXJvYmluc29uQGln YWxpYS5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgW0d0a10gT3BlbiBtZW51bGlzdHMgc2hvdWxkIHN1cHBvcnQgdHlwZWFoZWFkIGZpbmQKKyAg ICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI3NDQzCisKKyAg ICAgICAgQWRkZWQgdHlwZWFoZWFkIGZpbmQgc3VwcG9ydCBmb3Igb3BlbiBHVEsrIG1lbnVsaXN0 cy4KKworICAgICAgICBUZXN0OiBwbGF0Zm9ybS9ndGsvZmFzdC9mb3Jtcy9tZW51bGlzdC10eXBl YWhlYWQtZmluZC5odG1sCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ndGsvUG9wdXBNZW51R3RrLmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OlBvcHVwTWVudUd0azo6UG9wdXBNZW51R3RrKTogSW5pdGlh bGl6ZSBuZXcgbWVtYmVycy4KKyAgICAgICAgKFdlYkNvcmU6OlBvcHVwTWVudUd0azo6c2hvdyk6 IFRyYWNrIGN1cnJlbnRseSBzZWxlY3RlZCBtZW51IGl0ZW0KKyAgICAgICAgdmlhIGEgc2lnbmFs IGhhbmRsZXIuCisgICAgICAgIChXZWJDb3JlOjpQb3B1cE1lbnVHdGs6OnR5cGVBaGVhZEZpbmQp OiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OlBvcHVwTWVudUd0azo6bWVudVVubWFwcGVkKTog UmVzZXQgdHlwZWFoZWFkIGZpbmQgc3RhdGUKKyAgICAgICAgd2hlbiBtZW51IGlzIHVubWFwcGVk LgorICAgICAgICAoV2ViQ29yZTo6UG9wdXBNZW51R3RrOjpyZXNldFR5cGVBaGVhZEZpbmRTdGF0 ZSk6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6UG9wdXBNZW51R3RrOjpzZWxlY3RJdGVtQ2Fs bGJhY2spOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OlBvcHVwTWVudUd0azo6a2V5UHJlc3NF dmVudENhbGxiYWNrKTogQWRkZWQuCisgICAgICAgICogcGxhdGZvcm0vZ3RrL1BvcHVwTWVudUd0 ay5oOiBBZGRlZCBuZXcgbWVtYmVycyB0byB0cmFjayB0eXBlYWhlYWQKKyAgICAgICAgZmluZCBz dGF0ZS4KKwogMjAxMC0xMS0yNiAgUm9iIEJ1aXMgIDxyd2xidWlzQGdtYWlsLmNvbT4KIAogICAg ICAgICBSZXZpZXdlZCBieSBTaW1vbiBGcmFzZXIuCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRm b3JtL2d0ay9Qb3B1cE1lbnVHdGsuY3BwIGIvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvUG9wdXBNZW51 R3RrLmNwcAppbmRleCBlN2ZmNzhlMGM5NTdlMmEwM2Q4YzU5NGI5N2QyZjA5NmY2NzllMDQ3Li5j ZjQzNDM4NmE4NDMxMDA3MzNmNGIyNzVhNjczYWZkNGExYzlhNjllIDEwMDY0NAotLS0gYS9XZWJD b3JlL3BsYXRmb3JtL2d0ay9Qb3B1cE1lbnVHdGsuY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0v Z3RrL1BvcHVwTWVudUd0ay5jcHAKQEAgLTUsNiArNSw3IEBACiAgKiBDb3B5cmlnaHQgKEMpIDIw MDYgTWljaGFlbCBFbW1lbCBtaWtlLmVtbWVsQGdtYWlsLmNvbQogICogQ29weXJpZ2h0IChDKSAy MDA4IENvbGxhYm9yYSBMdGQuCiAgKiBDb3B5cmlnaHQgKEMpIDIwMTAgTm9raWEgQ29ycG9yYXRp b24gYW5kL29yIGl0cyBzdWJzaWRpYXJ5KC1pZXMpLgorICogQ29weXJpZ2h0IChDKSAyMDEwIEln YWxpYSBTLkwuCiAgKgogICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4g cmVkaXN0cmlidXRlIGl0IGFuZC9vcgogICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0 aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKQEAgLTI3LDE2ICsyOCwyMiBAQAogI2luY2x1 ZGUgIlBvcHVwTWVudUd0ay5oIgogCiAjaW5jbHVkZSAiRnJhbWVWaWV3LmgiCisjaW5jbHVkZSAi R093blB0ci5oIgogI2luY2x1ZGUgIkd0a1ZlcnNpb25pbmcuaCIKICNpbmNsdWRlICJIb3N0V2lu ZG93LmgiCiAjaW5jbHVkZSAiUGxhdGZvcm1TdHJpbmcuaCIKLSNpbmNsdWRlIDx3dGYvdGV4dC9D U3RyaW5nLmg+CisjaW5jbHVkZSA8Z2RrL2dkay5oPgogI2luY2x1ZGUgPGd0ay9ndGsuaD4KKyNp bmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAorc3Rh dGljIGNvbnN0IHVpbnQzMl90IGdTZWFyY2hUaW1lb3V0TXMgPSAxMDAwOworCiBQb3B1cE1lbnVH dGs6OlBvcHVwTWVudUd0ayhQb3B1cE1lbnVDbGllbnQqIGNsaWVudCkKICAgICA6IG1fcG9wdXBD bGllbnQoY2xpZW50KQorICAgICwgbV9wcmV2aW91c0tleUV2ZW50Q2hhcmFjdGVyKDApCisgICAg LCBtX2N1cnJlbnRseVNlbGVjdGVkTWVudUl0ZW0oMCkKIHsKIH0KIApAQCAtNTQsNyArNjEsOCBA QCB2b2lkIFBvcHVwTWVudUd0azo6c2hvdyhjb25zdCBJbnRSZWN0JiByZWN0LCBGcmFtZVZpZXcq IHZpZXcsIGludCBpbmRleCkKIAogICAgIGlmICghbV9wb3B1cCkgewogICAgICAgICBtX3BvcHVw ID0gR1RLX01FTlUoZ3RrX21lbnVfbmV3KCkpOwotICAgICAgICBnX3NpZ25hbF9jb25uZWN0KG1f cG9wdXAuZ2V0KCksICJ1bm1hcCIsIEdfQ0FMTEJBQ0sobWVudVVubWFwcGVkKSwgdGhpcyk7Cisg ICAgICAgIGdfc2lnbmFsX2Nvbm5lY3QobV9wb3B1cC5nZXQoKSwgInVubWFwIiwgR19DQUxMQkFD SyhQb3B1cE1lbnVHdGs6Om1lbnVVbm1hcHBlZCksIHRoaXMpOworICAgICAgICBnX3NpZ25hbF9j b25uZWN0KG1fcG9wdXAuZ2V0KCksICJrZXktcHJlc3MtZXZlbnQiLCBHX0NBTExCQUNLKFBvcHVw TWVudUd0azo6a2V5UHJlc3NFdmVudENhbGxiYWNrKSwgdGhpcyk7CiAgICAgfSBlbHNlCiAgICAg ICAgIGd0a19jb250YWluZXJfZm9yZWFjaChHVEtfQ09OVEFJTkVSKG1fcG9wdXAuZ2V0KCkpLCBy ZWludGVycHJldF9jYXN0PEd0a0NhbGxiYWNrPihtZW51UmVtb3ZlSXRlbSksIHRoaXMpOwogCkBA IC03Myw3ICs4MSw4IEBAIHZvaWQgUG9wdXBNZW51R3RrOjpzaG93KGNvbnN0IEludFJlY3QmIHJl Y3QsIEZyYW1lVmlldyogdmlldywgaW50IGluZGV4KQogICAgICAgICAgICAgaXRlbSA9IGd0a19t ZW51X2l0ZW1fbmV3X3dpdGhfbGFiZWwoY2xpZW50KCktPml0ZW1UZXh0KGkpLnV0ZjgoKS5kYXRh KCkpOwogCiAgICAgICAgIG1faW5kZXhNYXAuYWRkKGl0ZW0sIGkpOwotICAgICAgICBnX3NpZ25h bF9jb25uZWN0KGl0ZW0sICJhY3RpdmF0ZSIsIEdfQ0FMTEJBQ0sobWVudUl0ZW1BY3RpdmF0ZWQp LCB0aGlzKTsKKyAgICAgICAgZ19zaWduYWxfY29ubmVjdChpdGVtLCAiYWN0aXZhdGUiLCBHX0NB TExCQUNLKFBvcHVwTWVudUd0azo6bWVudUl0ZW1BY3RpdmF0ZWQpLCB0aGlzKTsKKyAgICAgICAg Z19zaWduYWxfY29ubmVjdChpdGVtLCAic2VsZWN0IiwgR19DQUxMQkFDSyhQb3B1cE1lbnVHdGs6 OnNlbGVjdEl0ZW1DYWxsYmFjayksIHRoaXMpOwogCiAgICAgICAgIC8vIEZJWE1FOiBBcHBseSB0 aGUgUG9wdXBNZW51U3R5bGUgZnJvbSBjbGllbnQoKS0+aXRlbVN0eWxlKGkpCiAgICAgICAgIGd0 a193aWRnZXRfc2V0X3NlbnNpdGl2ZShpdGVtLCBjbGllbnQoKS0+aXRlbUlzRW5hYmxlZChpKSk7 CkBAIC0xMzgsNiArMTQ3LDc2IEBAIHZvaWQgUG9wdXBNZW51R3RrOjpkaXNjb25uZWN0Q2xpZW50 KCkKICAgICBtX3BvcHVwQ2xpZW50ID0gMDsKIH0KIAorYm9vbCBQb3B1cE1lbnVHdGs6OnR5cGVB aGVhZEZpbmQoR2RrRXZlbnRLZXkqIGV2ZW50KQoreworICAgIC8vIElmIHdlIHdlcmUgZ2l2ZW4g YSBub24tcHJpbnRhYmxlIGNoYXJhY3RlciBqdXN0IHNraXAgaXQuCisgICAgZ3VuaWNoYXIgdW5p Y29kZUNoYXJhY3RlciA9IGdka19rZXl2YWxfdG9fdW5pY29kZShldmVudC0+a2V5dmFsKTsKKyAg ICBpZiAoIXVuaWNvZGVDaGFyYWN0ZXIpIHsKKyAgICAgICAgcmVzZXRUeXBlQWhlYWRGaW5kU3Rh dGUoKTsKKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIH0KKworICAgIGdsb25nIGNoYXJhY3Rl cnNXcml0dGVuOworICAgIEdPd25QdHI8Z3VuaWNoYXIyPiB1dGYxNlN0cmluZyhnX3VjczRfdG9f dXRmMTYoJnVuaWNvZGVDaGFyYWN0ZXIsIDEsIDAsICZjaGFyYWN0ZXJzV3JpdHRlbiwgMCkpOwor ICAgIGlmICghdXRmMTZTdHJpbmcpIHsKKyAgICAgICAgcmVzZXRUeXBlQWhlYWRGaW5kU3RhdGUo KTsKKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIH0KKworICAgIC8vIElmIHRoZSBjaGFyYWN0 ZXIgaXMgdGhlIHNhbWUgYXMgdGhlIGxhc3QgY2hhcmFjdGVyLCB0aGUgdXNlciBpcyBwcm9iYWJs eSB0cnlpbmcgdG8KKyAgICAvLyBjeWNsZSB0aHJvdWdoIHRoZSBtZW51bGlzdCBlbnRyaWVzLgor ICAgIGJvb2wgcmVwZWF0aW5nQ2hhcmFjdGVyID0gdW5pY29kZUNoYXJhY3RlciAhPSBtX3ByZXZp b3VzS2V5RXZlbnRDaGFyYWN0ZXI7CisgICAgaWYgKGV2ZW50LT50aW1lIC0gbV9wcmV2aW91c0tl eUV2ZW50VGltZXN0YW1wID4gZ1NlYXJjaFRpbWVvdXRNcykKKyAgICAgICAgbV9jdXJyZW50U2Vh cmNoU3RyaW5nID0gU3RyaW5nKHN0YXRpY19jYXN0PFVDaGFyKj4odXRmMTZTdHJpbmcuZ2V0KCkp LCBjaGFyYWN0ZXJzV3JpdHRlbik7CisgICAgZWxzZSBpZiAocmVwZWF0aW5nQ2hhcmFjdGVyKQor ICAgICAgICBtX2N1cnJlbnRTZWFyY2hTdHJpbmcuYXBwZW5kKFN0cmluZyhzdGF0aWNfY2FzdDxV Q2hhcio+KHV0ZjE2U3RyaW5nLmdldCgpKSwgY2hhcmFjdGVyc1dyaXR0ZW4pKTsKKworICAgIG1f cHJldmlvdXNLZXlFdmVudFRpbWVzdGFtcCA9IGV2ZW50LT50aW1lOworICAgIG1fcHJldmlvdXNL ZXlFdmVudENoYXJhY3RlciA9IHVuaWNvZGVDaGFyYWN0ZXI7CisKKyAgICAvLyBMaWtlIHRoZSBD aHJvbWl1bSBwb3J0LCB3ZSBjYXNlIGZvbGQgYmVmb3JlIHNlYXJjaGluZywgYmVjYXVzZSAKKyAg ICAvLyBzdHJuY21wIGRvZXMgbm90IGhhbmRsZSBub24tQVNDSUkgY2hhcmFjdGVycy4KKyAgICBH T3duUHRyPGdjaGFyPiBzZWFyY2hTdHJpbmdXaXRoQ2FzZUZvbGRlZChnX3V0ZjhfY2FzZWZvbGQo bV9jdXJyZW50U2VhcmNoU3RyaW5nLnV0ZjgoKS5kYXRhKCksIC0xKSk7CisgICAgc2l6ZV90IHBy ZWZpeExlbmd0aCA9IHN0cmxlbihzZWFyY2hTdHJpbmdXaXRoQ2FzZUZvbGRlZC5nZXQoKSk7CisK KyAgICBHTGlzdCogY2hpbGRyZW4gPSBndGtfY29udGFpbmVyX2dldF9jaGlsZHJlbihHVEtfQ09O VEFJTkVSKG1fcG9wdXAuZ2V0KCkpKTsKKyAgICBpZiAoIWNoaWxkcmVuKQorICAgICAgICByZXR1 cm4gdHJ1ZTsKKworICAgIC8vIElmIGEgbWVudSBpdGVtIGhhcyBhbHJlYWR5IGJlZW4gc2VsZWN0 ZWQsIHN0YXJ0IHNlYXJjaGluZyBmcm9tIHRoZSBjdXJyZW50CisgICAgLy8gaXRlbSBkb3duIHRo ZSBsaXN0LiBUaGlzIHdpbGwgbWFrZSBtdWx0aXBsZSBrZXkgcHJlc3NlcyBvZiB0aGUgc2FtZSBj aGFyYWN0ZXIKKyAgICAvLyBhZHZhbmNlIHRoZSBzZWxlY3Rpb24uIFRoaXMgbWF0Y2hlcyB0aGUg V2ViQ29yZSBiZWhhdmlvciBmb3IgY29sbGFwc2VkIG1lbnVsaXN0cy4KKyAgICBHTGlzdCogY3Vy cmVudENoaWxkID0gY2hpbGRyZW47CisgICAgaWYgKG1fY3VycmVudGx5U2VsZWN0ZWRNZW51SXRl bSkgeworICAgICAgICBjdXJyZW50Q2hpbGQgPSBnX2xpc3RfZmluZChjaGlsZHJlbiwgbV9jdXJy ZW50bHlTZWxlY3RlZE1lbnVJdGVtKTsKKyAgICAgICAgaWYgKCFjdXJyZW50Q2hpbGQpIHsKKyAg ICAgICAgICAgIG1fY3VycmVudGx5U2VsZWN0ZWRNZW51SXRlbSA9IDA7CisgICAgICAgICAgICBj dXJyZW50Q2hpbGQgPSBjaGlsZHJlbjsKKyAgICAgICAgfQorCisgICAgICAgIC8vIFJlcGVhdGlu ZyBjaGFyYWN0ZXJzIHNob3VsZCBpdGVyYXRlLgorICAgICAgICBpZiAocmVwZWF0aW5nQ2hhcmFj dGVyKSB7CisgICAgICAgICAgICBpZiAoR0xpc3QqIG5leHRDaGlsZCA9IGdfbGlzdF9uZXh0KGN1 cnJlbnRDaGlsZCkpCisgICAgICAgICAgICAgICAgY3VycmVudENoaWxkID0gbmV4dENoaWxkOwor ICAgICAgICB9CisgICAgfQorCisgICAgR0xpc3QqIGZpcnN0Q2hpbGQgPSBjdXJyZW50Q2hpbGQ7 CisgICAgZG8geworICAgICAgICBjdXJyZW50Q2hpbGQgPSBnX2xpc3RfbmV4dChjdXJyZW50Q2hp bGQpOworICAgICAgICBpZiAoIWN1cnJlbnRDaGlsZCkKKyAgICAgICAgICAgIGN1cnJlbnRDaGls ZCA9IGNoaWxkcmVuOworCisgICAgICAgIEdPd25QdHI8Z2NoYXI+IGl0ZW1UZXh0KGdfdXRmOF9j YXNlZm9sZChndGtfbWVudV9pdGVtX2dldF9sYWJlbChHVEtfTUVOVV9JVEVNKGN1cnJlbnRDaGls ZC0+ZGF0YSkpLCAtMSkpOworICAgICAgICBpZiAoIXN0cm5jbXAoc2VhcmNoU3RyaW5nV2l0aENh c2VGb2xkZWQuZ2V0KCksIGl0ZW1UZXh0LmdldCgpLCBwcmVmaXhMZW5ndGgpKSB7CisgICAgICAg ICAgICBndGtfbWVudV9zaGVsbF9zZWxlY3RfaXRlbShHVEtfTUVOVV9TSEVMTChtX3BvcHVwLmdl dCgpKSwgR1RLX1dJREdFVChjdXJyZW50Q2hpbGQtPmRhdGEpKTsKKyAgICAgICAgICAgIHJldHVy biB0cnVlOworICAgICAgICB9CisgICAgfSB3aGlsZSAoY3VycmVudENoaWxkICE9IGZpcnN0Q2hp bGQpOworCisgICAgcmV0dXJuIHRydWU7Cit9CisKIHZvaWQgUG9wdXBNZW51R3RrOjptZW51SXRl bUFjdGl2YXRlZChHdGtNZW51SXRlbSogaXRlbSwgUG9wdXBNZW51R3RrKiB0aGF0KQogewogICAg IEFTU0VSVCh0aGF0LT5jbGllbnQoKSk7CkBAIC0xNDgsNiArMjI3LDcgQEAgdm9pZCBQb3B1cE1l bnVHdGs6Om1lbnVJdGVtQWN0aXZhdGVkKEd0a01lbnVJdGVtKiBpdGVtLCBQb3B1cE1lbnVHdGsq IHRoYXQpCiB2b2lkIFBvcHVwTWVudUd0azo6bWVudVVubWFwcGVkKEd0a1dpZGdldCosIFBvcHVw TWVudUd0ayogdGhhdCkKIHsKICAgICBBU1NFUlQodGhhdC0+Y2xpZW50KCkpOworICAgIHRoYXQt PnJlc2V0VHlwZUFoZWFkRmluZFN0YXRlKCk7CiAgICAgdGhhdC0+Y2xpZW50KCktPnBvcHVwRGlk SGlkZSgpOwogfQogCkBAIC0xNTgsMTEgKzIzOCwyOSBAQCB2b2lkIFBvcHVwTWVudUd0azo6bWVu dVBvc2l0aW9uRnVuY3Rpb24oR3RrTWVudSosIGdpbnQqIHgsIGdpbnQqIHksIGdib29sZWFuKiBw dQogICAgICpwdXNoSW4gPSB0cnVlOwogfQogCit2b2lkIFBvcHVwTWVudUd0azo6cmVzZXRUeXBl QWhlYWRGaW5kU3RhdGUoKQoreworICAgIG1fY3VycmVudGx5U2VsZWN0ZWRNZW51SXRlbSA9IDA7 CisgICAgbV9wcmV2aW91c0tleUV2ZW50Q2hhcmFjdGVyID0gMDsKKyAgICBtX2N1cnJlbnRTZWFy Y2hTdHJpbmcgPSAiIjsKK30KKwogdm9pZCBQb3B1cE1lbnVHdGs6Om1lbnVSZW1vdmVJdGVtKEd0 a1dpZGdldCogd2lkZ2V0LCBQb3B1cE1lbnVHdGsqIHRoYXQpCiB7CiAgICAgQVNTRVJUKHRoYXQt Pm1fcG9wdXApOwogICAgIGd0a19jb250YWluZXJfcmVtb3ZlKEdUS19DT05UQUlORVIodGhhdC0+ bV9wb3B1cC5nZXQoKSksIHdpZGdldCk7CiB9CiAKK2ludCBQb3B1cE1lbnVHdGs6OnNlbGVjdEl0 ZW1DYWxsYmFjayhHdGtNZW51SXRlbSogaXRlbSwgUG9wdXBNZW51R3RrKiB0aGF0KQoreworICAg IHRoYXQtPm1fY3VycmVudGx5U2VsZWN0ZWRNZW51SXRlbSA9IEdUS19XSURHRVQoaXRlbSk7Cisg ICAgcmV0dXJuIEZBTFNFOworfQorCitpbnQgUG9wdXBNZW51R3RrOjprZXlQcmVzc0V2ZW50Q2Fs bGJhY2soR3RrV2lkZ2V0KiB3aWRnZXQsIEdka0V2ZW50S2V5KiBldmVudCwgUG9wdXBNZW51R3Rr KiB0aGF0KQoreworICAgIHJldHVybiB0aGF0LT50eXBlQWhlYWRGaW5kKGV2ZW50KTsKK30KKwog fQogCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9Qb3B1cE1lbnVHdGsuaCBiL1dl YkNvcmUvcGxhdGZvcm0vZ3RrL1BvcHVwTWVudUd0ay5oCmluZGV4IDg4NDhlMDZlODdiZWVkZGNj YzdhYzFjNzIxNWUyYjQwYjM2NzEwNzUuLmU0N2ZkYTY0YjllYzFmZGFlMDE0MTIxNTMyMTQ4NWVh ODRlYjk5YmMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1BvcHVwTWVudUd0ay5o CisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1BvcHVwTWVudUd0ay5oCkBAIC0yNCwxMSArMjQs MTIgQEAKICNpbmNsdWRlICJJbnRSZWN0LmgiCiAjaW5jbHVkZSAiUG9wdXBNZW51LmgiCiAjaW5j bHVkZSAiUG9wdXBNZW51Q2xpZW50LmgiCi0jaW5jbHVkZSA8Z2xpYi5oPgogI2luY2x1ZGUgPHd0 Zi9IYXNoTWFwLmg+CiAjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KICNpbmNsdWRlIDx3dGYv UmVmQ291bnRlZC5oPgogCit0eXBlZGVmIHN0cnVjdCBfR2RrRXZlbnRLZXkgR2RrRXZlbnRLZXk7 CisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgRnJhbWVWaWV3OwpAQCAtNDMsMTkgKzQ0 LDI3IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgaGlkZSgpOwogICAgIHZpcnR1YWwgdm9p ZCB1cGRhdGVGcm9tRWxlbWVudCgpOwogICAgIHZpcnR1YWwgdm9pZCBkaXNjb25uZWN0Q2xpZW50 KCk7CisgICAgYm9vbCB0eXBlQWhlYWRGaW5kKEdka0V2ZW50S2V5Kik7CiAKIHByaXZhdGU6CiAg ICAgUG9wdXBNZW51Q2xpZW50KiBjbGllbnQoKSBjb25zdCB7IHJldHVybiBtX3BvcHVwQ2xpZW50 OyB9CisgICAgdm9pZCByZXNldFR5cGVBaGVhZEZpbmRTdGF0ZSgpOwogCiAgICAgc3RhdGljIHZv aWQgbWVudUl0ZW1BY3RpdmF0ZWQoR3RrTWVudUl0ZW0qIGl0ZW0sIFBvcHVwTWVudUd0ayopOwog ICAgIHN0YXRpYyB2b2lkIG1lbnVVbm1hcHBlZChHdGtXaWRnZXQqLCBQb3B1cE1lbnVHdGsqKTsK ICAgICBzdGF0aWMgdm9pZCBtZW51UG9zaXRpb25GdW5jdGlvbihHdGtNZW51KiwgZ2ludCosIGdp bnQqLCBnYm9vbGVhbiosIFBvcHVwTWVudUd0ayopOwogICAgIHN0YXRpYyB2b2lkIG1lbnVSZW1v dmVJdGVtKEd0a1dpZGdldCosIFBvcHVwTWVudUd0ayopOworICAgIHN0YXRpYyBpbnQgc2VsZWN0 SXRlbUNhbGxiYWNrKEd0a01lbnVJdGVtKiwgUG9wdXBNZW51R3RrKik7CisgICAgc3RhdGljIGlu dCBrZXlQcmVzc0V2ZW50Q2FsbGJhY2soR3RrV2lkZ2V0KiwgR2RrRXZlbnRLZXkqLCBQb3B1cE1l bnVHdGsqKTsKIAogICAgIFBvcHVwTWVudUNsaWVudCogbV9wb3B1cENsaWVudDsKICAgICBJbnRQ b2ludCBtX21lbnVQb3NpdGlvbjsKICAgICBQbGF0Zm9ybVJlZlB0cjxHdGtNZW51PiBtX3BvcHVw OwogICAgIEhhc2hNYXA8R3RrV2lkZ2V0KiwgaW50PiBtX2luZGV4TWFwOworICAgIFN0cmluZyBt X2N1cnJlbnRTZWFyY2hTdHJpbmc7CisgICAgdWludDMyX3QgbV9wcmV2aW91c0tleUV2ZW50VGlt ZXN0YW1wOworICAgIHVuc2lnbmVkIGludCBtX3ByZXZpb3VzS2V5RXZlbnRDaGFyYWN0ZXI7Cisg ICAgR3RrV2lkZ2V0KiBtX2N1cnJlbnRseVNlbGVjdGVkTWVudUl0ZW07CiB9OwogCiB9Cg==