11839 2006-12-15 04:20:21 -0800 Webarchive fails to save CSS files in @import statements 2008-11-25 14:04:09 -0800 1 1 1 Unclassified WebKit WebKit Misc. 420+ Mac OS X 10.4 RESOLVED FIXED InRadar P2 Normal --- 1 ddkilzer ddkilzer beidson darin mitz oldest_to_newest 41904 0 ddkilzer 2006-12-15 04:20:21 -0800 Summary: When saving a page in the webarchive format, CSS files appearing in @import statements are not saved, while CSS files in <link rel="stylesheet> tags are saved. CSS files appearing in @import statements should also be saved. Steps to reproduce: 1. Open a test page with an @import statement in Safari. (Will post one to this bug shortly.) 2. Save the page as a webarchive named: test.webarchive. 3. Open test.webarchive in the Property List Editor application. 4. Review the list of WebSubresources saved in the file. Expected results: The CSS file linked in the @import statement should be included in the webarchive as a WebSubresource. Actual results: The CSS file linked in the @import statement is not included in the webarchive as a WebSubresource. Regression: Same bug occurs in Safari 2.0.4 (419.3) on Mac OS X 10.4.8 (8L127). Notes: The "Activity Window" in Safari lists CSS files from both <link rel="stylesheet"> tags and @import statements. If this list is kept in the WebKit framework (as opposed to Safari), perhaps it should be used when outputting a webarchive instead. 41907 1 11858 ddkilzer 2006-12-15 04:39:46 -0800 Created attachment 11858 Test files in zip archive 1. Download zip file. 2. Unzip into directory. 3. Open bug-11839-test.html. 4. Save as webarchive. 5. View in Property List Editor. 41908 2 11859 ddkilzer 2006-12-15 04:40:41 -0800 Created attachment 11859 Example webarchive missing @import stylesheet 41913 3 ddkilzer 2006-12-15 08:00:15 -0800 I have a patch to fix this, but I need to clean it up and get recursion working (since a stylesheet referenced by @import may include other stylesheets, or--worse--link back to its parent). 41699 4 11878 ddkilzer 2006-12-16 05:49:42 -0800 Created attachment 11878 Test files in zip archive v2 These test files include recursive @import statements. 41700 5 11879 ddkilzer 2006-12-16 05:53:04 -0800 Created attachment 11879 Fixed webarchive for test v2 41702 6 11881 ddkilzer 2006-12-16 06:54:13 -0800 Created attachment 11881 Test files in zip archive v3 Also tests reading @import statements from stylesheets defined in <link> tags. 41703 7 11882 ddkilzer 2006-12-16 06:55:09 -0800 Created attachment 11882 Fixed webarchive for test v3 41704 8 11883 ddkilzer 2006-12-16 07:03:01 -0800 Created attachment 11883 Patch v1 Reviews list of CSS rules for each stylesheet defined in a web page (via <link> or <style>) and adds @import urls to the list of urls to save when creating a .webarchive file. 41706 9 11883 ddkilzer 2006-12-16 07:12:25 -0800 Comment on attachment 11883 Patch v1 >++ (void)_readCSSRulesRecursively:(DOMCSSStyleSheet *)sheet withURLs:(NSMutableArray *)URLs withDOMDocument:(DOMDocument *)document >+{ >+ DOMCSSRuleList *rules = [sheet cssRules]; >+ for (int i = 0, max = [rules length]; i < max; i++) { >+ DOMCSSRule *rule = [rules item:i]; >+ if ([rule type] == DOM_IMPORT_RULE) { >+ DOMCSSImportRule *importRule = (DOMCSSImportRule *) rule; >+ NSString *string = [importRule href]; >+ if ([string length] > 0) { >+ NSURL *newURL = [document URLWithAttributeString:string]; >+ if (![URLs containsObject:newURL]) { >+ [URLs addObject:newURL]; >+ [DOMHTMLStyleElement _readCSSRulesRecursively:[importRule styleSheet] withURLs:URLs withDOMDocument:document]; >+ } >+ } >+ } >+ } >+} Strictly speaking, the check for "if (![URLs containsObject:newURL])" here is not necessary to prevent recursion, only to prevent duplicate copies of the same resource being added twice. (The DOMCSSImportRule that refers to the duplicate stylesheet URL returns nil for the styleSheet call, which ends up falling through in the next recursion.) If this code is removed, the first recursed stylesheet will appear twice in the .webarchive file. This is not a big deal, since it already happens with images (see Bug 7266), and will be fixed when that bug is fixed. I wasn't sure whether I should rely on the CSS parser not creating recursive references when building DOMCSSImportRule objects in the future, though. 41708 10 11883 mitz 2006-12-16 07:58:13 -0800 Comment on attachment 11883 Patch v1 I can't review this, but here are a few observations and a question :-) I don't think it's very elegant to do the following also for rel="icon" (although it doesn't do any harm): + DOMCSSStyleSheet *sheet = (DOMCSSStyleSheet *)[self sheet]; + [DOMHTMLStyleElement _readCSSRulesRecursively:sheet withURLs:URLs withDOMDocument:[self ownerDocument]]; Extra space before 'rule': + DOMCSSImportRule *importRule = (DOMCSSImportRule *) rule; Since length is unsigned, this should be just 'if ([string length])': + if ([string length] > 0) { Regarding this method: ++ (void)_readCSSRulesRecursively:(DOMCSSStyleSheet *)sheet withURLs:(NSMutableArray *)URLs withDOMDocument:(DOMDocument *)document; I don't think its name describes what it does or the arguments' roles very well. Have you considered, instead of a DOMHTMLStyleElement class method, a DOMCSSStyleSheet (WebPrivate) instance method? Say, -(void)_recursivelyAddSubresourceURLsToArray:(NSMutableArray *)URLs withDOMDocument:(DOMDocument *)document; 41412 11 11898 ddkilzer 2006-12-17 19:24:07 -0800 Created attachment 11898 Patch v2 Addresses feedback in Comment #10. Thanks for the pre-review Mitz! 41171 12 11898 darin 2006-12-19 07:48:01 -0800 Comment on attachment 11898 Patch v2 The future direction for this code is: 1) to be converted to C++ and moved to WebCore 2) to eschew recursive algorithms and use iterative algorithms with data for context rather than using the processor stack 3) to never do an operation like containsObject: on an array, since that's O(n) -- we need to use sets instead in cases like that Regarding the word "Private" in WebKit, that's used to mean "for possible use internally in OS X". The word "Internal" means "to be used only inside WebKit". Thus these categories should be using the word Internal, not Private. We need a way to do automated tests of this code. Anyway, r=me 41027 13 11898 ddkilzer 2006-12-19 11:08:58 -0800 Comment on attachment 11898 Patch v2 Clearing review flag. I want to fix some of the issues raised in Comment #12, specifically item #2 (recursion vs. iteration), item #3 (containsObject: on NSArray) and the Internal vs. Private issue. The choice to "reuse" the NSMutableArray and call containsObject: on it was a conscious one. I felt that most web pages would have a relatively small number of total stylesheets included in a hierarchical fashion (on the order of 10), and that the performance benefit from creating another data structure just for bookkeeping of duplicates was "worse" than performing a containsObject: on an existing data structure with such a small number of objects. (I considered this "premature optimization".) However, I don't have any basis for the "average" number of hierarchically included stylesheets per web page on the Internet (other than personal experience), and I didn't test the performance difference between running containsObject: on an NSArray with 10+ objects and an NSSet with 10+ objects to measure the performance drop-off. 41029 14 ddkilzer 2006-12-19 11:15:07 -0800 Will rework Patch v2 to address comments in Comment #12. 41034 15 darin 2006-12-19 11:20:23 -0800 (In reply to comment #13) > The choice to "reuse" the NSMutableArray and call containsObject: on it was a > conscious one. I felt that most web pages would have a relatively small number > of total stylesheets included in a hierarchical fashion (on the order of 10), > and that the performance benefit from creating another data structure just for > bookkeeping of duplicates was "worse" than performing a containsObject: on an > existing data structure with such a small number of objects. (I considered > this "premature optimization".) Here's my thinking on this: Generally, when dealing with things decided by page authors, we should be prepared for unusually large data sets, even if most pages wouldn't have them. Thus we need to cultivate habits of using associative data structures rather than vectors or arrays, even if the vector or array is faster for the normal case. It's different if the size of the data structure is somehow controlled by WebKit -- when it's part of the web page we have to assume it could be pathologically large in some cases. I'd really like to see this code in C++ rather than Objective-C and using HashSet instead of NSSet. Adding more Objective-C just means more code to translate later. 41061 16 ddkilzer 2006-12-19 14:09:14 -0800 (In reply to comment #15) > I'd really like to see this code in C++ rather than Objective-C and using > HashSet instead of NSSet. Adding more Objective-C just means more code to > translate later. I'm going to ask a really dumb question or two. Could you define the scope of "this code"? Is it everything in the WebKit/DOM directory, or are you talking about the code the creates the .webarchive files? Also, since some of this code is "Private", will the current Objective-C interface need to be preserved? 41072 17 darin 2006-12-19 15:43:05 -0800 (In reply to comment #16) > Could you define the scope of "this code"? Is it everything in the WebKit/DOM > directory, or are you talking about the code the creates the .webarchive files? I was specifically talking about the guts of the archiving code. As we did with the frame loader, the logic about what goes into an archive should be cross-platform C++ code. In the context of this patch, I was thinking that at least the code that gathers up all the URLs should be in C++. I now see that's expressed in the form of "DOM operations". I think those operations should probably be done in C++ and wrapped in Objective-C as needed. Two reasons we'd need to wrap would be: 1) legacy uses outside WebKit, 2) uses inside WebKit, some of which we could eliminate over time. > Also, since some of this code is "Private", will the current Objective-C > interface need to be preserved? The answer there is "I don't know". We need to preserve SPI/Private stuff if it's being used, and if it's not we can usually get away with making it internal. I don't know exactly what's being used at the moment; it's possible Mail uses some of this. This is a powerful argument against adding any more SPI/Private stuff unless it's actually needed. 27628 18 12925 ddkilzer 2007-02-04 18:11:39 -0800 Created attachment 12925 Patch v3 (In reply to comment #13) > Clearing review flag. I want to fix some of the issues raised in Comment #12, > specifically item #2 (recursion vs. iteration), item #3 (containsObject: on > NSArray) and the Internal vs. Private issue. Changes since Patch v2: - Added layout test thanks to Bug 11882. - Switched algorithm from recursion to iteration. - Changed to call containsObject: on an NSMutableSet instead of an NSMutableArray (at the cost of allocating another data structure). - No longer modify the DOMNode _URLsFromSelectors: SPI. - Switched Private API added (DOMCSSStyleSheet _recursivelyAddSubresourceURLsToArray:withDOMDocument:) to Internal API (DOMCSSStyleSheet _addSubresourceURLsToArray:withBaseURL:). - Fixed bug when referencing CSS stylesheets outside the current URL "directory" of the page that was being archived. 27633 19 12925 darin 2007-02-04 18:40:40 -0800 Comment on attachment 12925 Patch v3 + NSMutableSet *URLList = [NSMutableSet setWithCapacity:[URLs count]]; + [URLList addObjectsFromArray:URLs]; +[NSMutableSet setWithArray:] will do the same thing in one line. + NSMutableArray *sheetList = [NSMutableArray arrayWithCapacity:1]; + [sheetList addObject:self]; +[NSMutableArray arrayWithObject:] will do the same thing in one line. + NSMutableArray *baseURLList = [NSMutableArray arrayWithCapacity:1]; + [baseURLList addObject:URL]; Ditto. + DOMCSSStyleSheet *sheet = [sheetList objectAtIndex:0]; + [sheetList removeObjectAtIndex:0]; It's unnecessarily inefficient to keep removing the first object from an array. This will be slow if the array is large. I think it might scale better if these style sheets were in a set rather than an array since the order doesn't matter. We could store the base URLs in a dictionary. For common cases this would be slower, but it would have better worst-case behavior. + NSURL *importedStylesheetURL = [[NSURL URLWithString:importedStylesheetURLString relativeToURL:baseURL] absoluteURL]; We can get slightly better efficiency here by using initWithString: instead of URLWithString: and manually releasing the URL. Our rule of thumb is that we try not to rely on autorelease except when it's required because of a return value. + [URLs setArray:[URLList allObjects]]; Shouldn't this be addObjectsFromArray: instead? Should we be sorting the list? Another idea is to write the logic of this entire function in C++, with conversion on entry and exit. Something like this: void addSubresourceURLs(CSSStyleSheet*, const KURL& baseURL, Vector<KURL>&); That would be more forward looking, since we hope to some day have this web archiving code be cross-platform. + NSURL *stylesheetURL = [[self _URLsFromSelectors:@selector(href), nil] objectAtIndex:0]; Why is it OK to look only at the first URL? + NSMutableArray *URLs = [NSMutableArray arrayWithCapacity:1]; + [URLs addObject:stylesheetURL]; Again. r=me 27393 20 ddkilzer 2007-02-05 11:32:48 -0800 (In reply to comment #19) > (From update of attachment 12925 [edit]) > + NSMutableSet *URLList = [NSMutableSet setWithCapacity:[URLs count]]; > + [URLList addObjectsFromArray:URLs]; > [NSMutableSet setWithArray:] will do the same thing in one line. Obviously I need to better-familiarize myself with the Foundation collection classes. > + DOMCSSStyleSheet *sheet = [sheetList objectAtIndex:0]; > + [sheetList removeObjectAtIndex:0]; > > It's unnecessarily inefficient to keep removing the first object from an array. > This will be slow if the array is large. I think it might scale better if these > style sheets were in a set rather than an array since the order doesn't matter. > We could store the base URLs in a dictionary. For common cases this would be > slower, but it would have better worst-case behavior. Foundation classes are missing an ordered set class (like Java's HashTreeSet). I need to test this change, but my initial concern about using an unordered set is that it would produce unpredictable results in the test output. I'll give it a try, though. > + NSURL *importedStylesheetURL = [[NSURL > URLWithString:importedStylesheetURLString relativeToURL:baseURL] absoluteURL]; > > We can get slightly better efficiency here by using initWithString: instead of > URLWithString: and manually releasing the URL. Our rule of thumb is that we try > not to rely on autorelease except when it's required because of a return value. Okay. > + [URLs setArray:[URLList allObjects]]; > > Shouldn't this be addObjectsFromArray: instead? Should we be sorting the list? The URLList gets everything in URLs at the top of the method, so I thought it would be more efficiently to simply blast everything in URLList back into URLs when finished. Is this not the case? I'm missing insight into the Foundation classes. > Another idea is to write the logic of this entire function in C++, with > conversion on entry and exit. Something like this: > > void addSubresourceURLs(CSSStyleSheet*, const KURL& baseURL, > Vector<KURL>&); > > That would be more forward looking, since we hope to some day have this web > archiving code be cross-platform. I'll see what I can do. I'd rather get the bug fixed before the Wednesday cut-off, though. > + NSURL *stylesheetURL = [[self _URLsFromSelectors:@selector(href), nil] > objectAtIndex:0]; > > Why is it OK to look only at the first URL? Because a <style> tag has only one 'href' attribute, thus that method call will only ever return one URL. 27313 21 12925 ddkilzer 2007-02-05 11:33:37 -0800 Comment on attachment 12925 Patch v3 Clearing darin's r+ flag per Comment #20. 27316 22 darin 2007-02-05 11:49:45 -0800 (In reply to comment #20) > Foundation classes are missing an ordered set class (like Java's HashTreeSet). For what it's worth, WTF now has this. It's called ListHashSet. We also use Vector/HashSet pairs when we don't need removal. > I need to test this change, but my initial concern about using an unordered set > is that it would produce unpredictable results in the test output. I'll give > it a try, though. If you're concerned about unpredictable results in the test output, then I think the use of a set for URLList is also a problem. I suggest sorting the final list to make the results predictable. > > + [URLs setArray:[URLList allObjects]]; > > > > Shouldn't this be addObjectsFromArray: instead? Should we be sorting the list? > > The URLList gets everything in URLs at the top of the method, so I thought it > would be more efficiently to simply blast everything in URLList back into URLs > when finished. Is this not the case? I'm missing insight into the Foundation > classes. I didn't notice that URLList starts out as URLs at the top of the method. I think we need sorting for the reason you mention above. Perhaps the caller could handle this. > > + NSURL *stylesheetURL = [[self _URLsFromSelectors:@selector(href), nil] > > objectAtIndex:0]; > > > > Why is it OK to look only at the first URL? > > Because a <style> tag has only one 'href' attribute, thus that method call will > only ever return one URL. Perhaps we need to assert that. Can _URLsFromSelectors possibly return an empty array? If so, then objectAtIndex:0 is going to raise an Objective-C exception. 76190 23 beidson 2008-04-02 15:19:31 -0700 Patch is a great start - but this code is all in WebCore now. I'm working on converting it to "The New Math™" 76191 24 12925 beidson 2008-04-02 15:19:57 -0700 Comment on attachment 12925 Patch v3 r-, simply because it's obsolete. I'm working on changing it over 76208 25 ap 2008-04-02 22:28:39 -0700 <rdar://problem/5838347> 76209 26 beidson 2008-04-02 22:58:28 -0700 Landed a WebCore-ified version of the patch along with the layout test in r31578 76261 27 ddkilzer 2008-04-03 13:32:54 -0700 (In reply to comment #12) > (From update of attachment 11898 [edit]) > The future direction for this code is: > > 1) to be converted to C++ and moved to WebCore > 2) to eschew recursive algorithms and use iterative algorithms with data > for context rather than using the processor stack [...] I'm disappointed that r31578 switched back to a recursive algorithm after I spent time making an iterative one in Attachment #12925. :( http://trac.webkit.org/projects/webkit/changeset/31578 76264 28 beidson 2008-04-03 13:51:18 -0700 Why? :) 76268 29 ddkilzer 2008-04-03 14:15:30 -0700 (In reply to comment #28) > Why? :) Universal entropy increased. :) 100281 30 ddkilzer 2008-11-25 14:04:09 -0800 (In reply to comment #27) > (In reply to comment #12) > > (From update of attachment 11898 [review] [edit]) > > The future direction for this code is: > > > > 1) to be converted to C++ and moved to WebCore > > 2) to eschew recursive algorithms and use iterative algorithms with data > > for context rather than using the processor stack > > [...] > > I'm disappointed that r31578 switched back to a recursive algorithm after I > spent time making an iterative one in Attachment #12925 [review]. :( > > http://trac.webkit.org/projects/webkit/changeset/31578 See Bug 11850 Comment #1 for a fix. 11858 2006-12-15 04:39:46 -0800 2006-12-16 05:49:42 -0800 Test files in zip archive bug-11839-test.zip application/zip 668 ddkilzer UEsDBAoAAgAAAKIujzV5vKyUEwAAABMAAAAUABUAYnVnLTExODM5LWltcG9ydC5jc3NVVAkAA5+M gkXZkoJFVXgEAPUB9QFwIHsgY29sb3I6IGJsdWU7IH0KUEsDBAoAAgAAACwyjzU68IcRFQAAABUA AAASABUAYnVnLTExODM5LWxpbmsuY3NzVVQJAANUkoJF2ZKCRVV4BAD1AfUBc3BhbiB7IGNvbG9y OiByZWQ7IH0KUEsDBBQAAgAIACgyjzWibor0ogAAAAUBAAATABUAYnVnLTExODM5LXRlc3QuaHRt bFVUCQADTJKCRdmSgkVVeAQA9QH1AW2PwQ6CMAyG7z5F3QU9jIV40QjEh/AFmKuOWGDZukTe3g1I vHhq+/fv17a2PFC7qy12JgXqxzd4pEYEngmDRWQB1uOzETq+ZFWdTxeZXeUjBAE8O2wE44dVrhNh mfuj76WEWz+4yTNET4fih1vVDCyOV5AyudWCycl2mJ7MnIJr77YPkMEQ7BTJgEbQFLGslcvrXTf+ 9Xg0ybK0E3XDqfX7L1BLAQIXAwoAAgAAAKIujzV5vKyUEwAAABMAAAAUAA0AAAAAAAEAAACkgQAA AABidWctMTE4MzktaW1wb3J0LmNzc1VUBQADn4yCRVV4AABQSwECFwMKAAIAAAAsMo81OvCHERUA AAAVAAAAEgANAAAAAAABAAAApIFaAAAAYnVnLTExODM5LWxpbmsuY3NzVVQFAANUkoJFVXgAAFBL AQIXAxQAAgAIACgyjzWibor0ogAAAAUBAAATAA0AAAAAAAEAAACkgbQAAABidWctMTE4MzktdGVz dC5odG1sVVQFAANMkoJFVXgAAFBLBQYAAAAAAwADAOoAAACcAQAAAAA= 11859 2006-12-15 04:40:41 -0800 2006-12-15 04:40:41 -0800 Example webarchive missing @import stylesheet bug-11839-test.webarchive application/x-webarchive 1104 ddkilzer YnBsaXN0MDDSAQIDDV8QD1dlYlN1YnJlc291cmNlc18QD1dlYk1haW5SZXNvdXJjZaEE1AUGBwgJ CgsMXxATV2ViUmVzb3VyY2VSZXNwb25zZV8QD1dlYlJlc291cmNlRGF0YV5XZWJSZXNvdXJjZVVS TF8QE1dlYlJlc291cmNlTUlNRVR5cGVPEQG9YnBsaXN0MDDUAQIDBAUGBwpZJGFyY2hpdmVyWCR2 ZXJzaW9uVCR0b3BYJG9iamVjdHNfEA9OU0tleWVkQXJjaGl2ZXISAAGGoNEICV8QE1dlYlJlc291 cmNlUmVzcG9uc2WAAacLDBshIikqVSRudWxs1w0ODxAREhMUFRYXGBkaUiQyUiQzUiQ0UiQwViRj bGFzc1IkNVIkMYAFgAAQFRAHgAYjf+////////+AAtMcHREVHyBXTlMuYmFzZVtOUy5yZWxhdGl2 ZYAAgAOABF8QHmZpbGU6Ly8vdG1wL2J1Zy0xMTgzOS1saW5rLmNzc9IjJCUmWCRjbGFzc2VzWiRj bGFzc25hbWWjJicoVU5TVVJMViVOU1VSTFhOU09iamVjdFh0ZXh0L2Nzc9IjJCssoiwoXU5TVVJM UmVzcG9uc2UACAARABsAJAApADIARABJAEwAYgBkAGwAcgCBAIQAhwCKAI0AlACXAJoAnACeAKAA ogCkAK0ArwC2AL4AygDMAM4A0ADxAPYA/wEKAQ4BFAEbASQBLQEyATUAAAAAAAACAQAAAAAAAAAt AAAAAAAAAAAAAAAAAAABQ08QFXNwYW4geyBjb2xvcjogcmVkOyB9Cl8QHmZpbGU6Ly8vdG1wL2J1 Zy0xMTgzOS1saW5rLmNzc1h0ZXh0L2Nzc9UIBg4PBxAREhMUXxAbV2ViUmVzb3VyY2VUZXh0RW5j b2RpbmdOYW1lXxAUV2ViUmVzb3VyY2VGcmFtZU5hbWVZdGV4dC9odG1sTxEBAzxodG1sPjxoZWFk Pgo8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImJ1Zy0xMTgzOS1saW5rLmNzcyIgdHlwZT0i dGV4dC9jc3MiPgo8c3R5bGUgdHlwZT0idGV4dC9jc3MiPgo8IS0tIEBpbXBvcnQgdXJsKCdidWct MTE4MzktaW1wb3J0LmNzcycpOyAtLT4KPC9zdHlsZT4KPC9oZWFkPjxib2R5Pgo8cD5UaGlzIHRl eHQgc2hvdWxkIGJlIGJsdWUuPC9wPgo8c3Bhbj5UaGlzIHRleHQgc2hvdWxkIGJlIHJlZC48L3Nw YW4+CgoKPC9ib2R5PjwvaHRtbD5VVVRGLThQXxAfZmlsZTovLy90bXAvYnVnLTExODM5LXRlc3Qu aHRtbAAIAA0AHwAxADMAPABSAGQAcwCJAkoCYgKDAowClwK1AswC1gPdA+MD5AAAAAAAAAIBAAAA AAAAABUAAAAAAAAAAAAAAAAAAAQG 11878 2006-12-16 05:49:42 -0800 2006-12-16 06:54:13 -0800 Test files in zip archive v2 bug-11839-test-2.zip application/zip 947 ddkilzer UEsDBBQAAgAIAFIykDWT0euYOQAAADsAAAAcABUAYnVnLTExODM5LWltcG9ydC1yZWN1cnNlLmNz c1VUCQADHOSDRYvmg0VVeAQA9QH1AXPIzC3ILypRKC3K0VBPKk3XNTS0MLbUhYjqJRcXq2tac6Vk lilUKyTn5+QXWSmkF6Wm5lkr1HIBAFBLAwQUAAIACAA4LZA1u2qqIz4AAABAAAAAFAAVAGJ1Zy0x MTgzOS1pbXBvcnQuY3NzVVQJAAN824NFi+aDRVV4BAD1AfUBc8jMLcgvKlEoLcrRUE8qTdc1NLQw ttSFiOoWpSaXFhWn6iUXF6trWnMVKFQrJOfn5BdZKSTllKZaK9RyAQBQSwMECgACAAAALDKPNTrw hxEVAAAAFQAAABIAFQBidWctMTE4MzktbGluay5jc3NVVAkAA1SSgkWL5oNFVXgEAPUB9QFzcGFu IHsgY29sb3I6IHJlZDsgfQpQSwMEFAACAAgAuiyQNd5CLmCvAAAAKwEAABMAFQBidWctMTE4Mzkt dGVzdC5odG1sVVQJAAOP2oNFiuaDRVV4BAD1AfUBbZBNDsIgEEb3PcXIprqgpHGjkTYewgsUGQuR toQfY28vtE3cdDUw83jfBK7CYNqCK+xkKkaPb3BoGuLDbNArxEBAOXw1RMSe1vXlfKWZqp7eEwiz xYYE/AaW78mwvNvpHyiFux7s5AJEZ47lX7d2s7A83YDSRLNFkw/bYmKScyq2fSjtIYvBqykaCQJB mIgVZzbH227cZRzKhCzjgkv92YV6hzgmLM9T9hbK1j/6AVBLAQIXAxQAAgAIAFIykDWT0euYOQAA ADsAAAAcAA0AAAAAAAEAAACkgQAAAABidWctMTE4MzktaW1wb3J0LXJlY3Vyc2UuY3NzVVQFAAMc 5INFVXgAAFBLAQIXAxQAAgAIADgtkDW7aqojPgAAAEAAAAAUAA0AAAAAAAEAAACkgYgAAABidWct MTE4MzktaW1wb3J0LmNzc1VUBQADfNuDRVV4AABQSwECFwMKAAIAAAAsMo81OvCHERUAAAAVAAAA EgANAAAAAAABAAAApIENAQAAYnVnLTExODM5LWxpbmsuY3NzVVQFAANUkoJFVXgAAFBLAQIXAxQA AgAIALoskDXeQi5grwAAACsBAAATAA0AAAAAAAEAAACkgWcBAABidWctMTE4MzktdGVzdC5odG1s VVQFAAOP2oNFVXgAAFBLBQYAAAAABAAEAEEBAABcAgAAAAA= 11879 2006-12-16 05:53:04 -0800 2006-12-16 06:55:09 -0800 Fixed webarchive for test v2 bug-11839-test-2-fixed.webarchive application/x-webarchive 2295 ddkilzer YnBsaXN0MDDSAQIDFV8QD1dlYlN1YnJlc291cmNlc18QD1dlYk1haW5SZXNvdXJjZaMEDRHUBQYH CAkKCwxfEBNXZWJSZXNvdXJjZVJlc3BvbnNlXxAPV2ViUmVzb3VyY2VEYXRhXldlYlJlc291cmNl VVJMXxATV2ViUmVzb3VyY2VNSU1FVHlwZU8RAb1icGxpc3QwMNQBAgMEBQYHClkkYXJjaGl2ZXJY JHZlcnNpb25UJHRvcFgkb2JqZWN0c18QD05TS2V5ZWRBcmNoaXZlchIAAYag0QgJXxATV2ViUmVz b3VyY2VSZXNwb25zZYABpwsMGyEiKSpVJG51bGzXDQ4PEBESExQVFhcYGRpSJDJSJDNSJDRSJDBW JGNsYXNzUiQ1UiQxgAWAABAVEAeABiN/7////////4AC0xwdERUfIFdOUy5iYXNlW05TLnJlbGF0 aXZlgACAA4AEXxAeZmlsZTovLy90bXAvYnVnLTExODM5LWxpbmsuY3Nz0iMkJSZYJGNsYXNzZXNa JGNsYXNzbmFtZaMmJyhVTlNVUkxWJU5TVVJMWE5TT2JqZWN0WHRleHQvY3Nz0iMkKyyiLChdTlNV UkxSZXNwb25zZQAIABEAGwAkACkAMgBEAEkATABiAGQAbAByAIEAhACHAIoAjQCUAJcAmgCcAJ4A oACiAKQArQCvALYAvgDKAMwAzgDQAPEA9gD/AQoBDgEUARsBJAEtATIBNQAAAAAAAAIBAAAAAAAA AC0AAAAAAAAAAAAAAAAAAAFDTxAVc3BhbiB7IGNvbG9yOiByZWQ7IH0KXxAeZmlsZTovLy90bXAv YnVnLTExODM5LWxpbmsuY3NzWHRleHQvY3Nz1AUGBwgODxAMTxEBv2JwbGlzdDAw1AECAwQFBgcK WSRhcmNoaXZlclgkdmVyc2lvblQkdG9wWCRvYmplY3RzXxAPTlNLZXllZEFyY2hpdmVyEgABhqDR CAlfEBNXZWJSZXNvdXJjZVJlc3BvbnNlgAGnCwwbISIpKlUkbnVsbNcNDg8QERITFBUWFxgZGlIk MlIkM1IkNFIkMFYkY2xhc3NSJDVSJDGABYAAEEAQB4AGI3/v////////gALTHB0RFR8gV05TLmJh c2VbTlMucmVsYXRpdmWAAIADgARfECBmaWxlOi8vL3RtcC9idWctMTE4MzktaW1wb3J0LmNzc9Ij JCUmWCRjbGFzc2VzWiRjbGFzc25hbWWjJicoVU5TVVJMViVOU1VSTFhOU09iamVjdFh0ZXh0L2Nz c9IjJCssoiwoXU5TVVJMUmVzcG9uc2UACAARABsAJAApADIARABJAEwAYgBkAGwAcgCBAIQAhwCK AI0AlACXAJoAnACeAKAAogCkAK0ArwC2AL4AygDMAM4A0ADzAPgBAQEMARABFgEdASYBLwE0ATcA AAAAAAACAQAAAAAAAAAtAAAAAAAAAAAAAAAAAAABRU8QQEBpbXBvcnQgdXJsKCdidWctMTE4Mzkt aW1wb3J0LXJlY3Vyc2UuY3NzJyk7CnAgeyBjb2xvcjogYmx1ZTsgfQpfECBmaWxlOi8vL3RtcC9i dWctMTE4MzktaW1wb3J0LmNzc9QFBgcIEhMUDE8RAcdicGxpc3QwMNQBAgMEBQYHClkkYXJjaGl2 ZXJYJHZlcnNpb25UJHRvcFgkb2JqZWN0c18QD05TS2V5ZWRBcmNoaXZlchIAAYag0QgJXxATV2Vi UmVzb3VyY2VSZXNwb25zZYABpwsMGyEiKSpVJG51bGzXDQ4PEBESExQVFhcYGRpSJDJSJDNSJDRS JDBWJGNsYXNzUiQ1UiQxgAWAABA7EAeABiN/7////////4AC0xwdERUfIFdOUy5iYXNlW05TLnJl bGF0aXZlgACAA4AEXxAoZmlsZTovLy90bXAvYnVnLTExODM5LWltcG9ydC1yZWN1cnNlLmNzc9Ij JCUmWCRjbGFzc2VzWiRjbGFzc25hbWWjJicoVU5TVVJMViVOU1VSTFhOU09iamVjdFh0ZXh0L2Nz c9IjJCssoiwoXU5TVVJMUmVzcG9uc2UACAARABsAJAApADIARABJAEwAYgBkAGwAcgCBAIQAhwCK AI0AlACXAJoAnACeAKAAogCkAK0ArwC2AL4AygDMAM4A0AD7AQABCQEUARgBHgElAS4BNwE8AT8A AAAAAAACAQAAAAAAAAAtAAAAAAAAAAAAAAAAAAABTU8QO0BpbXBvcnQgdXJsKCdidWctMTE4Mzkt aW1wb3J0LmNzcycpOwpkaXYgeyBjb2xvcjogZ3JlZW47IH0KXxAoZmlsZTovLy90bXAvYnVnLTEx ODM5LWltcG9ydC1yZWN1cnNlLmNzc9UIBhYXBxgZGhscXxAbV2ViUmVzb3VyY2VUZXh0RW5jb2Rp bmdOYW1lXxAUV2ViUmVzb3VyY2VGcmFtZU5hbWVZdGV4dC9odG1sTxEBKTxodG1sPjxoZWFkPgo8 bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImJ1Zy0xMTgzOS1saW5rLmNzcyIgdHlwZT0idGV4 dC9jc3MiPgo8c3R5bGUgdHlwZT0idGV4dC9jc3MiPgo8IS0tIEBpbXBvcnQgdXJsKCdidWctMTE4 MzktaW1wb3J0LmNzcycpOyAtLT4KPC9zdHlsZT4KPC9oZWFkPjxib2R5Pgo8cD5UaGlzIHRleHQg c2hvdWxkIGJlIGJsdWUuPC9wPgo8c3Bhbj5UaGlzIHRleHQgc2hvdWxkIGJlIHJlZC48L3NwYW4+ CjxkaXY+VGhpcyB0ZXh0IHNob3VsZCBiZSBncmVlbi48L2Rpdj4KCgo8L2JvZHk+PC9odG1sPlVV VEYtOFBfEB9maWxlOi8vL3RtcC9idWctMTE4MzktdGVzdC5odG1sAAgADQAfADEANQA+AFQAZgB1 AIsCTAJkAoUCjgKXBFoEnQTABMkGlAbSBv0HCAcmBz0HRwh0CHoIewAAAAAAAAIBAAAAAAAAAB0A AAAAAAAAAAAAAAAAAAid 11881 2006-12-16 06:54:13 -0800 2006-12-16 06:54:13 -0800 Test files in zip archive v3 bug-11839-test-3.zip application/zip 1222 ddkilzer UEsDBBQAAgAIALk+kDVrt74iOAAAAD4AAAAcABUAYnVnLTExODM5LWltcG9ydC1yZWN1cnNlLmNz c1VUCQADbfqDRVEChEVVeAQA9QH1AXPIzC3ILypRKC3K0VBPKk3XNTS0MLbUhYjqJRcXq2tac+ml F6Wm5ilUKyTn5+QXWSmAudYKtVwAUEsDBBQAAgAIALk+kDXHoq50PwAAAEQAAAAUABUAYnVnLTEx ODM5LWltcG9ydC5jc3NVVAkAA276g0VRAoRFVXgEAPUB9QFzyMwtyC8qUSgtytFQTypN1zU0tDC2 1IWI6halJpcWFafqJRcXq2tac+kl5ZSmKlQrJOfn5BdZKYB41gq1XABQSwMEFAACAAgAuj6QNXpo nbU+AAAARQAAABkAFQBidWctMTE4MzktbGluay1pbXBvcnQuY3NzVVQJAANw+oNFUQKERVV4BAD1 AfUBc8jMLcgvKlEoLcrRUE8qTdc1NLQwttTNyczL1oVI6SUXF6trWnPpFZQWFeSkKlQrJOfn5BdZ KUD41gq1XABQSwMEFAACAAgAuz6QNYSdJvA7AAAAPwAAABIAFQBidWctMTE4MzktbGluay5jc3NV VAkAA3L6g0VRAoRFVXgEAPUB9QFzyMwtyC8qUSgtytFQTypN1zU0tDC21M3JzMvWhUjpJRcXq2ta c+kVpaYoVCsk5+fkF1kpADnWCrVcAFBLAwQUAAIACACLPpA1Jbpspr4AAACKAQAAEwAVAGJ1Zy0x MTgzOS10ZXN0Lmh0bWxVVAkAAxb6g0VPAoRFVXgEAPUB9QF1kU0OgjAQhfeeYuwGXZSGuNEIxEN4 AaCjJQ4/6Y+R29sC0ZjU1bTz3vdmmubKdlRucoWV9IXa/gEaqWDGToRGIVoGSuOtYLW78yw7Hk48 uNLGGAZ2GrFgFl9WhLtPmLlIf8s5XNpuHLQFp2mXfOOWbghM9mfg3LvFHBMO62L1ICdfZPuEhipj /DrkkJVX1RoIc8CowZGEGiEoaS6895fQKOOAF2L+u0bs48QsxZjR6ZH+7LVoH0qsbxLLF7wBUEsB AhcDFAACAAgAuT6QNWu3viI4AAAAPgAAABwADQAAAAAAAQAAAKSBAAAAAGJ1Zy0xMTgzOS1pbXBv cnQtcmVjdXJzZS5jc3NVVAUAA236g0VVeAAAUEsBAhcDFAACAAgAuT6QNceirnQ/AAAARAAAABQA DQAAAAAAAQAAAKSBhwAAAGJ1Zy0xMTgzOS1pbXBvcnQuY3NzVVQFAANu+oNFVXgAAFBLAQIXAxQA AgAIALo+kDV6aJ21PgAAAEUAAAAZAA0AAAAAAAEAAACkgQ0BAABidWctMTE4MzktbGluay1pbXBv cnQuY3NzVVQFAANw+oNFVXgAAFBLAQIXAxQAAgAIALs+kDWEnSbwOwAAAD8AAAASAA0AAAAAAAEA AACkgZcBAABidWctMTE4MzktbGluay5jc3NVVAUAA3L6g0VVeAAAUEsBAhcDFAACAAgAiz6QNSW6 bKa+AAAAigEAABMADQAAAAAAAQAAAKSBFwIAAGJ1Zy0xMTgzOS10ZXN0Lmh0bWxVVAUAAxb6g0VV eAAAUEsFBgAAAAAFAAUAlQEAABsDAAAAAA== 11882 2006-12-16 06:55:09 -0800 2006-12-16 06:55:09 -0800 Fixed webarchive for test v3 bug-11839-test-3-fixed.webarchive application/x-webarchive 3025 ddkilzer YnBsaXN0MDDSAQIDGV8QD1dlYlN1YnJlc291cmNlc18QD1dlYk1haW5SZXNvdXJjZaQEDREV1AUG BwgJCgsMXxATV2ViUmVzb3VyY2VSZXNwb25zZV8QD1dlYlJlc291cmNlRGF0YV5XZWJSZXNvdXJj ZVVSTF8QE1dlYlJlc291cmNlTUlNRVR5cGVPEQG9YnBsaXN0MDDUAQIDBAUGBwpZJGFyY2hpdmVy WCR2ZXJzaW9uVCR0b3BYJG9iamVjdHNfEA9OU0tleWVkQXJjaGl2ZXISAAGGoNEICV8QE1dlYlJl c291cmNlUmVzcG9uc2WAAacLDBshIikqVSRudWxs1w0ODxAREhMUFRYXGBkaUiQyUiQzUiQ0UiQw ViRjbGFzc1IkNVIkMYAFgAAQPxAHgAYjf+////////+AAtMcHREVHyBXTlMuYmFzZVtOUy5yZWxh dGl2ZYAAgAOABF8QHmZpbGU6Ly8vdG1wL2J1Zy0xMTgzOS1saW5rLmNzc9IjJCUmWCRjbGFzc2Vz WiRjbGFzc25hbWWjJicoVU5TVVJMViVOU1VSTFhOU09iamVjdFh0ZXh0L2Nzc9IjJCssoiwoXU5T VVJMUmVzcG9uc2UACAARABsAJAApADIARABJAEwAYgBkAGwAcgCBAIQAhwCKAI0AlACXAJoAnACe AKAAogCkAK0ArwC2AL4AygDMAM4A0ADxAPYA/wEKAQ4BFAEbASQBLQEyATUAAAAAAAACAQAAAAAA AAAtAAAAAAAAAAAAAAAAAAABQ08QP0BpbXBvcnQgdXJsKCdidWctMTE4MzktbGluay1pbXBvcnQu Y3NzJyk7Ci5yZWQgeyBjb2xvcjogcmVkOyB9Cl8QHmZpbGU6Ly8vdG1wL2J1Zy0xMTgzOS1saW5r LmNzc1h0ZXh0L2Nzc9QFBgcIDg8QDE8RAcRicGxpc3QwMNQBAgMEBQYHClkkYXJjaGl2ZXJYJHZl cnNpb25UJHRvcFgkb2JqZWN0c18QD05TS2V5ZWRBcmNoaXZlchIAAYag0QgJXxATV2ViUmVzb3Vy Y2VSZXNwb25zZYABpwsMGyEiKSpVJG51bGzXDQ4PEBESExQVFhcYGRpSJDJSJDNSJDRSJDBWJGNs YXNzUiQ1UiQxgAWAABBFEAeABiN/7////////4AC0xwdERUfIFdOUy5iYXNlW05TLnJlbGF0aXZl gACAA4AEXxAlZmlsZTovLy90bXAvYnVnLTExODM5LWxpbmstaW1wb3J0LmNzc9IjJCUmWCRjbGFz c2VzWiRjbGFzc25hbWWjJicoVU5TVVJMViVOU1VSTFhOU09iamVjdFh0ZXh0L2Nzc9IjJCssoiwo XU5TVVJMUmVzcG9uc2UACAARABsAJAApADIARABJAEwAYgBkAGwAcgCBAIQAhwCKAI0AlACXAJoA nACeAKAAogCkAK0ArwC2AL4AygDMAM4A0AD4AP0BBgERARUBGwEiASsBNAE5ATwAAAAAAAACAQAA AAAAAAAtAAAAAAAAAAAAAAAAAAABSk8QRUBpbXBvcnQgdXJsKCdidWctMTE4MzktbGluay1pbXBv cnQuY3NzJyk7Ci5wdXJwbGUgeyBjb2xvcjogcHVycGxlOyB9Cl8QJWZpbGU6Ly8vdG1wL2J1Zy0x MTgzOS1saW5rLWltcG9ydC5jc3PUBQYHCBITFAxPEQG/YnBsaXN0MDDUAQIDBAUGBwpZJGFyY2hp dmVyWCR2ZXJzaW9uVCR0b3BYJG9iamVjdHNfEA9OU0tleWVkQXJjaGl2ZXISAAGGoNEICV8QE1dl YlJlc291cmNlUmVzcG9uc2WAAacLDBshIikqVSRudWxs1w0ODxAREhMUFRYXGBkaUiQyUiQzUiQ0 UiQwViRjbGFzc1IkNVIkMYAFgAAQRBAHgAYjf+////////+AAtMcHREVHyBXTlMuYmFzZVtOUy5y ZWxhdGl2ZYAAgAOABF8QIGZpbGU6Ly8vdG1wL2J1Zy0xMTgzOS1pbXBvcnQuY3Nz0iMkJSZYJGNs YXNzZXNaJGNsYXNzbmFtZaMmJyhVTlNVUkxWJU5TVVJMWE5TT2JqZWN0WHRleHQvY3Nz0iMkKyyi LChdTlNVUkxSZXNwb25zZQAIABEAGwAkACkAMgBEAEkATABiAGQAbAByAIEAhACHAIoAjQCUAJcA mgCcAJ4AoACiAKQArQCvALYAvgDKAMwAzgDQAPMA+AEBAQwBEAEWAR0BJgEvATQBNwAAAAAAAAIB AAAAAAAAAC0AAAAAAAAAAAAAAAAAAAFFTxBEQGltcG9ydCB1cmwoJ2J1Zy0xMTgzOS1pbXBvcnQt cmVjdXJzZS5jc3MnKTsKLmJsdWUgeyBjb2xvcjogYmx1ZTsgfQpfECBmaWxlOi8vL3RtcC9idWct MTE4MzktaW1wb3J0LmNzc9QFBgcIFhcYDE8RAcdicGxpc3QwMNQBAgMEBQYHClkkYXJjaGl2ZXJY JHZlcnNpb25UJHRvcFgkb2JqZWN0c18QD05TS2V5ZWRBcmNoaXZlchIAAYag0QgJXxATV2ViUmVz b3VyY2VSZXNwb25zZYABpwsMGyEiKSpVJG51bGzXDQ4PEBESExQVFhcYGRpSJDJSJDNSJDRSJDBW JGNsYXNzUiQ1UiQxgAWAABA+EAeABiN/7////////4AC0xwdERUfIFdOUy5iYXNlW05TLnJlbGF0 aXZlgACAA4AEXxAoZmlsZTovLy90bXAvYnVnLTExODM5LWltcG9ydC1yZWN1cnNlLmNzc9IjJCUm WCRjbGFzc2VzWiRjbGFzc25hbWWjJicoVU5TVVJMViVOU1VSTFhOU09iamVjdFh0ZXh0L2Nzc9Ij JCssoiwoXU5TVVJMUmVzcG9uc2UACAARABsAJAApADIARABJAEwAYgBkAGwAcgCBAIQAhwCKAI0A lACXAJoAnACeAKAAogCkAK0ArwC2AL4AygDMAM4A0AD7AQABCQEUARgBHgElAS4BNwE8AT8AAAAA AAACAQAAAAAAAAAtAAAAAAAAAAAAAAAAAAABTU8QPkBpbXBvcnQgdXJsKCdidWctMTE4MzktaW1w b3J0LmNzcycpOwouZ3JlZW4geyBjb2xvcjogZ3JlZW47IH0KXxAoZmlsZTovLy90bXAvYnVnLTEx ODM5LWltcG9ydC1yZWN1cnNlLmNzc9UIBhobBxwdHh8gXxAbV2ViUmVzb3VyY2VUZXh0RW5jb2Rp bmdOYW1lXxAUV2ViUmVzb3VyY2VGcmFtZU5hbWVZdGV4dC9odG1sTxEBiDxodG1sPjxoZWFkPgo8 bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImJ1Zy0xMTgzOS1saW5rLmNzcyIgdHlwZT0idGV4 dC9jc3MiPgo8c3R5bGUgdHlwZT0idGV4dC9jc3MiPgo8IS0tIEBpbXBvcnQgdXJsKCdidWctMTE4 MzktaW1wb3J0LmNzcycpOyAtLT4KPC9zdHlsZT4KPC9oZWFkPjxib2R5Pgo8ZGl2IGNsYXNzPSJi bHVlIj5UaGlzIHRleHQgc2hvdWxkIGJlIGJsdWUuPC9kaXY+CjxkaXYgY2xhc3M9InJlZCI+VGhp cyB0ZXh0IHNob3VsZCBiZSByZWQuPC9kaXY+CjxkaXYgY2xhc3M9ImdyZWVuIj5UaGlzIHRleHQg c2hvdWxkIGJlIGdyZWVuLjwvZGl2Pgo8ZGl2IGNsYXNzPSJwdXJwbGUiPlRoaXMgdGV4dCBzaG91 bGQgYmUgcHVycGxlLjwvZGl2PgoKCjwvYm9keT48L2h0bWw+VVVURi04UF8QH2ZpbGU6Ly8vdG1w L2J1Zy0xMTgzOS10ZXN0Lmh0bWwACAANAB8AMQA2AD8AVQBnAHYAjAJNAo8CsAK5AsIEigTSBPoF AwbGBw0HMAc5CQQJRQlwCXsJmQmwCboLRgtMC00AAAAAAAACAQAAAAAAAAAhAAAAAAAAAAAAAAAA AAALbw== 11883 2006-12-16 07:03:01 -0800 2006-12-17 19:24:07 -0800 Patch v1 bug-11839-v1.diff text/plain 4753 ddkilzer SW5kZXg6IFdlYktpdC9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L0NoYW5nZUxvZwko cmV2aXNpb24gMTgyNTYpCisrKyBXZWJLaXQvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0x LDMgKzEsMTggQEAKKzIwMDYtMTItMTYgIERhdmlkIEtpbHplciAgPGRka2lsemVyQGtpbHplci5u ZXQ+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgaHR0 cDovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTE4MzkKKyAgICAgICAgV2ViYXJj aGl2ZSBmYWlscyB0byBzYXZlIENTUyBmaWxlcyBpbiBAaW1wb3J0IHN0YXRlbWVudHMKKworICAg ICAgICAqIERPTS9XZWJET01PcGVyYXRpb25zLm06CisgICAgICAgICgtW0RPTU5vZGUgX1VSTHNG cm9tU2VsZWN0b3JzOl0pOiBSZXR1cm4gcG9pbnRlciB0byBOU011dGFibGVBcnJheSBpbnN0ZWFk IG9mIE5TQXJyYXkuCisgICAgICAgICgtW0RPTUhUTUxMaW5rRWxlbWVudCBfc3VicmVzb3VyY2VV UkxzXSk6CisgICAgICAgIENhbGwgX3JlYWRDU1NSdWxlc1JlY3Vyc2l2ZWx5OndpdGhVUkxzOndp dGhET01Eb2N1bWVudDogdG8gZmluZCBvdGhlciBAaW1wb3J0IHN0YXRlbWVudHMuCisgICAgICAg ICgrW0RPTUhUTUxTdHlsZUVsZW1lbnQgX3JlYWRDU1NSdWxlc1JlY3Vyc2l2ZWx5OndpdGhVUkxz OndpdGhET01Eb2N1bWVudDpdKTogQWRkZWQuCisgICAgICAgICgtW0RPTUhUTUxTdHlsZUVsZW1l bnQgX3N1YnJlc291cmNlVVJMc10pOiBBZGRlZC4KKyAgICAgICAgKiBET00vV2ViRE9NT3BlcmF0 aW9uc1ByaXZhdGUuaDoKKwogMjAwNi0xMi0xNiAgQWRlbGUgUGV0ZXJzb24gIDxhZGVsZUBhcHBs ZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgQWRhbS4KSW5kZXg6IFdlYktpdC9ET00vV2Vi RE9NT3BlcmF0aW9ucy5tCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9ET00vV2ViRE9NT3BlcmF0aW9u cy5tCShyZXZpc2lvbiAxODI1NikKKysrIFdlYktpdC9ET00vV2ViRE9NT3BlcmF0aW9ucy5tCSh3 b3JraW5nIGNvcHkpCkBAIC0xLDUgKzEsNSBAQAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwNSBB cHBsZSBDb21wdXRlciwgSW5jLiAgQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqIENvcHlyaWdodCAo QykgMjAwNSwgMjAwNiBBcHBsZSBDb21wdXRlciwgSW5jLiAgQWxsIHJpZ2h0cyByZXNlcnZlZC4K ICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1z LCB3aXRoIG9yIHdpdGhvdXQKICAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRl ZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwpAQCAtNTUsNyArNTUsNyBAQAogICAgIHJl dHVybiBbW3NlbGYgX2JyaWRnZV0gbWFya3VwU3RyaW5nRnJvbU5vZGU6c2VsZiBub2RlczpuaWxd OwogfQogCi0tIChOU0FycmF5ICopX1VSTHNGcm9tU2VsZWN0b3JzOihTRUwpZmlyc3RTZWwsIC4u LgorLSAoTlNNdXRhYmxlQXJyYXkgKilfVVJMc0Zyb21TZWxlY3RvcnM6KFNFTClmaXJzdFNlbCwg Li4uCiB7CiAgICAgTlNNdXRhYmxlQXJyYXkgKlVSTHMgPSBbTlNNdXRhYmxlQXJyYXkgYXJyYXld OwogICAgIApAQCAtMTU1LDEzICsxNTUsNDcgQEAKIHsKICAgICBOU1N0cmluZyAqcmVsTmFtZSA9 IFtzZWxmIHJlbF07CiAgICAgaWYgKFtyZWxOYW1lIF93ZWJraXRfaXNDYXNlSW5zZW5zaXRpdmVF cXVhbFRvU3RyaW5nOkAic3R5bGVzaGVldCJdIHx8IFtyZWxOYW1lIF93ZWJraXRfaXNDYXNlSW5z ZW5zaXRpdmVFcXVhbFRvU3RyaW5nOkAiaWNvbiJdKSB7Ci0gICAgICAgIHJldHVybiBbc2VsZiBf VVJMc0Zyb21TZWxlY3RvcnM6QHNlbGVjdG9yKGhyZWYpLCBuaWxdOworICAgICAgICBOU011dGFi bGVBcnJheSAqVVJMcyA9IFtzZWxmIF9VUkxzRnJvbVNlbGVjdG9yczpAc2VsZWN0b3IoaHJlZiks IG5pbF07CisgICAgICAgIERPTUNTU1N0eWxlU2hlZXQgKnNoZWV0ID0gKERPTUNTU1N0eWxlU2hl ZXQgKilbc2VsZiBzaGVldF07CisgICAgICAgIFtET01IVE1MU3R5bGVFbGVtZW50IF9yZWFkQ1NT UnVsZXNSZWN1cnNpdmVseTpzaGVldCB3aXRoVVJMczpVUkxzIHdpdGhET01Eb2N1bWVudDpbc2Vs ZiBvd25lckRvY3VtZW50XV07CisgICAgICAgIHJldHVybiBVUkxzOwogICAgIH0KICAgICByZXR1 cm4gbmlsOwogfQogCiBAZW5kCiAKK0BpbXBsZW1lbnRhdGlvbiBET01IVE1MU3R5bGVFbGVtZW50 IChXZWJET01IVE1MU3R5bGVFbGVtZW50T3BlcmF0aW9uc1ByaXZhdGUpCisKKysgKHZvaWQpX3Jl YWRDU1NSdWxlc1JlY3Vyc2l2ZWx5OihET01DU1NTdHlsZVNoZWV0ICopc2hlZXQgd2l0aFVSTHM6 KE5TTXV0YWJsZUFycmF5ICopVVJMcyB3aXRoRE9NRG9jdW1lbnQ6KERPTURvY3VtZW50ICopZG9j dW1lbnQKK3sKKyAgICBET01DU1NSdWxlTGlzdCAqcnVsZXMgPSBbc2hlZXQgY3NzUnVsZXNdOwor ICAgIGZvciAoaW50IGkgPSAwLCBtYXggPSBbcnVsZXMgbGVuZ3RoXTsgaSA8IG1heDsgaSsrKSB7 CisgICAgICAgIERPTUNTU1J1bGUgKnJ1bGUgPSBbcnVsZXMgaXRlbTppXTsKKyAgICAgICAgaWYg KFtydWxlIHR5cGVdID09IERPTV9JTVBPUlRfUlVMRSkgeworICAgICAgICAgICAgRE9NQ1NTSW1w b3J0UnVsZSAqaW1wb3J0UnVsZSA9IChET01DU1NJbXBvcnRSdWxlICopIHJ1bGU7IAorICAgICAg ICAgICAgTlNTdHJpbmcgKnN0cmluZyA9IFtpbXBvcnRSdWxlIGhyZWZdOworICAgICAgICAgICAg aWYgKFtzdHJpbmcgbGVuZ3RoXSA+IDApIHsKKyAgICAgICAgICAgICAgICBOU1VSTCAqbmV3VVJM ID0gW2RvY3VtZW50IFVSTFdpdGhBdHRyaWJ1dGVTdHJpbmc6c3RyaW5nXTsKKyAgICAgICAgICAg ICAgICBpZiAoIVtVUkxzIGNvbnRhaW5zT2JqZWN0Om5ld1VSTF0pIHsKKyAgICAgICAgICAgICAg ICAgICAgW1VSTHMgYWRkT2JqZWN0Om5ld1VSTF07CisgICAgICAgICAgICAgICAgICAgIFtET01I VE1MU3R5bGVFbGVtZW50IF9yZWFkQ1NTUnVsZXNSZWN1cnNpdmVseTpbaW1wb3J0UnVsZSBzdHls ZVNoZWV0XSB3aXRoVVJMczpVUkxzIHdpdGhET01Eb2N1bWVudDpkb2N1bWVudF07CisgICAgICAg ICAgICAgICAgfQorICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgfQorfQorCistIChOU0Fy cmF5ICopX3N1YnJlc291cmNlVVJMcworeworICAgIE5TTXV0YWJsZUFycmF5ICpVUkxzID0gW05T TXV0YWJsZUFycmF5IGFycmF5XTsKKyAgICBET01DU1NTdHlsZVNoZWV0ICpzaGVldCA9IChET01D U1NTdHlsZVNoZWV0ICopW3NlbGYgc2hlZXRdOworICAgIFtET01IVE1MU3R5bGVFbGVtZW50IF9y ZWFkQ1NTUnVsZXNSZWN1cnNpdmVseTpzaGVldCB3aXRoVVJMczpVUkxzIHdpdGhET01Eb2N1bWVu dDpbc2VsZiBvd25lckRvY3VtZW50XV07CisgICAgcmV0dXJuIFVSTHM7Cit9CisKK0BlbmQKKwog QGltcGxlbWVudGF0aW9uIERPTUhUTUxTY3JpcHRFbGVtZW50IChXZWJET01IVE1MU2NyaXB0RWxl bWVudE9wZXJhdGlvbnNQcml2YXRlKQogCiAtIChOU0FycmF5ICopX3N1YnJlc291cmNlVVJMcwpJ bmRleDogV2ViS2l0L0RPTS9XZWJET01PcGVyYXRpb25zUHJpdmF0ZS5oCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFdlYktpdC9ET00vV2ViRE9NT3BlcmF0aW9uc1ByaXZhdGUuaAkocmV2aXNpb24gMTgyNTYpCisr KyBXZWJLaXQvRE9NL1dlYkRPTU9wZXJhdGlvbnNQcml2YXRlLmgJKHdvcmtpbmcgY29weSkKQEAg LTEsNSArMSw1IEBACiAvKgotICogQ29weXJpZ2h0IChDKSAyMDA1IEFwcGxlIENvbXB1dGVyLCBJ bmMuICBBbGwgcmlnaHRzIHJlc2VydmVkLgorICogQ29weXJpZ2h0IChDKSAyMDA1LCAyMDA2IEFw cGxlIENvbXB1dGVyLCBJbmMuICBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJp YnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91 dAogICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxv d2luZyBjb25kaXRpb25zCkBAIC0zMiw3ICszMiw3IEBACiAKIEBpbnRlcmZhY2UgRE9NTm9kZSAo V2ViRE9NTm9kZU9wZXJhdGlvbnNQcml2YXRlKQogLSAoV2ViRnJhbWVCcmlkZ2UgKilfYnJpZGdl OwotLSAoTlNBcnJheSAqKV9VUkxzRnJvbVNlbGVjdG9yczooU0VMKWZpcnN0U2VsLCAuLi47Cist IChOU011dGFibGVBcnJheSAqKV9VUkxzRnJvbVNlbGVjdG9yczooU0VMKWZpcnN0U2VsLCAuLi47 CiAtIChOU0FycmF5ICopX3N1YnJlc291cmNlVVJMczsKIEBlbmQKIApAQCAtNDQsMyArNDQsNyBA QAogLSAoRE9NUmFuZ2UgKilfY3JlYXRlUmFuZ2VXaXRoTm9kZTooRE9NTm9kZSAqKW5vZGU7CiAt IChET01SYW5nZSAqKV9kb2N1bWVudFJhbmdlOwogQGVuZAorCitAaW50ZXJmYWNlIERPTUhUTUxT dHlsZUVsZW1lbnQgKFdlYkRPTUhUTUxTdHlsZUVsZW1lbnRPcGVyYXRpb25zUHJpdmF0ZSkKKysg KHZvaWQpX3JlYWRDU1NSdWxlc1JlY3Vyc2l2ZWx5OihET01DU1NTdHlsZVNoZWV0ICopc2hlZXQg d2l0aFVSTHM6KE5TTXV0YWJsZUFycmF5ICopVVJMcyB3aXRoRE9NRG9jdW1lbnQ6KERPTURvY3Vt ZW50ICopZG9jdW1lbnQ7CitAZW5kCg== 11898 2006-12-17 19:24:07 -0800 2007-02-04 18:11:39 -0800 Patch v2 bug-11839-v2.diff text/plain 5419 ddkilzer SW5kZXg6IFdlYktpdC9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L0NoYW5nZUxvZwko cmV2aXNpb24gMTgyNzMpCisrKyBXZWJLaXQvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0x LDMgKzEsMTggQEAKKzIwMDYtMTItMTcgIERhdmlkIEtpbHplciAgPGRka2lsemVyQGtpbHplci5u ZXQ+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgaHR0 cDovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTE4MzkKKyAgICAgICAgV2ViYXJj aGl2ZSBmYWlscyB0byBzYXZlIENTUyBmaWxlcyBpbiBAaW1wb3J0IHN0YXRlbWVudHMKKworICAg ICAgICAqIERPTS9XZWJET01PcGVyYXRpb25zLm06CisgICAgICAgICgtW0RPTU5vZGUgX1VSTHNG cm9tU2VsZWN0b3JzOl0pOiBSZXR1cm4gcG9pbnRlciB0byBOU011dGFibGVBcnJheSBpbnN0ZWFk IG9mIE5TQXJyYXkuICBTdHlsZSBmaXhlcy4KKyAgICAgICAgKC1bRE9NQ1NTU3R5bGVTaGVldCBf cmVjdXJzaXZlbHlBZGRTdWJyZXNvdXJjZVVSTHNUb0FycmF5OndpdGhET01Eb2N1bWVudDpdKTog QWRkZWQuCisgICAgICAgICgtW0RPTUhUTUxMaW5rRWxlbWVudCBfc3VicmVzb3VyY2VVUkxzXSk6 IENhbGwgX3JlY3Vyc2l2ZWx5QWRkU3VicmVzb3VyY2VVUkxzVG9BcnJheTp3aXRoRE9NRG9jdW1l bnQ6CisgICAgICAgIGZvciBzdHlsZXNoZWV0cyB0byBmaW5kIG90aGVyIEBpbXBvcnQgc3VicmVz b3VyY2VzLgorICAgICAgICAoLVtET01IVE1MU3R5bGVFbGVtZW50IF9zdWJyZXNvdXJjZVVSTHNd KTogQWRkZWQuCisgICAgICAgICogRE9NL1dlYkRPTU9wZXJhdGlvbnNQcml2YXRlLmg6CisKIDIw MDYtMTItMTYgIEFkZWxlIFBldGVyc29uICA8YWRlbGVAYXBwbGUuY29tPgogCiAgICAgICAgIFJl dmlld2VkIGJ5IEFkYW0uCkluZGV4OiBXZWJLaXQvRE9NL1dlYkRPTU9wZXJhdGlvbnMubQo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBXZWJLaXQvRE9NL1dlYkRPTU9wZXJhdGlvbnMubQkocmV2aXNpb24gMTgyNzMp CisrKyBXZWJLaXQvRE9NL1dlYkRPTU9wZXJhdGlvbnMubQkod29ya2luZyBjb3B5KQpAQCAtMSw1 ICsxLDUgQEAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDUgQXBwbGUgQ29tcHV0ZXIsIEluYy4g IEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDUsIDIwMDYgQXBwbGUg Q29tcHV0ZXIsIEluYy4gIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRp b24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAg KiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5n IGNvbmRpdGlvbnMKQEAgLTU1LDcgKzU1LDcgQEAKICAgICByZXR1cm4gW1tzZWxmIF9icmlkZ2Vd IG1hcmt1cFN0cmluZ0Zyb21Ob2RlOnNlbGYgbm9kZXM6bmlsXTsKIH0KIAotLSAoTlNBcnJheSAq KV9VUkxzRnJvbVNlbGVjdG9yczooU0VMKWZpcnN0U2VsLCAuLi4KKy0gKE5TTXV0YWJsZUFycmF5 ICopX1VSTHNGcm9tU2VsZWN0b3JzOihTRUwpZmlyc3RTZWwsIC4uLgogewogICAgIE5TTXV0YWJs ZUFycmF5ICpVUkxzID0gW05TTXV0YWJsZUFycmF5IGFycmF5XTsKICAgICAKQEAgLTY1LDkgKzY1 LDggQEAKICAgICBTRUwgc2VsZWN0b3IgPSBmaXJzdFNlbDsKICAgICBkbyB7CiAgICAgICAgIE5T U3RyaW5nICpzdHJpbmcgPSBbc2VsZiBwZXJmb3JtU2VsZWN0b3I6c2VsZWN0b3JdOwotICAgICAg ICBpZiAoW3N0cmluZyBsZW5ndGhdID4gMCkgeworICAgICAgICBpZiAoW3N0cmluZyBsZW5ndGhd KQogICAgICAgICAgICAgW1VSTHMgYWRkT2JqZWN0Oltbc2VsZiBvd25lckRvY3VtZW50XSBVUkxX aXRoQXR0cmlidXRlU3RyaW5nOnN0cmluZ11dOwotICAgICAgICB9CiAgICAgfSB3aGlsZSAoKHNl bGVjdG9yID0gdmFfYXJnKGFyZ3MsIFNFTCkpICE9IG5pbCk7CiAgICAgCiAgICAgdmFfZW5kKGFy Z3MpOwpAQCAtMTMxLDYgKzEzMCwyOSBAQAogCiBAZW5kCiAKK0BpbXBsZW1lbnRhdGlvbiBET01D U1NTdHlsZVNoZWV0IChXZWJET01DU1NTdHlsZVNoZWV0T3BlcmF0aW9uc1ByaXZhdGUpCisKKy0g KHZvaWQpX3JlY3Vyc2l2ZWx5QWRkU3VicmVzb3VyY2VVUkxzVG9BcnJheTooTlNNdXRhYmxlQXJy YXkgKilVUkxzIHdpdGhET01Eb2N1bWVudDooRE9NRG9jdW1lbnQgKilkb2N1bWVudAoreworICAg IERPTUNTU1J1bGVMaXN0ICpydWxlcyA9IFtzZWxmIGNzc1J1bGVzXTsKKyAgICBmb3IgKGludCBp ID0gMCwgbWF4ID0gW3J1bGVzIGxlbmd0aF07IGkgPCBtYXg7IGkrKykgeworICAgICAgICBET01D U1NSdWxlICpydWxlID0gW3J1bGVzIGl0ZW06aV07CisgICAgICAgIGlmIChbcnVsZSB0eXBlXSA9 PSBET01fSU1QT1JUX1JVTEUpIHsKKyAgICAgICAgICAgIERPTUNTU0ltcG9ydFJ1bGUgKmltcG9y dFJ1bGUgPSAoRE9NQ1NTSW1wb3J0UnVsZSAqKXJ1bGU7IAorICAgICAgICAgICAgTlNTdHJpbmcg KnN0cmluZyA9IFtpbXBvcnRSdWxlIGhyZWZdOworICAgICAgICAgICAgaWYgKFtzdHJpbmcgbGVu Z3RoXSkgeworICAgICAgICAgICAgICAgIE5TVVJMICpuZXdVUkwgPSBbZG9jdW1lbnQgVVJMV2l0 aEF0dHJpYnV0ZVN0cmluZzpzdHJpbmddOworICAgICAgICAgICAgICAgIGlmICghW1VSTHMgY29u dGFpbnNPYmplY3Q6bmV3VVJMXSkgeworICAgICAgICAgICAgICAgICAgICBbVVJMcyBhZGRPYmpl Y3Q6bmV3VVJMXTsKKyAgICAgICAgICAgICAgICAgICAgW1tpbXBvcnRSdWxlIHN0eWxlU2hlZXRd IF9yZWN1cnNpdmVseUFkZFN1YnJlc291cmNlVVJMc1RvQXJyYXk6VVJMcyB3aXRoRE9NRG9jdW1l bnQ6ZG9jdW1lbnRdOworICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgIH0KKyAgICAgICAg fQorICAgIH0KK30KKworQGVuZAorCiBAaW1wbGVtZW50YXRpb24gRE9NSFRNTEJvZHlFbGVtZW50 IChXZWJET01IVE1MQm9keUVsZW1lbnRPcGVyYXRpb25zUHJpdmF0ZSkKIAogLSAoTlNBcnJheSAq KV9zdWJyZXNvdXJjZVVSTHMKQEAgLTE1NCwxNCArMTc2LDM0IEBACiAtIChOU0FycmF5ICopX3N1 YnJlc291cmNlVVJMcwogewogICAgIE5TU3RyaW5nICpyZWxOYW1lID0gW3NlbGYgcmVsXTsKLSAg ICBpZiAoW3JlbE5hbWUgX3dlYmtpdF9pc0Nhc2VJbnNlbnNpdGl2ZUVxdWFsVG9TdHJpbmc6QCJz dHlsZXNoZWV0Il0gfHwgW3JlbE5hbWUgX3dlYmtpdF9pc0Nhc2VJbnNlbnNpdGl2ZUVxdWFsVG9T dHJpbmc6QCJpY29uIl0pIHsKKworICAgIGlmIChbcmVsTmFtZSBfd2Via2l0X2lzQ2FzZUluc2Vu c2l0aXZlRXF1YWxUb1N0cmluZzpAImljb24iXSkKICAgICAgICAgcmV0dXJuIFtzZWxmIF9VUkxz RnJvbVNlbGVjdG9yczpAc2VsZWN0b3IoaHJlZiksIG5pbF07CisKKyAgICBpZiAoW3JlbE5hbWUg X3dlYmtpdF9pc0Nhc2VJbnNlbnNpdGl2ZUVxdWFsVG9TdHJpbmc6QCJzdHlsZXNoZWV0Il0pIHsK KyAgICAgICAgTlNNdXRhYmxlQXJyYXkgKlVSTHMgPSBbc2VsZiBfVVJMc0Zyb21TZWxlY3RvcnM6 QHNlbGVjdG9yKGhyZWYpLCBuaWxdOworICAgICAgICBET01DU1NTdHlsZVNoZWV0ICpzaGVldCA9 IChET01DU1NTdHlsZVNoZWV0ICopW3NlbGYgc2hlZXRdOworICAgICAgICBbc2hlZXQgX3JlY3Vy c2l2ZWx5QWRkU3VicmVzb3VyY2VVUkxzVG9BcnJheTpVUkxzIHdpdGhET01Eb2N1bWVudDpbc2Vs ZiBvd25lckRvY3VtZW50XV07CisgICAgICAgIHJldHVybiBVUkxzOwogICAgIH0KKwogICAgIHJl dHVybiBuaWw7CiB9CiAKIEBlbmQKIAorQGltcGxlbWVudGF0aW9uIERPTUhUTUxTdHlsZUVsZW1l bnQgKFdlYkRPTUhUTUxTdHlsZUVsZW1lbnRPcGVyYXRpb25zUHJpdmF0ZSkKKworLSAoTlNBcnJh eSAqKV9zdWJyZXNvdXJjZVVSTHMKK3sKKyAgICBOU011dGFibGVBcnJheSAqVVJMcyA9IFtOU011 dGFibGVBcnJheSBhcnJheV07CisgICAgRE9NQ1NTU3R5bGVTaGVldCAqc2hlZXQgPSAoRE9NQ1NT U3R5bGVTaGVldCAqKVtzZWxmIHNoZWV0XTsKKyAgICBbc2hlZXQgX3JlY3Vyc2l2ZWx5QWRkU3Vi cmVzb3VyY2VVUkxzVG9BcnJheTpVUkxzIHdpdGhET01Eb2N1bWVudDpbc2VsZiBvd25lckRvY3Vt ZW50XV07CisgICAgcmV0dXJuIFVSTHM7Cit9CisKK0BlbmQKKwogQGltcGxlbWVudGF0aW9uIERP TUhUTUxTY3JpcHRFbGVtZW50IChXZWJET01IVE1MU2NyaXB0RWxlbWVudE9wZXJhdGlvbnNQcml2 YXRlKQogCiAtIChOU0FycmF5ICopX3N1YnJlc291cmNlVVJMcwpJbmRleDogV2ViS2l0L0RPTS9X ZWJET01PcGVyYXRpb25zUHJpdmF0ZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9ET00vV2ViRE9N T3BlcmF0aW9uc1ByaXZhdGUuaAkocmV2aXNpb24gMTgyNzMpCisrKyBXZWJLaXQvRE9NL1dlYkRP TU9wZXJhdGlvbnNQcml2YXRlLmgJKHdvcmtpbmcgY29weSkKQEAgLTEsNSArMSw1IEBACiAvKgot ICogQ29weXJpZ2h0IChDKSAyMDA1IEFwcGxlIENvbXB1dGVyLCBJbmMuICBBbGwgcmlnaHRzIHJl c2VydmVkLgorICogQ29weXJpZ2h0IChDKSAyMDA1LCAyMDA2IEFwcGxlIENvbXB1dGVyLCBJbmMu ICBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4g c291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAogICogbW9kaWZpY2F0aW9u LCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCkBA IC0zMCw5ICszMCwxNSBAQAogCiAjaW1wb3J0IDxXZWJLaXQvV2ViRE9NT3BlcmF0aW9ucy5oPgog CisjaW1wb3J0IDxXZWJLaXQvRE9NQ1NTU3R5bGVTaGVldC5oPgorCitAaW50ZXJmYWNlIERPTUNT U1N0eWxlU2hlZXQgKFdlYkRPTUNTU1N0eWxlU2hlZXRPcGVyYXRpb25zUHJpdmF0ZSkKKy0gKHZv aWQpX3JlY3Vyc2l2ZWx5QWRkU3VicmVzb3VyY2VVUkxzVG9BcnJheTooTlNNdXRhYmxlQXJyYXkg KilVUkxzIHdpdGhET01Eb2N1bWVudDooRE9NRG9jdW1lbnQgKilkb2N1bWVudDsKK0BlbmQKKwog QGludGVyZmFjZSBET01Ob2RlIChXZWJET01Ob2RlT3BlcmF0aW9uc1ByaXZhdGUpCiAtIChXZWJG cmFtZUJyaWRnZSAqKV9icmlkZ2U7Ci0tIChOU0FycmF5ICopX1VSTHNGcm9tU2VsZWN0b3JzOihT RUwpZmlyc3RTZWwsIC4uLjsKKy0gKE5TTXV0YWJsZUFycmF5ICopX1VSTHNGcm9tU2VsZWN0b3Jz OihTRUwpZmlyc3RTZWwsIC4uLjsKIC0gKE5TQXJyYXkgKilfc3VicmVzb3VyY2VVUkxzOwogQGVu ZAogCg== 12925 2007-02-04 18:11:39 -0800 2008-04-02 15:19:57 -0700 Patch v3 bug-11839-v3.diff text/plain 19298 ddkilzer SW5kZXg6IExheW91dFRlc3RzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9D aGFuZ2VMb2cJKHJldmlzaW9uIDE5Mzk1KQorKysgTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCSh3b3Jr aW5nIGNvcHkpCkBAIC0xLDMgKzEsMTcgQEAKKzIwMDctMDItMDQgIERhdmlkIEtpbHplciAgPGRk a2lsemVyQHdlYmtpdC5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgLSB0ZXN0IGZvciBodHRwOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0xMTgzOQorICAgICAgICAgIFdlYmFyY2hpdmUgZmFpbHMgdG8gc2F2ZSBDU1MgZmlsZXMg aW4gQGltcG9ydCBzdGF0ZW1lbnRzCisKKyAgICAgICAgKiB3ZWJhcmNoaXZlL3Jlc291cmNlcy90 ZXN0LWNzcy1pbXBvcnQtcmVjdXJzZS5jc3M6IEFkZGVkLgorICAgICAgICAqIHdlYmFyY2hpdmUv cmVzb3VyY2VzL3Rlc3QtY3NzLWltcG9ydC5jc3M6IEFkZGVkLgorICAgICAgICAqIHdlYmFyY2hp dmUvcmVzb3VyY2VzL3Rlc3QtY3NzLWxpbmstcmVjdXJzZS5jc3M6IEFkZGVkLgorICAgICAgICAq IHdlYmFyY2hpdmUvcmVzb3VyY2VzL3Rlc3QtY3NzLWxpbmsuY3NzOiBBZGRlZC4KKyAgICAgICAg KiB3ZWJhcmNoaXZlL3Rlc3QtY3NzLWltcG9ydC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAg ICAqIHdlYmFyY2hpdmUvdGVzdC1jc3MtaW1wb3J0Lmh0bWw6IEFkZGVkLgorCiAyMDA3LTAyLTAz ICBHZW9mZnJleSBHYXJlbiAgPGdnYXJlbkBhcHBsZS5jb20+CiAKICAgICAgICAgTGFuZGluZyBy ZXN1bHRzIHRoYXQgSSB0aGluayBNYWNpZWogaW50ZW5kZWQgdG8gbGFuZCwgdG8gZ2V0IHRoZSBi dWlsZGJvdApJbmRleDogTGF5b3V0VGVzdHMvd2ViYXJjaGl2ZS90ZXN0LWNzcy1pbXBvcnQtZXhw ZWN0ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL3dlYmFyY2hpdmUvdGVzdC1jc3Mt aW1wb3J0LWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL3dlYmFyY2hp dmUvdGVzdC1jc3MtaW1wb3J0LWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwx MjIgQEAKKzw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Cis8IURPQ1RZUEUg cGxpc3QgUFVCTElDICItLy9BcHBsZSBDb21wdXRlci8vRFREIFBMSVNUIDEuMC8vRU4iICJodHRw Oi8vd3d3LmFwcGxlLmNvbS9EVERzL1Byb3BlcnR5TGlzdC0xLjAuZHRkIj4KKzxwbGlzdCB2ZXJz aW9uPSIxLjAiPgorPGRpY3Q+CisJPGtleT5XZWJNYWluUmVzb3VyY2U8L2tleT4KKwk8ZGljdD4K KwkJPGtleT5XZWJSZXNvdXJjZURhdGE8L2tleT4KKwkJPHN0cmluZz4mbHQ7aHRtbCZndDsmbHQ7 aGVhZCZndDsKKyZsdDtzY3JpcHQmZ3Q7CisgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJv bGxlcikKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzV2ViQXJjaGl2ZSgpOwor Jmx0Oy9zY3JpcHQmZ3Q7CismbHQ7bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9InJlc291cmNl cy90ZXN0LWNzcy1saW5rLmNzcyIgdHlwZT0idGV4dC9jc3MiJmd0OworJmx0O3N0eWxlIHR5cGU9 InRleHQvY3NzIiZndDsKKyZsdDshLS0gQGltcG9ydCB1cmwoJ3Jlc291cmNlcy90ZXN0LWNzcy1p bXBvcnQuY3NzJyk7IC0tJmd0OworJmx0Oy9zdHlsZSZndDsKKyZsdDsvaGVhZCZndDsmbHQ7Ym9k eSZndDsKKyZsdDtkaXYgY2xhc3M9ImJsdWUiJmd0O1RoaXMgdGV4dCBzaG91bGQgYmUgYmx1ZS4m bHQ7L2RpdiZndDsKKyZsdDtkaXYgY2xhc3M9InJlZCImZ3Q7VGhpcyB0ZXh0IHNob3VsZCBiZSBy ZWQuJmx0Oy9kaXYmZ3Q7CismbHQ7ZGl2IGNsYXNzPSJncmVlbiImZ3Q7VGhpcyB0ZXh0IHNob3Vs ZCBiZSBncmVlbi4mbHQ7L2RpdiZndDsKKyZsdDtkaXYgY2xhc3M9InB1cnBsZSImZ3Q7VGhpcyB0 ZXh0IHNob3VsZCBiZSBwdXJwbGUuJmx0Oy9kaXYmZ3Q7CisKKworJmx0Oy9ib2R5Jmd0OyZsdDsv aHRtbCZndDs8L3N0cmluZz4KKwkJPGtleT5XZWJSZXNvdXJjZUZyYW1lTmFtZTwva2V5PgorCQk8 c3RyaW5nPjwvc3RyaW5nPgorCQk8a2V5PldlYlJlc291cmNlTUlNRVR5cGU8L2tleT4KKwkJPHN0 cmluZz50ZXh0L2h0bWw8L3N0cmluZz4KKwkJPGtleT5XZWJSZXNvdXJjZVRleHRFbmNvZGluZ05h bWU8L2tleT4KKwkJPHN0cmluZz5VVEYtODwvc3RyaW5nPgorCQk8a2V5PldlYlJlc291cmNlVVJM PC9rZXk+CisJCTxzdHJpbmc+ZmlsZTovLy9MYXlvdXRUZXN0cy93ZWJhcmNoaXZlL3Rlc3QtY3Nz LWltcG9ydC5odG1sPC9zdHJpbmc+CisJPC9kaWN0PgorCTxrZXk+V2ViU3VicmVzb3VyY2VzPC9r ZXk+CisJPGFycmF5PgorCQk8ZGljdD4KKwkJCTxrZXk+V2ViUmVzb3VyY2VEYXRhPC9rZXk+CisJ CQk8c3RyaW5nPkBpbXBvcnQgdXJsKCd0ZXN0LWNzcy1saW5rLXJlY3Vyc2UuY3NzJyk7CisucmVk IHsgY29sb3I6IHJlZDsgfQorPC9zdHJpbmc+CisJCQk8a2V5PldlYlJlc291cmNlTUlNRVR5cGU8 L2tleT4KKwkJCTxzdHJpbmc+dGV4dC9jc3M8L3N0cmluZz4KKwkJCTxrZXk+V2ViUmVzb3VyY2VS ZXNwb25zZTwva2V5PgorCQkJPGRhdGE+CisJCQlZbkJzYVhOME1ERFVBUUlEQkFVR0J3cFpKR0Z5 WTJocGRtVnlXQ1IyWlhKemFXOXVWQ1IwCisJCQliM0JZSkc5aWFtVmpkSE5mRUE5T1UwdGxlV1Zr UVhKamFHbDJaWElTQUFHR29ORUlDVjhRCisJCQlFMWRsWWxKbGMyOTFjbU5sVW1WemNHOXVjMldB QWFRTERCc2NWU1J1ZFd4czF3ME9EeEFSCisJCQlFaE1VRlJZWEdCa1ZVaVF5VWlRelVpUTBVaVF3 VmlSamJHRnpjMUlrTlZJa01ZQUNnQUFRCisJCQlQeEFIZ0FNamYrLy8vLy8vLy8rQUFGaDBaWGgw TDJOemM5SWRIaDhnV0NSamJHRnpjMlZ6CisJCQlXaVJqYkdGemMyNWhiV1dpSUNGZFRsTlZVa3hT WlhOd2IyNXpaVmhPVTA5aWFtVmpkQWdSCisJCQlHeVFwTWtSSlRHSmthVzkrZ1lTSGlwR1VsNW1i bloraHFxeTF1c1BPMGQ4QUFBQUFBQUFCCisJCQlBUUFBQUFBQUFBQWlBQUFBQUFBQUFBQUFBQUFB QUFBQTZBPT0KKwkJCTwvZGF0YT4KKwkJCTxrZXk+V2ViUmVzb3VyY2VVUkw8L2tleT4KKwkJCTxz dHJpbmc+ZmlsZTovLy9MYXlvdXRUZXN0cy93ZWJhcmNoaXZlL3Jlc291cmNlcy90ZXN0LWNzcy1s aW5rLmNzczwvc3RyaW5nPgorCQk8L2RpY3Q+CisJCTxkaWN0PgorCQkJPGtleT5XZWJSZXNvdXJj ZURhdGE8L2tleT4KKwkJCTxzdHJpbmc+QGltcG9ydCB1cmwoJ3Rlc3QtY3NzLWxpbmstcmVjdXJz ZS5jc3MnKTsKKy5wdXJwbGUgeyBjb2xvcjogcHVycGxlOyB9Cis8L3N0cmluZz4KKwkJCTxrZXk+ V2ViUmVzb3VyY2VNSU1FVHlwZTwva2V5PgorCQkJPHN0cmluZz50ZXh0L2Nzczwvc3RyaW5nPgor CQkJPGtleT5XZWJSZXNvdXJjZVJlc3BvbnNlPC9rZXk+CisJCQk8ZGF0YT4KKwkJCVluQnNhWE4w TUREVUFRSURCQVVHQndwWkpHRnlZMmhwZG1WeVdDUjJaWEp6YVc5dVZDUjAKKwkJCWIzQllKRzlp YW1WamRITmZFQTlPVTB0bGVXVmtRWEpqYUdsMlpYSVNBQUdHb05FSUNWOFEKKwkJCUUxZGxZbEps YzI5MWNtTmxVbVZ6Y0c5dWMyV0FBYVFMREJzY1ZTUnVkV3hzMXcwT0R4QVIKKwkJCUVoTVVGUllY R0JrVlVpUXlVaVF6VWlRMFVpUXdWaVJqYkdGemMxSWtOVklrTVlBQ2dBQVEKKwkJCVJSQUhnQU1q ZisvLy8vLy8vLytBQUZoMFpYaDBMMk56YzlJZEhoOGdXQ1JqYkdGemMyVnoKKwkJCVdpUmpiR0Z6 YzI1aGJXV2lJQ0ZkVGxOVlVreFNaWE53YjI1elpWaE9VMDlpYW1WamRBZ1IKKwkJCUd5UXBNa1JK VEdKa2FXOStnWVNIaXBHVWw1bWJuWitocXF5MXVzUE8wZDhBQUFBQUFBQUIKKwkJCUFRQUFBQUFB QUFBaUFBQUFBQUFBQUFBQUFBQUFBQUFBNkE9PQorCQkJPC9kYXRhPgorCQkJPGtleT5XZWJSZXNv dXJjZVVSTDwva2V5PgorCQkJPHN0cmluZz5maWxlOi8vL0xheW91dFRlc3RzL3dlYmFyY2hpdmUv cmVzb3VyY2VzL3Rlc3QtY3NzLWxpbmstcmVjdXJzZS5jc3M8L3N0cmluZz4KKwkJPC9kaWN0Pgor CQk8ZGljdD4KKwkJCTxrZXk+V2ViUmVzb3VyY2VEYXRhPC9rZXk+CisJCQk8c3RyaW5nPkBpbXBv cnQgdXJsKCd0ZXN0LWNzcy1pbXBvcnQtcmVjdXJzZS5jc3MnKTsKKy5ibHVlIHsgY29sb3I6IGJs dWU7IH0KKzwvc3RyaW5nPgorCQkJPGtleT5XZWJSZXNvdXJjZU1JTUVUeXBlPC9rZXk+CisJCQk8 c3RyaW5nPnRleHQvY3NzPC9zdHJpbmc+CisJCQk8a2V5PldlYlJlc291cmNlUmVzcG9uc2U8L2tl eT4KKwkJCTxkYXRhPgorCQkJWW5Cc2FYTjBNRERVQVFJREJBVUdCd3BaSkdGeVkyaHBkbVZ5V0NS MlpYSnphVzl1VkNSMAorCQkJYjNCWUpHOWlhbVZqZEhOZkVBOU9VMHRsZVdWa1FYSmphR2wyWlhJ U0FBR0dvTkVJQ1Y4UQorCQkJRTFkbFlsSmxjMjkxY21ObFVtVnpjRzl1YzJXQUFhUUxEQnNjVlNS dWRXeHMxdzBPRHhBUgorCQkJRWhNVUZSWVhHQmtWVWlReVVpUXpVaVEwVWlRd1ZpUmpiR0Z6YzFJ a05WSWtNWUFDZ0FBUQorCQkJUXhBSGdBTWpmKy8vLy8vLy8vK0FBRmgwWlhoMEwyTnpjOUlkSGg4 Z1dDUmpiR0Z6YzJWegorCQkJV2lSamJHRnpjMjVoYldXaUlDRmRUbE5WVWt4U1pYTndiMjV6WlZo T1UwOWlhbVZqZEFnUgorCQkJR3lRcE1rUkpUR0prYVc5K2dZU0hpcEdVbDVtYm5aK2hxcXkxdXNQ TzBkOEFBQUFBQUFBQgorCQkJQVFBQUFBQUFBQUFpQUFBQUFBQUFBQUFBQUFBQUFBQUE2QT09CisJ CQk8L2RhdGE+CisJCQk8a2V5PldlYlJlc291cmNlVVJMPC9rZXk+CisJCQk8c3RyaW5nPmZpbGU6 Ly8vTGF5b3V0VGVzdHMvd2ViYXJjaGl2ZS9yZXNvdXJjZXMvdGVzdC1jc3MtaW1wb3J0LmNzczwv c3RyaW5nPgorCQk8L2RpY3Q+CisJCTxkaWN0PgorCQkJPGtleT5XZWJSZXNvdXJjZURhdGE8L2tl eT4KKwkJCTxzdHJpbmc+QGltcG9ydCB1cmwoJ3Rlc3QtY3NzLWltcG9ydC5jc3MnKTsKKy5ncmVl biB7IGNvbG9yOiBncmVlbjsgfQorPC9zdHJpbmc+CisJCQk8a2V5PldlYlJlc291cmNlTUlNRVR5 cGU8L2tleT4KKwkJCTxzdHJpbmc+dGV4dC9jc3M8L3N0cmluZz4KKwkJCTxrZXk+V2ViUmVzb3Vy Y2VSZXNwb25zZTwva2V5PgorCQkJPGRhdGE+CisJCQlZbkJzYVhOME1ERFVBUUlEQkFVR0J3cFpK R0Z5WTJocGRtVnlXQ1IyWlhKemFXOXVWQ1IwCisJCQliM0JZSkc5aWFtVmpkSE5mRUE5T1UwdGxl V1ZrUVhKamFHbDJaWElTQUFHR29ORUlDVjhRCisJCQlFMWRsWWxKbGMyOTFjbU5sVW1WemNHOXVj MldBQWFRTERCc2NWU1J1ZFd4czF3ME9EeEFSCisJCQlFaE1VRlJZWEdCa1ZVaVF5VWlRelVpUTBV aVF3VmlSamJHRnpjMUlrTlZJa01ZQUNnQUFRCisJCQlQUkFIZ0FNamYrLy8vLy8vLy8rQUFGaDBa WGgwTDJOemM5SWRIaDhnV0NSamJHRnpjMlZ6CisJCQlXaVJqYkdGemMyNWhiV1dpSUNGZFRsTlZV a3hTWlhOd2IyNXpaVmhPVTA5aWFtVmpkQWdSCisJCQlHeVFwTWtSSlRHSmthVzkrZ1lTSGlwR1Vs NW1ibloraHFxeTF1c1BPMGQ4QUFBQUFBQUFCCisJCQlBUUFBQUFBQUFBQWlBQUFBQUFBQUFBQUFB QUFBQUFBQTZBPT0KKwkJCTwvZGF0YT4KKwkJCTxrZXk+V2ViUmVzb3VyY2VVUkw8L2tleT4KKwkJ CTxzdHJpbmc+ZmlsZTovLy9MYXlvdXRUZXN0cy93ZWJhcmNoaXZlL3Jlc291cmNlcy90ZXN0LWNz cy1pbXBvcnQtcmVjdXJzZS5jc3M8L3N0cmluZz4KKwkJPC9kaWN0PgorCTwvYXJyYXk+Cis8L2Rp Y3Q+Cis8L3BsaXN0PgpJbmRleDogTGF5b3V0VGVzdHMvd2ViYXJjaGl2ZS90ZXN0LWNzcy1pbXBv cnQuaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy93ZWJhcmNoaXZlL3Rlc3QtY3NzLWlt cG9ydC5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvd2ViYXJjaGl2ZS90ZXN0LWNz cy1pbXBvcnQuaHRtbAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwxOCBAQAorPGh0bWw+Cis8aGVh ZD4KKzxzY3JpcHQ+CisgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICAg ICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzV2ViQXJjaGl2ZSgpOworPC9zY3JpcHQ+Cis8 bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9InJlc291cmNlcy90ZXN0LWNzcy1saW5rLmNzcyIg dHlwZT0idGV4dC9jc3MiPgorPHN0eWxlIHR5cGU9InRleHQvY3NzIj4KKzwhLS0gQGltcG9ydCB1 cmwoJ3Jlc291cmNlcy90ZXN0LWNzcy1pbXBvcnQuY3NzJyk7IC0tPgorPC9zdHlsZT4KKzwvaGVh ZD4KKzxib2R5PgorPGRpdiBjbGFzcz0iYmx1ZSI+VGhpcyB0ZXh0IHNob3VsZCBiZSBibHVlLjwv ZGl2PgorPGRpdiBjbGFzcz0icmVkIj5UaGlzIHRleHQgc2hvdWxkIGJlIHJlZC48L2Rpdj4KKzxk aXYgY2xhc3M9ImdyZWVuIj5UaGlzIHRleHQgc2hvdWxkIGJlIGdyZWVuLjwvZGl2PgorPGRpdiBj bGFzcz0icHVycGxlIj5UaGlzIHRleHQgc2hvdWxkIGJlIHB1cnBsZS48L2Rpdj4KKzwvYm9keT4K KzwvaHRtbD4KSW5kZXg6IExheW91dFRlc3RzL3dlYmFyY2hpdmUvcmVzb3VyY2VzL3Rlc3QtY3Nz LWltcG9ydC1yZWN1cnNlLmNzcwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy93ZWJhcmNoaXZl L3Jlc291cmNlcy90ZXN0LWNzcy1pbXBvcnQtcmVjdXJzZS5jc3MJKHJldmlzaW9uIDApCisrKyBM YXlvdXRUZXN0cy93ZWJhcmNoaXZlL3Jlc291cmNlcy90ZXN0LWNzcy1pbXBvcnQtcmVjdXJzZS5j c3MJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMiBAQAorQGltcG9ydCB1cmwoJ3Rlc3QtY3NzLWlt cG9ydC5jc3MnKTsKKy5ncmVlbiB7IGNvbG9yOiBncmVlbjsgfQpJbmRleDogTGF5b3V0VGVzdHMv d2ViYXJjaGl2ZS9yZXNvdXJjZXMvdGVzdC1jc3MtaW1wb3J0LmNzcwo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBM YXlvdXRUZXN0cy93ZWJhcmNoaXZlL3Jlc291cmNlcy90ZXN0LWNzcy1pbXBvcnQuY3NzCShyZXZp c2lvbiAwKQorKysgTGF5b3V0VGVzdHMvd2ViYXJjaGl2ZS9yZXNvdXJjZXMvdGVzdC1jc3MtaW1w b3J0LmNzcwkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwyIEBACitAaW1wb3J0IHVybCgndGVzdC1j c3MtaW1wb3J0LXJlY3Vyc2UuY3NzJyk7CisuYmx1ZSB7IGNvbG9yOiBibHVlOyB9CkluZGV4OiBM YXlvdXRUZXN0cy93ZWJhcmNoaXZlL3Jlc291cmNlcy90ZXN0LWNzcy1saW5rLXJlY3Vyc2UuY3Nz Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL3dlYmFyY2hpdmUvcmVzb3VyY2VzL3Rlc3QtY3Nz LWxpbmstcmVjdXJzZS5jc3MJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy93ZWJhcmNoaXZl L3Jlc291cmNlcy90ZXN0LWNzcy1saW5rLXJlY3Vyc2UuY3NzCShyZXZpc2lvbiAwKQpAQCAtMCww ICsxLDIgQEAKK0BpbXBvcnQgdXJsKCd0ZXN0LWNzcy1saW5rLXJlY3Vyc2UuY3NzJyk7CisucHVy cGxlIHsgY29sb3I6IHB1cnBsZTsgfQpJbmRleDogTGF5b3V0VGVzdHMvd2ViYXJjaGl2ZS9yZXNv dXJjZXMvdGVzdC1jc3MtbGluay5jc3MKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvd2ViYXJj aGl2ZS9yZXNvdXJjZXMvdGVzdC1jc3MtbGluay5jc3MJKHJldmlzaW9uIDApCisrKyBMYXlvdXRU ZXN0cy93ZWJhcmNoaXZlL3Jlc291cmNlcy90ZXN0LWNzcy1saW5rLmNzcwkocmV2aXNpb24gMCkK QEAgLTAsMCArMSwyIEBACitAaW1wb3J0IHVybCgndGVzdC1jc3MtbGluay1yZWN1cnNlLmNzcycp OworLnJlZCB7IGNvbG9yOiByZWQ7IH0KSW5kZXg6IFdlYktpdC9DaGFuZ2VMb2cKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gV2ViS2l0L0NoYW5nZUxvZwkocmV2aXNpb24gMTkzOTUpCisrKyBXZWJLaXQvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMjIgQEAKKzIwMDctMDItMDQgIERhdmlkIEtp bHplciAgPGRka2lsemVyQHdlYmtpdC5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgLSBmaXggaHR0cDovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MTE4MzkKKyAgICAgICAgV2ViYXJjaGl2ZSBmYWlscyB0byBzYXZlIENTUyBmaWxl cyBpbiBAaW1wb3J0IHN0YXRlbWVudHMKKworICAgICAgICBUZXN0OiB3ZWJhcmNoaXZlL3Rlc3Qt Y3NzLWltcG9ydC5odG1sCisKKyAgICAgICAgKiBET00vV2ViRE9NT3BlcmF0aW9ucy5tbToKKyAg ICAgICAgKC1bRE9NTm9kZSBfVVJMc0Zyb21TZWxlY3RvcnM6XSk6IFN0eWxlIGZpeGVzLgorICAg ICAgICAoLVtET01DU1NTdHlsZVNoZWV0IF9hZGRTdWJyZXNvdXJjZVVSTHNUb0FycmF5OndpdGhC YXNlVVJMOl0pOiBBZGRlZC4gIFJlY3Vyc2l2ZWx5IGZpbmRzIEBpbXBvcnQKKyAgICAgICAgc3Rh dGVtZW50cyBpbiBDU1MgZmlsZXMgdXNpbmcgYW4gaXRlcmF0aXZlIGFsZ29yaXRobSBhbmQgYWRk cyBlYWNoIFVSTCB0byB0aGUgbGlzdC4KKyAgICAgICAgKC1bRE9NSFRNTExpbmtFbGVtZW50IF9z dWJyZXNvdXJjZVVSTHNdKTogQ2FsbHMgX2FkZFN1YnJlc291cmNlVVJMc1RvQXJyYXk6d2l0aEJh c2VVUkw6IHRvIGZpbmQKKyAgICAgICAgYWRkaXRpb25hbCBpbXBvcnRlZCBzdHlsZXNoZWV0cy4K KyAgICAgICAgKC1bRE9NSFRNTFN0eWxlRWxlbWVudCBfc3VicmVzb3VyY2VVUkxzXSk6IEFkZGVk LiAgRGl0dG8uCisgICAgICAgICogRE9NL1dlYkRPTU9wZXJhdGlvbnNJbnRlcm5hbC5oOiBBZGRl ZC4gIEhvbWUgb2YgRE9NQ1NTU3R5bGVTaGVldCBfYWRkU3VicmVzb3VyY2VVUkxzVG9BcnJheTp3 aXRoQmFzZVVSTDouCisgICAgICAgICogV2ViS2l0Lnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2o6 IEFkZGVkIERPTS9XZWJET01PcGVyYXRpb25zSW50ZXJuYWwuaC4KKwogMjAwNy0wMi0wMSAgR2Vv ZmZyZXkgR2FyZW4gIDxnZ2FyZW5AYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IE1h Y2llaiBTdGFjaG93aWFrLgpJbmRleDogV2ViS2l0L0RPTS9XZWJET01PcGVyYXRpb25zLm1tCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFdlYktpdC9ET00vV2ViRE9NT3BlcmF0aW9ucy5tbQkocmV2aXNpb24gMTkz OTUpCisrKyBXZWJLaXQvRE9NL1dlYkRPTU9wZXJhdGlvbnMubW0JKHdvcmtpbmcgY29weSkKQEAg LTEsNSArMSw1IEBACiAvKgotICogQ29weXJpZ2h0IChDKSAyMDA1IEFwcGxlIENvbXB1dGVyLCBJ bmMuICBBbGwgcmlnaHRzIHJlc2VydmVkLgorICogQ29weXJpZ2h0IChDKSAyMDA1LCAyMDA3IEFw cGxlLCBJbmMuICBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFu ZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAogICogbW9k aWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25k aXRpb25zCkBAIC0yNiw2ICsyNiw4IEBACiAgKiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklT RUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgogICovCiAKKyNpbXBvcnQgIldl YkRPTU9wZXJhdGlvbnNJbnRlcm5hbC5oIgorCiAjaW1wb3J0IDxXZWJLaXQvV2ViRE9NT3BlcmF0 aW9uc1ByaXZhdGUuaD4KIAogI2ltcG9ydCA8V2ViS2l0L0RPTUV4dGVuc2lvbnMuaD4KQEAgLTY1 LDkgKzY3LDggQEAKICAgICBTRUwgc2VsZWN0b3IgPSBmaXJzdFNlbDsKICAgICBkbyB7CiAgICAg ICAgIE5TU3RyaW5nICpzdHJpbmcgPSBbc2VsZiBwZXJmb3JtU2VsZWN0b3I6c2VsZWN0b3JdOwot ICAgICAgICBpZiAoW3N0cmluZyBsZW5ndGhdID4gMCkgeworICAgICAgICBpZiAoW3N0cmluZyBs ZW5ndGhdKQogICAgICAgICAgICAgW1VSTHMgYWRkT2JqZWN0Oltbc2VsZiBvd25lckRvY3VtZW50 XSBVUkxXaXRoQXR0cmlidXRlU3RyaW5nOnN0cmluZ11dOwotICAgICAgICB9CiAgICAgfSB3aGls ZSAoKHNlbGVjdG9yID0gdmFfYXJnKGFyZ3MsIFNFTCkpICE9IG5pbCk7CiAgICAgCiAgICAgdmFf ZW5kKGFyZ3MpOwpAQCAtMTMxLDYgKzEzMiw0NyBAQAogCiBAZW5kCiAKK0BpbXBsZW1lbnRhdGlv biBET01DU1NTdHlsZVNoZWV0IChXZWJET01DU1NTdHlsZVNoZWV0T3BlcmF0aW9uc0ludGVybmFs KQorCistICh2b2lkKV9hZGRTdWJyZXNvdXJjZVVSTHNUb0FycmF5OihOU011dGFibGVBcnJheSAq KVVSTHMgd2l0aEJhc2VVUkw6KE5TVVJMICopVVJMCit7CisgICAgTlNNdXRhYmxlU2V0ICpVUkxM aXN0ID0gW05TTXV0YWJsZVNldCBzZXRXaXRoQ2FwYWNpdHk6W1VSTHMgY291bnRdXTsKKyAgICBb VVJMTGlzdCBhZGRPYmplY3RzRnJvbUFycmF5OlVSTHNdOworCisgICAgTlNNdXRhYmxlQXJyYXkg KnNoZWV0TGlzdCA9IFtOU011dGFibGVBcnJheSBhcnJheVdpdGhDYXBhY2l0eToxXTsKKyAgICBb c2hlZXRMaXN0IGFkZE9iamVjdDpzZWxmXTsKKyAgICBOU011dGFibGVBcnJheSAqYmFzZVVSTExp c3QgPSBbTlNNdXRhYmxlQXJyYXkgYXJyYXlXaXRoQ2FwYWNpdHk6MV07CisgICAgW2Jhc2VVUkxM aXN0IGFkZE9iamVjdDpVUkxdOworCisgICAgd2hpbGUgKFtzaGVldExpc3QgY291bnRdKSB7Cisg ICAgICAgIERPTUNTU1N0eWxlU2hlZXQgKnNoZWV0ID0gW3NoZWV0TGlzdCBvYmplY3RBdEluZGV4 OjBdOworICAgICAgICBbc2hlZXRMaXN0IHJlbW92ZU9iamVjdEF0SW5kZXg6MF07CisgICAgICAg IE5TVVJMICpiYXNlVVJMID0gW2Jhc2VVUkxMaXN0IG9iamVjdEF0SW5kZXg6MF07CisgICAgICAg IFtiYXNlVVJMTGlzdCByZW1vdmVPYmplY3RBdEluZGV4OjBdOworCisgICAgICAgIERPTUNTU1J1 bGVMaXN0ICpydWxlcyA9IFtzaGVldCBjc3NSdWxlc107CisgICAgICAgIGZvciAoaW50IGkgPSAw LCBtYXggPSBbcnVsZXMgbGVuZ3RoXTsgaSA8IG1heDsgaSsrKSB7CisgICAgICAgICAgICBET01D U1NSdWxlICpydWxlID0gW3J1bGVzIGl0ZW06aV07CisgICAgICAgICAgICBpZiAoW3J1bGUgdHlw ZV0gPT0gRE9NX0lNUE9SVF9SVUxFKSB7CisgICAgICAgICAgICAgICAgRE9NQ1NTSW1wb3J0UnVs ZSAqaW1wb3J0UnVsZSA9IChET01DU1NJbXBvcnRSdWxlICopcnVsZTsgCisgICAgICAgICAgICAg ICAgTlNTdHJpbmcgKmltcG9ydGVkU3R5bGVzaGVldFVSTFN0cmluZyA9IFtpbXBvcnRSdWxlIGhy ZWZdOworICAgICAgICAgICAgICAgIGlmIChbaW1wb3J0ZWRTdHlsZXNoZWV0VVJMU3RyaW5nIGxl bmd0aF0pIHsKKyAgICAgICAgICAgICAgICAgICAgTlNVUkwgKmltcG9ydGVkU3R5bGVzaGVldFVS TCA9IFtbTlNVUkwgVVJMV2l0aFN0cmluZzppbXBvcnRlZFN0eWxlc2hlZXRVUkxTdHJpbmcgcmVs YXRpdmVUb1VSTDpiYXNlVVJMXSBhYnNvbHV0ZVVSTF07CisgICAgICAgICAgICAgICAgICAgIGlm ICghW1VSTExpc3QgY29udGFpbnNPYmplY3Q6aW1wb3J0ZWRTdHlsZXNoZWV0VVJMXSkgeworICAg ICAgICAgICAgICAgICAgICAgICAgW1VSTExpc3QgYWRkT2JqZWN0OmltcG9ydGVkU3R5bGVzaGVl dFVSTF07CisgICAgICAgICAgICAgICAgICAgICAgICBbc2hlZXRMaXN0IGFkZE9iamVjdDpbaW1w b3J0UnVsZSBzdHlsZVNoZWV0XV07CisgICAgICAgICAgICAgICAgICAgICAgICBbYmFzZVVSTExp c3QgYWRkT2JqZWN0OmltcG9ydGVkU3R5bGVzaGVldFVSTF07CisgICAgICAgICAgICAgICAgICAg IH0KKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICB9CisK KyAgICBbVVJMcyBzZXRBcnJheTpbVVJMTGlzdCBhbGxPYmplY3RzXV07Cit9CisKK0BlbmQKKwog QGltcGxlbWVudGF0aW9uIERPTUhUTUxCb2R5RWxlbWVudCAoV2ViRE9NSFRNTEJvZHlFbGVtZW50 T3BlcmF0aW9uc1ByaXZhdGUpCiAKIC0gKE5TQXJyYXkgKilfc3VicmVzb3VyY2VVUkxzCkBAIC0x NTQsMTQgKzE5NiwzNyBAQAogLSAoTlNBcnJheSAqKV9zdWJyZXNvdXJjZVVSTHMKIHsKICAgICBO U1N0cmluZyAqcmVsTmFtZSA9IFtzZWxmIHJlbF07Ci0gICAgaWYgKFtyZWxOYW1lIF93ZWJraXRf aXNDYXNlSW5zZW5zaXRpdmVFcXVhbFRvU3RyaW5nOkAic3R5bGVzaGVldCJdIHx8IFtyZWxOYW1l IF93ZWJraXRfaXNDYXNlSW5zZW5zaXRpdmVFcXVhbFRvU3RyaW5nOkAiaWNvbiJdKSB7CisKKyAg ICBpZiAoW3JlbE5hbWUgX3dlYmtpdF9pc0Nhc2VJbnNlbnNpdGl2ZUVxdWFsVG9TdHJpbmc6QCJp Y29uIl0pCiAgICAgICAgIHJldHVybiBbc2VsZiBfVVJMc0Zyb21TZWxlY3RvcnM6QHNlbGVjdG9y KGhyZWYpLCBuaWxdOworCisgICAgaWYgKFtyZWxOYW1lIF93ZWJraXRfaXNDYXNlSW5zZW5zaXRp dmVFcXVhbFRvU3RyaW5nOkAic3R5bGVzaGVldCJdKSB7CisgICAgICAgIE5TVVJMICpzdHlsZXNo ZWV0VVJMID0gW1tzZWxmIF9VUkxzRnJvbVNlbGVjdG9yczpAc2VsZWN0b3IoaHJlZiksIG5pbF0g b2JqZWN0QXRJbmRleDowXTsKKyAgICAgICAgTlNNdXRhYmxlQXJyYXkgKlVSTHMgPSBbTlNNdXRh YmxlQXJyYXkgYXJyYXlXaXRoQ2FwYWNpdHk6MV07CisgICAgICAgIFtVUkxzIGFkZE9iamVjdDpz dHlsZXNoZWV0VVJMXTsKKyAgICAgICAgRE9NQ1NTU3R5bGVTaGVldCAqc2hlZXQgPSAoRE9NQ1NT U3R5bGVTaGVldCAqKVtzZWxmIHNoZWV0XTsKKyAgICAgICAgW3NoZWV0IF9hZGRTdWJyZXNvdXJj ZVVSTHNUb0FycmF5OlVSTHMgd2l0aEJhc2VVUkw6c3R5bGVzaGVldFVSTF07CisgICAgICAgIHJl dHVybiBVUkxzOwogICAgIH0KKwogICAgIHJldHVybiBuaWw7CiB9CiAKIEBlbmQKIAorQGltcGxl bWVudGF0aW9uIERPTUhUTUxTdHlsZUVsZW1lbnQgKFdlYkRPTUhUTUxTdHlsZUVsZW1lbnRPcGVy YXRpb25zUHJpdmF0ZSkKKworLSAoTlNBcnJheSAqKV9zdWJyZXNvdXJjZVVSTHMKK3sKKyAgICBO U011dGFibGVBcnJheSAqVVJMcyA9IFtOU011dGFibGVBcnJheSBhcnJheV07CisgICAgRE9NQ1NT U3R5bGVTaGVldCAqc2hlZXQgPSAoRE9NQ1NTU3R5bGVTaGVldCAqKVtzZWxmIHNoZWV0XTsKKyAg ICBOU1VSTCAqYmFzZVVSTCA9IFtbW3NlbGYgb3duZXJEb2N1bWVudF0gX2JyaWRnZV0gYmFzZVVS TF07CisgICAgW3NoZWV0IF9hZGRTdWJyZXNvdXJjZVVSTHNUb0FycmF5OlVSTHMgd2l0aEJhc2VV Ukw6YmFzZVVSTF07CisgICAgcmV0dXJuIFVSTHM7Cit9CisKK0BlbmQKKwogQGltcGxlbWVudGF0 aW9uIERPTUhUTUxTY3JpcHRFbGVtZW50IChXZWJET01IVE1MU2NyaXB0RWxlbWVudE9wZXJhdGlv bnNQcml2YXRlKQogCiAtIChOU0FycmF5ICopX3N1YnJlc291cmNlVVJMcwpJbmRleDogV2ViS2l0 L0RPTS9XZWJET01PcGVyYXRpb25zSW50ZXJuYWwuaAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvRE9N L1dlYkRPTU9wZXJhdGlvbnNJbnRlcm5hbC5oCShyZXZpc2lvbiAwKQorKysgV2ViS2l0L0RPTS9X ZWJET01PcGVyYXRpb25zSW50ZXJuYWwuaAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwzNSBAQAor LyoKKyAqIENvcHlyaWdodCAoQykgMjAwNyBBcHBsZSwgSW5jLiAgQWxsIHJpZ2h0cyByZXNlcnZl ZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZv cm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92 aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqCisgKiAx LiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBj b3B5cmlnaHQKKyAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIuIAorICogMi4gIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkg Zm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICAgbm90aWNlLCB0 aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRo ZQorICogICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3 aXRoIHRoZSBkaXN0cmlidXRpb24uIAorICogMy4gIE5laXRoZXIgdGhlIG5hbWUgb2YgQXBwbGUg Q29tcHV0ZXIsIEluYy4gKCJBcHBsZSIpIG5vciB0aGUgbmFtZXMgb2YKKyAqICAgICBpdHMgY29u dHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJp dmVkCisgKiAgICAgZnJvbSB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3Jp dHRlbiBwZXJtaXNzaW9uLiAKKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQ UExFIEFORCBJVFMgQ09OVFJJQlVUT1JTICJBUyBJUyIgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJ TVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1Q TElFRAorICogV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEg UEFSVElDVUxBUiBQVVJQT1NFIEFSRQorICogRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwg QVBQTEUgT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWQorICogRElSRUNULCBJ TkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFM IERBTUFHRVMKKyAqIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQg T0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsKKyAqIExPU1MgT0YgVVNFLCBEQVRBLCBP UiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORAor ICogT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklD VCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJ U0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRgorICogVEhJUyBTT0ZUV0FS RSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAq LworCisjaW1wb3J0IDxXZWJLaXQvV2ViRE9NT3BlcmF0aW9ucy5oPgorCisjaW1wb3J0IDxXZWJL aXQvRE9NQ1NTU3R5bGVTaGVldC5oPgorCitAaW50ZXJmYWNlIERPTUNTU1N0eWxlU2hlZXQgKFdl YkRPTUNTU1N0eWxlU2hlZXRPcGVyYXRpb25zSW50ZXJuYWwpCistICh2b2lkKV9hZGRTdWJyZXNv dXJjZVVSTHNUb0FycmF5OihOU011dGFibGVBcnJheSAqKVVSTHMgd2l0aEJhc2VVUkw6KE5TVVJM ICopYmFzZVVSTDsKK0BlbmQKSW5kZXg6IFdlYktpdC9XZWJLaXQueGNvZGVwcm9qL3Byb2plY3Qu cGJ4cHJvago9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvV2ViS2l0Lnhjb2RlcHJvai9wcm9qZWN0LnBi eHByb2oJKHJldmlzaW9uIDE5Mzk1KQorKysgV2ViS2l0L1dlYktpdC54Y29kZXByb2ovcHJvamVj dC5wYnhwcm9qCSh3b3JraW5nIGNvcHkpCkBAIC00Miw2ICs0Miw3IEBACiAJCTIyRTQyQTRGMEE1 QjlGNjIwMDAzMjc1QiAvKiBPcGVuR0wuZnJhbWV3b3JrIGluIEZyYW1ld29ya3MgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMjJFNDJBNEUwQTVCOUY2MjAwMDMyNzVCIC8qIE9w ZW5HTC5mcmFtZXdvcmsgKi87IH07CiAJCTIyRTQyQTlBMEE1QkE0RDAwMDAzMjc1QiAvKiBBR0wu ZnJhbWV3b3JrIGluIEZyYW1ld29ya3MgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVm ID0gMjJFNDJBOTkwQTVCQTREMDAwMDMyNzVCIC8qIEFHTC5mcmFtZXdvcmsgKi87IH07CiAJCTIy RjIxOUNDMDhEMjM2NzMwMDMwRTA3OCAvKiBXZWJCYWNrRm9yd2FyZExpc3RQcml2YXRlLmggaW4g SGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAyMkYyMTlDQjA4RDIz NjczMDAzMEUwNzggLyogV2ViQmFja0ZvcndhcmRMaXN0UHJpdmF0ZS5oICovOyBzZXR0aW5ncyA9 IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CisJCTNBODIxQUEwMEI3NkEzNjUwMDBB M0M1MiAvKiBXZWJET01PcGVyYXRpb25zSW50ZXJuYWwuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9 IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDNBODIxQTlGMEI3NkEzNjUwMDBBM0M1MiAvKiBXZWJE T01PcGVyYXRpb25zSW50ZXJuYWwuaCAqLzsgfTsKIAkJNEJGOTlGOTAwQUUwNTBCQzAwODE1QzJC IC8qIFdlYkVkaXRvckNsaWVudC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxl OyBmaWxlUmVmID0gNEJGOTlGOEUwQUUwNTBCQzAwODE1QzJCIC8qIFdlYkVkaXRvckNsaWVudC5o ICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKCk7IH07IH07CiAJCTRCRjk5RjkxMEFFMDUw QkMwMDgxNUMyQiAvKiBXZWJFZGl0b3JDbGllbnQubW0gaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQ QlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0QkY5OUY4RjBBRTA1MEJDMDA4MTVDMkIgLyogV2ViRWRp dG9yQ2xpZW50Lm1tICovOyB9OwogCQk1MUIyQTEwMDBBREIxNUQwMDAyQTlCRUUgLyogV2ViSWNv bkRhdGFiYXNlRGVsZWdhdGUuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsg ZmlsZVJlZiA9IDUxQjJBMEZGMEFEQjE1RDAwMDJBOUJFRSAvKiBXZWJJY29uRGF0YWJhc2VEZWxl Z2F0ZS5oICovOyB9OwpAQCAtMzY3LDYgKzM2OCw3IEBACiAJCTM5NDQ2MDdFMDIwRjUwRUQwRUNB MTc2NyAvKiBXZWJCYWNrRm9yd2FyZExpc3QubW0gKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5j ZTsgZmlsZUVuY29kaW5nID0gMzA7IGluZGVudFdpZHRoID0gNDsgbGFzdEtub3duRmlsZVR5cGUg PSBzb3VyY2Vjb2RlLmNwcC5vYmpjcHA7IHBhdGggPSBXZWJCYWNrRm9yd2FyZExpc3QubW07IHNv dXJjZVRyZWUgPSAiPGdyb3VwPiI7IHRhYldpZHRoID0gODsgdXNlc1RhYnMgPSAwOyB9OwogCQkz OTQ0NjA3RjAyMEY1MEVEMEVDQTE3NjcgLyogV2ViSGlzdG9yeUl0ZW0uaCAqLyA9IHtpc2EgPSBQ QlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsgaW5kZW50V2lkdGggPSA0OyBsYXN0 S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gV2ViSGlzdG9yeUl0ZW0uaDsg c291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgdGFiV2lkdGggPSA4OyB1c2VzVGFicyA9IDA7IH07CiAJ CTM5NDQ2MDgwMDIwRjUwRUQwRUNBMTc2NyAvKiBXZWJIaXN0b3J5SXRlbS5tbSAqLyA9IHtpc2Eg PSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsgaW5kZW50V2lkdGggPSA0OyBs YXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9IFdlYkhpc3Rv cnlJdGVtLm1tOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB0YWJXaWR0aCA9IDg7IHVzZXNUYWJz ID0gMDsgfTsKKwkJM0E4MjFBOUYwQjc2QTM2NTAwMEEzQzUyIC8qIFdlYkRPTU9wZXJhdGlvbnNJ bnRlcm5hbC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMw OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gV2ViRE9NT3BlcmF0 aW9uc0ludGVybmFsLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTRCRjk5RjhFMEFF MDUwQkMwMDgxNUMyQiAvKiBXZWJFZGl0b3JDbGllbnQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVm ZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2Rl LmMuaDsgcGF0aCA9IFdlYkVkaXRvckNsaWVudC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9 OwogCQk0QkY5OUY4RjBBRTA1MEJDMDA4MTVDMkIgLyogV2ViRWRpdG9yQ2xpZW50Lm1tICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9IFdlYkVkaXRvckNsaWVudC5tbTsg c291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNTEzRDQyMkUwMzRDRjU1QTAwQ0EyQUNEIC8q IFdlYlJlc291cmNlTG9hZERlbGVnYXRlLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsg ZmlsZUVuY29kaW5nID0gMzA7IGluZGVudFdpZHRoID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBz b3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFdlYlJlc291cmNlTG9hZERlbGVnYXRlLmg7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IHRhYldpZHRoID0gODsgdXNlc1RhYnMgPSAwOyB9OwpAQCAtOTcxLDYg Kzk3Myw3IEBACiAJCQlpc2EgPSBQQlhHcm91cDsKIAkJCWNoaWxkcmVuID0gKAogCQkJCTg0NjE3 MUY5MDYyNEFFNUIwMDcxQTRBMyAvKiBXZWJET01PcGVyYXRpb25zLmggKi8sCisJCQkJM0E4MjFB OUYwQjc2QTM2NTAwMEEzQzUyIC8qIFdlYkRPTU9wZXJhdGlvbnNJbnRlcm5hbC5oICovLAogCQkJ CTg0QUU5MDVGMDYyREU2QTgwMDc1QkJGOSAvKiBXZWJET01PcGVyYXRpb25zUHJpdmF0ZS5oICov LAogCQkJCTg0NjE3MUZBMDYyNEFFNUIwMDcxQTRBMyAvKiBXZWJET01PcGVyYXRpb25zLm1tICov LAogCQkJKTsKQEAgLTEyNDQsNiArMTI0Nyw3IEBACiAJCQkJNTFDNzE0RkIwQjIwRjc5RjAwRTVF MzNDIC8qIFdlYkJhY2tGb3J3YXJkTGlzdEludGVybmFsLmggaW4gSGVhZGVycyAqLywKIAkJCQlB NzA5MzZBRjBCNTYwOERDMDBDREI0OEUgLyogV2ViRHJhZ0NsaWVudC5oIGluIEhlYWRlcnMgKi8s CiAJCQkJQTdEM0M1QkMwQjU3NzNDNTAwMkNBNDUwIC8qIFdlYlBhc3RlYm9hcmRIZWxwZXIuaCBp biBIZWFkZXJzICovLAorCQkJCTNBODIxQUEwMEI3NkEzNjUwMDBBM0M1MiAvKiBXZWJET01PcGVy YXRpb25zSW50ZXJuYWwuaCBpbiBIZWFkZXJzICovLAogCQkJKTsKIAkJCXJ1bk9ubHlGb3JEZXBs b3ltZW50UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9Owo=