37765 2010-04-18 00:10:27 -0700 REGRESSION(57531): the commit-queue still hates Tor Arne Vestbø 2010-04-22 22:26:27 -0700 1 1 1 Unclassified WebKit Tools / Tests 528+ (Nightly build) PC OS X 10.5 RESOLVED FIXED P2 Normal --- 37965 35288 37044 37587 37588 37763 1 eric webkit-unassigned abarth cjerdonek dpranke eric jamesr levin tony ukai vestbo webkit.review.bot yuzo oldest_to_newest 213722 0 eric 2010-04-18 00:10:27 -0700 REGRESSION(57531): the commit-queue still hates Tor Arne Vestbø I fixed the commit-queue ignoring Tor as a reviewer, but now it throws an exception every time it tries to land a patch with his name in it. I created this bug by hand due to bug 37764. :( 213728 1 cjerdonek 2010-04-18 02:09:47 -0700 I'm not sure if code like this will solve it: http://trac.webkit.org/browser/trunk/WebKitTools/Scripts/webkitpy/style/checker.py?rev=57467#L564 Whatever the answer is, we may want to expose the necessary helper methods in webkitpy/common/ since we should probably be supporting unicode characters across the board. 213729 2 eric 2010-04-18 02:14:34 -0700 I've now coded up two versions of this patch. Both have failed in different places. :( Unicode = trail of tears. The first version tried to deploy use of the unicode() class more widely. That ran into trouble because we will have to change a bunch of places to be more unicode() aware and correctly encode to utf-8 before calling things like file.write(). The second version tried to remove use of the unicode() class from our codebase and instead just encode Tor's name in utf8 in a str() object. Turns out that fails too, because if you call str("Tor Arne Vestb\xC3\xB8").encode("utf8") python notices that \xC3 is not a valid ascii character and throws an exception. So it seems like python is forcing us towards using unicode(). That's just gonna hurt. A lot. 213732 3 eric 2010-04-18 02:20:44 -0700 http://farmdev.com/talks/unicode/ is really pushing unicode() Not sure I'm ready for the koolaid. 213734 4 eric 2010-04-18 02:25:48 -0700 OK. I think I'm maybe convinced. We should take the unicode dive. I will need a few hours and a good stiff drink. Maybe monday. 213735 5 cjerdonek 2010-04-18 02:29:29 -0700 (In reply to comment #4) > OK. I think I'm maybe convinced. > > We should take the unicode dive. I will need a few hours and a good stiff > drink. Maybe monday. Briefly, what's the pain point? 213736 6 eric 2010-04-18 02:47:51 -0700 (In reply to comment #5) > > We should take the unicode dive. I will need a few hours and a good stiff > > drink. Maybe monday. > > Briefly, what's the pain point? What do you mean? 213738 7 cjerdonek 2010-04-18 02:55:08 -0700 (In reply to comment #6) > > Briefly, what's the pain point? > > What do you mean? I was just asking if you could explain briefly why it will hurt so much to start using it more widely (as you say below). And will that be true even if we use it just in the places we really need it? > So it seems like python is forcing us towards using unicode(). That's just > gonna hurt. A lot. 213739 8 eric 2010-04-18 03:00:23 -0700 Every place that we log, call print, or call write we will need to encode. Many of our unit tests will need unicode versions added (eventually). Every time we open a file or read off the network (when we're not using BeautifulSoup) we will need to document what encoding we expect. Totally doable. Just will be a large change. Looking at it now. 213743 9 53625 eric 2010-04-18 04:14:28 -0700 Created attachment 53625 Patch 213744 10 53625 eric 2010-04-18 04:15:14 -0700 Comment on attachment 53625 Patch I'm sure this change will break things. We'll fix them when we find where it broke stuff. 213745 11 webkit.review.bot 2010-04-18 04:20:48 -0700 Attachment 53625 did not pass style-queue: Failed to run "WebKitTools/Scripts/check-webkit-style" exit_code: 1 WebKitTools/Scripts/webkitpy/common/net/buildbot.py:413: whitespace before ':' [pep8/E203] [5] WebKitTools/Scripts/webkitpy/common/system/autoinstall.py:127: at least two spaces before inline comment [pep8/E261] [5] WebKitTools/Scripts/webkitpy/tool/steps/postdiff.py:47: at least two spaces before inline comment [pep8/E261] [5] WebKitTools/Scripts/webkitpy/tool/commands/upload.py:265: at least two spaces before inline comment [pep8/E261] [5] WebKitTools/Scripts/webkitpy/tool/commands/upload.py:407: at least two spaces before inline comment [pep8/E261] [5] WebKitTools/Scripts/webkitpy/tool/commands/upload.py:427: at least two spaces before inline comment [pep8/E261] [5] Total errors found: 6 in 24 files If any of these errors are false positives, please file a bug against check-webkit-style. 213746 12 53625 eric 2010-04-18 04:38:02 -0700 Comment on attachment 53625 Patch Nope, not quite there. Will post a better patch in teh morning. 213748 13 53626 eric 2010-04-18 04:59:06 -0700 Created attachment 53626 Patch 213749 14 eric 2010-04-18 05:00:10 -0700 I think this one finally works. I ended up having to rip out a bunch of StringIO plumbing. Basically every time we use StringIO, we have to be sure to encode the unicode string to a utf-8 byte array so that StringIO can vend back byte arrays via its read() method. 213779 15 cjerdonek 2010-04-18 10:41:18 -0700 Thanks for taking this on and looking into this, Eric. (Good slide show in comment 3, btw.) A couple random comments before a couple comments on the patch: (1) As the slides suggest, we may want to consider decoding using "utf-8-sig" as a general practice instead of "utf-8": "To increase the reliability with which a UTF-8 encoding can be detected, Microsoft invented a variant of UTF-8 (that Python 2.5 calls "utf-8-sig").... Before any of the Unicode characters is written to the file, a UTF-8 encoded BOM (which looks like this as a byte sequence: 0xef, 0xbb, 0xbf) is written. On decoding utf-8-sig will skip those three bytes if they appear as the first three bytes in the file." (from http://docs.python.org/library/codecs.html#encodings-and-unicode ) (2) I came across this which might be useful somewhere (intelligent encoding auto-detection): http://chardet.feedparser.org/ 213783 16 abarth 2010-04-18 11:23:36 -0700 We should be careful about BOM proliferation. It might confuse tools that don't understand it. 213785 17 cjerdonek 2010-04-18 11:31:19 -0700 (In reply to comment #16) > We should be careful about BOM proliferation. It might confuse tools that > don't understand it. Just to be clear, I was suggesting using "utf-8-sig" only when reading -- which would remove the BOM. 213786 18 cjerdonek 2010-04-18 11:36:29 -0700 +++ b/WebKitTools/ChangeLog @@ -1,3 +1,93 @@ + We do not have to use u"" instead of "" because u"a" == "a" as expected + in Python. Python will generate a warning to the console in cases where + a unicode() == str() operation cannot be performed. Can you clarify what you are trying to say here? It sounds like you might be saying more than you mean to say -- e.g. that the caller never needs to use unicode string literals, which is obviously not right. + All places which use StringIO need to be sure to pass StringIO a + pre-encoded byte-array (str object) instead of unicode so that + clients which read from the StringIO don't have encoding exceptions. It seems like we shouldn't need to use StringIO as much as we do (except perhaps in unittest code to make certain tests easier). It looks like you're removing a lot of the places it's being used which seems good. @@ -117,7 +118,9 @@ class ChangeLog(object): def latest_entry(self): # ChangeLog files are always UTF-8, we read them in as such to support Reviewers with unicode in their names. - changelog_file = codecs.open(self.path, "r", "utf-8") + # We don't use codecs.open here to make the api for parse_latest_entry_from_file clearer. + # If we did, then it would be unclear as to whos reponsibility decoding of the file should be. + changelog_file = open(self.path, "r") try: return self.parse_latest_entry_from_file(changelog_file) I understand what you're saying, but maybe the conclusion that should be drawn is that we shouldn't have parse_latest_entry_from_file() as part of our API? In other words, the caller should be responsible. That would also be more consistent with the rule of thumb to decode as early as possible. +++ b/WebKitTools/Scripts/webkitpy/common/system/deprecated_logging.py @@ -45,9 +45,10 @@ class tee: def __init__(self, *files): self.files = files - def write(self, string): + # Callers should pass an already encoded string for writing. + def write(self, bytes): for file in self.files: - file.write(string) + file.write(bytes) Doesn't this also go against "unicode everywhere/encode late"? Maybe this would be a good spot to do type-checking between unicode/str for backwards compatibility. +++ b/WebKitTools/Scripts/webkitpy/layout_tests/layout_package/metered_stream.py @@ -56,6 +56,8 @@ class MeteredStream: self._stream = stream self._last_update = "" + # FIXME: Does this take a string (unicode) or an array of bytes (str)? + # If it takes a string, it needs to call txt.encode("utf-8") def write(self, txt): """Write text directly to the stream, overwriting and resetting the meter.""" I'm a bit unclear on the extent to which, for example, we'll need to be passing unicode strings even for every log message we create. You've probably thought about this more than I have. Out of curiosity, I started looking to see how Python's logging package handles this. I stopped when it started to look like the logging package has no preference between str and unicode. I think it might only be the particular logging handlers that care, which is what the caller has control over (when they configure logging). 213820 19 eric 2010-04-18 15:36:29 -0700 (In reply to comment #18) Good questions! > Can you clarify what you are trying to say here? It sounds like you might be > saying more than you mean to say -- e.g. that the caller never needs to use > unicode string literals, which is obviously not right. I was attempting to excuse why I didn't add u"" to every string literal in the project. :) If you forget the u"" and it actually contains non-ascii code points, python will yell at you. > It seems like we shouldn't need to use StringIO as much as we do (except > perhaps in unittest code to make certain tests easier). It looks like you're > removing a lot of the places it's being used which seems good. StringIO is just confusingly named. It deals with a stream of bytes. aka, a "str" object in Python 2.x. In Python 3.0 "str" is actually a unicode() object, and there is an explicit bytes() type. StringIO probably takes a bytes() object in 3.0. :) There are few places we actually need StringIO, since we tend to follow the model of just reading everything into memory. The files we deal with tend to be small, and the machines these scripts run on rather beefy. > I understand what you're saying, but maybe the conclusion that should be drawn > is that we shouldn't have parse_latest_entry_from_file() as part of our API? > In other words, the caller should be responsible. That would also be more > consistent with the rule of thumb to decode as early as possible. Any API which takes a file-like object is rather confusing. Because the read() method is expected to return a byte stream. However you can use codecs.open() to create a file-like object which will return unicode() strings instead of str() byte streams from the various methods. > Doesn't this also go against "unicode everywhere/encode late"? Maybe this > would be a good spot to do type-checking between unicode/str for backwards > compatibility. Nope. .write() is expected to deal with byte streams. Think of file.write() > I'm a bit unclear on the extent to which, for example, we'll need to be passing > unicode strings even for every log message we create. You've probably thought > about this more than I have. Well, depends on the logging infrastructure. As far as I can tell Python 2.5 "print" seems to be smart enough to handle unicode() objects. file.write() not so much (unless you open the file with codecs.open and declare an encoding) So depends on what sort of logging we're doing. If we're logging to the console, it seems python is smart enough to handle unicode for us. If we're logging to a file we may have to be careful to call .encode("utf-8") to create the appropriate byte stream first. > Out of curiosity, I started looking to see how Python's logging package handles > this. I stopped when it started to look like the logging package has no > preference between str and unicode. I think it might only be the particular > logging handlers that care, which is what the caller has control over (when > they configure logging). There is not difference between "str" and "unicode" as far as most of python is concerned. I wouldn't expect the logging module to care, except if it's writing to files or to the console (however I suspect that when writing to the console the unicode encoding is abstracted at a lower layer). 213822 20 eric 2010-04-18 15:38:01 -0700 (In reply to comment #17) > (In reply to comment #16) > > We should be careful about BOM proliferation. It might confuse tools that > > don't understand it. > > Just to be clear, I was suggesting using "utf-8-sig" only when reading -- which > would remove the BOM. I don't think we need to use utf-8-sig anywhere. Our tools don't (and shouldn't) write out BOMs and we know the encodings of all our files. It's possible that editing ChangeLog files in MSVC would spit out a BOM in the file. If that's the case, we might have to use "utf-8-sig" when reading in ChangeLog files to be safe. 213870 21 53626 tony 2010-04-18 17:48:25 -0700 Comment on attachment 53626 Patch In response to comment #2, I think it would work if you use decode instead of encode (the string you passed in is already utf8 encoded, you want to convert it to a unicode object, right?). FWIW, I would probably have tried to keep everything as a utf8 encoded str, but using unicode everywhere seems fine too (you get some better type checking this way). In either case, thanks for taking this on. Some small style nits below. > diff --git a/WebKitTools/Scripts/webkitpy/common/checkout/changelog.py b/WebKitTools/Scripts/webkitpy/common/checkout/changelog.py > index e93896f..862dc48 100644 > --- a/WebKitTools/Scripts/webkitpy/common/checkout/changelog.py > +++ b/WebKitTools/Scripts/webkitpy/common/checkout/changelog.py > @@ -102,12 +102,13 @@ class ChangeLog(object): > date_line_regexp = re.compile(ChangeLogEntry.date_line_regexp) > entry_lines = [] > # The first line should be a date line. > - first_line = changelog_file.readline() > + first_line = unicode(changelog_file.readline(), "utf-8") Nit: I find using .decode('utf-8') easier to read than calling unicode(), but either is fine with me. There's another instance of this in the same file. > diff --git a/WebKitTools/Scripts/webkitpy/common/net/bugzilla.py b/WebKitTools/Scripts/webkitpy/common/net/bugzilla.py > index bb22d14..2dd4d20 100644 > --- a/WebKitTools/Scripts/webkitpy/common/net/bugzilla.py > +++ b/WebKitTools/Scripts/webkitpy/common/net/bugzilla.py > def _parse_attachment_element(self, element, bug_id): > + Nit: Did you mean to add this blank line? > diff --git a/WebKitTools/Scripts/webkitpy/common/system/executive.py b/WebKitTools/Scripts/webkitpy/common/system/executive.py > index b6126e4..cbe0e1f 100644 > --- a/WebKitTools/Scripts/webkitpy/common/system/executive.py > +++ b/WebKitTools/Scripts/webkitpy/common/system/executive.py > @@ -145,7 +157,7 @@ class Executive(object): > # os.kill isn't available on Windows. However, when I tried it > # using Cygwin, it worked fine. We should investigate whether > # we need this platform specific code here. > - subprocess.call(('taskkill.exe', '/f', '/pid', str(pid)), > + subprocess.call(('taskkill.exe', '/f', '/pid', unicode(pid)), Nit: This can probably stay as str(). It's a bit weird to have the other strings be str and the pid be unicode. 213882 22 cjerdonek 2010-04-18 19:59:38 -0700 (In reply to comment #19) Thanks for your responses, Eric. > > I understand what you're saying, but maybe the conclusion that should be drawn > > is that we shouldn't have parse_latest_entry_from_file() as part of our API? > > In other words, the caller should be responsible. That would also be more > > consistent with the rule of thumb to decode as early as possible. > > Any API which takes a file-like object is rather confusing. Because the read() > method is expected to return a byte stream. However you can use codecs.open() > to create a file-like object which will return unicode() strings instead of > str() byte streams from the various methods. I guess what I was getting at here is that -- following the "decode early" mantra -- we might want to have parse_latest_entry_from_file() accept a file-like object from codecs.open() rather than a UTF-8 encoded stream. That way parse_latest_entry_from_file() doesn't have to be encoding aware and will see only unicode strings. I only bring this up because this issue will probably come up in more spots as we review more of our code. Any time we define a function that takes a file-like object representing text, we'll need to decide if that function should take a UTF-8 encoded stream, say, or an encoding-aware stream from codecs. (The codecs module blurs the recommendations in the slide show somewhat because you can "decode early" while still seeming to handle a stream of bytes.) Incidentally, the Python documentation notes that in Python 3, "there is no longer any need for using the encoding-aware streams in the codecs module." (from http://docs.python.org/release/3.0.1/whatsnew/3.0.html#text-vs-data-instead-of-unicode-vs-8-bit ) 213910 23 eric 2010-04-18 22:20:31 -0700 (In reply to comment #21) > (From update of attachment 53626 [details]) > In response to comment #2, I think it would work if you use decode instead of > encode (the string you passed in is already utf8 encoded, you want to convert > it to a unicode object, right?). My example was slightly confusing, and I was myself slightly confused. Now that I see "str" as an array of bytes and not actually a string type the world makes a lot more sense. I was attempting to unconditionally encode any "string like object" to a utf-8 bytestream before passing off to the Popen call. This meant that if I was passing around utf8-encoded str objects, and tried to call "encode" on them, it would scream at me. > FWIW, I would probably have tried to keep everything as a utf8 encoded str, but > using unicode everywhere seems fine too (you get some better type checking this > way). In either case, thanks for taking this on. Yes, it's true, that could work. However there are already many APIs which feed us unicode() objects and so we'd have to be careful to be sure to convert those back to utf-8 byte stream (str) objects before passing them around or comparisons would fail. I decided to go with the unicode() solution, mostly because it seemed the most consistent in my head. Turns out it's also the recommended way to prepare for Python 3.0 (which we'll eventually get to in a year or more). :) > > - first_line = changelog_file.readline() > > + first_line = unicode(changelog_file.readline(), "utf-8") > > Nit: I find using .decode('utf-8') easier to read than calling unicode(), but > either is fine with me. There's another instance of this in the same file. Yes. The only difference is handling of None. However I agree in this case decode is definitely nicer. > > def _parse_attachment_element(self, element, bug_id): > > + > > Nit: Did you mean to add this blank line? Nope. Will fix. > > - subprocess.call(('taskkill.exe', '/f', '/pid', str(pid)), > > + subprocess.call(('taskkill.exe', '/f', '/pid', unicode(pid)), > > Nit: This can probably stay as str(). It's a bit weird to have the other > strings be str and the pid be unicode. It certainly could. I was trying to move away from ever using the str() constructor. str() is basically always bad news, even when we use it to mean "make this number a string". 213911 24 eric 2010-04-18 22:23:37 -0700 (In reply to comment #22) > I guess what I was getting at here is that -- following the "decode early" > mantra -- we might want to have parse_latest_entry_from_file() accept a > file-like object from codecs.open() rather than a UTF-8 encoded stream. That > way parse_latest_entry_from_file() doesn't have to be encoding aware and will > see only unicode strings. Hmm... Maybe. Seems a bit magical. We'd have to assert that .read() returned isinstance(unicode) values or something to be sure. You're right that it would make the code read more like Python 3.0 would. :) > I only bring this up because this issue will probably come up in more spots as > we review more of our code. Any time we define a function that takes a > file-like object representing text, we'll need to decide if that function > should take a UTF-8 encoded stream, say, or an encoding-aware stream from > codecs. Yes. And your point is valid. Not sure how to make that work with StringIO for unittesting though. If I remember correctly StringIO(unicode(...)) will throw exceptions when read() is called. > (The codecs module blurs the recommendations in the slide show somewhat because > you can "decode early" while still seeming to handle a stream of bytes.) > > Incidentally, the Python documentation notes that in Python 3, "there is no > longer any need for using the encoding-aware streams in the codecs module." > > (from > http://docs.python.org/release/3.0.1/whatsnew/3.0.html#text-vs-data-instead-of-unicode-vs-8-bit > ) Thank you. :) Very helpful comments as always. 214225 25 cjerdonek 2010-04-19 13:52:05 -0700 (In reply to comment #24) > Yes. And your point is valid. Not sure how to make that work with StringIO > for unittesting though. If I remember correctly StringIO(unicode(...)) will > throw exceptions when read() is called. I haven't tried this out myself to check, but the Python documentation seems to say this is okay as long as one doesn't mix the two: http://docs.python.org/library/stringio.html#StringIO.StringIO 214271 26 eric 2010-04-19 15:02:16 -0700 You're right, StringIO(unicode()) seems to work fine: >>> import StringIO >>> tor = u"Vestb\u00f8" >>> print tor Vestbø >>> tor_io =StringIO.StringIO(tor) >>> read_tor =tor_io.read() >>> print read_tor Vestbø >>> print read_tor.__class__ <type 'unicode'> 214415 27 eric 2010-04-19 18:33:55 -0700 I can haz r+ or r- plz? 214821 28 abarth 2010-04-20 11:58:36 -0700 Looking. 214831 29 53626 abarth 2010-04-20 12:08:57 -0700 Comment on attachment 53626 Patch Oh man. This looks like a good approach. Now we get to see how good our test coverage is. Btw, we should write up a doc about reviewing/writing webkitpy code that explains these kinds of constraints we have going forward. 214848 30 cjerdonek 2010-04-20 12:19:30 -0700 (In reply to comment #29) > Btw, we should write up a doc about reviewing/writing webkitpy code that > explains these kinds of constraints we have going forward. I'm not sure what kind of doc you're envisioning, but I've started to put general information about WebKit Python and webkitpy here: http://trac.webkit.org/wiki/PythonGuidelines (linked under the "Documentation" section on the main wiki page) 214856 31 vestbo 2010-04-20 12:25:56 -0700 Much love for looking into this Eric! 214862 32 abarth 2010-04-20 12:31:06 -0700 That wiki page looks great. Would you be willing to add some info about our Unicode strategy and good and bad patterns? 214878 33 cjerdonek 2010-04-20 12:44:29 -0700 (In reply to comment #32) > That wiki page looks great. Would you be willing to add some info about our > Unicode strategy and good and bad patterns? Sure, I could do that. For now I stubbed out a section with a link to this comment thread. But don't let that stop anyone else from adding to that section if I don't get to it right away. :) 214891 34 eric 2010-04-20 12:55:00 -0700 Committed r57907: <http://trac.webkit.org/changeset/57907> 214929 35 webkit.review.bot 2010-04-20 13:54:49 -0700 http://trac.webkit.org/changeset/57907 might have broken Windows Debug (Tests) The following changes are on the blame list: http://trac.webkit.org/changeset/57904 http://trac.webkit.org/changeset/57905 http://trac.webkit.org/changeset/57906 http://trac.webkit.org/changeset/57907 http://trac.webkit.org/changeset/57908 214950 36 eric 2010-04-20 14:30:40 -0700 Reverted r57907 for reason: Appears to have broken MacEWS and possibly webkit-patch upload for svn users. Needs further investigation. Committed r57920: <http://trac.webkit.org/changeset/57920> 214951 37 eric 2010-04-20 14:31:52 -0700 The chromium bots also saw a failure in new-run-webkit-tests: http://build.chromium.org/buildbot/waterfall.fyi/builders/Webkit%20Linux%20(webkit.org)/builds/23994/steps/webkit_tests/logs/stdio 214963 38 dpranke 2010-04-20 14:50:39 -0700 So, to summarize the thinking in this patch: 1) assume all text files are encoded on disk as UTF-8 2) read files using codecs.open(..., "r", encoding="utf-8") 3) write files using codecs.open(..., "w", enocding="utf-8"), write(s.encode("utf-8")) if s is a string that is not known to be encoded already Correct? It would be good if we provided wrappers for (2) and (3) that handled this automatically and centralized the open and close logic in one place. Perhaps the read_file() and write_file() utility routines in dryrun.py that are supposed to be split off into their own file would be a good start on standardizing this. 214968 39 eric 2010-04-20 14:55:36 -0700 (In reply to comment #38) > So, to summarize the thinking in this patch: > > 1) assume all text files are encoded on disk as UTF-8 More precisely: be explicit about how things are encoded, whatever that encoding may be. > 2) read files using codecs.open(..., "r", encoding="utf-8") Possibly. This patch uses a combination. codecs.open makes file object return unicode() strings instead of str byte arrays from read() and friends. We use that in some palces. cjerdonek was suggesting we standardize, but I didn't do a good job of that in this patch. > 3) write files using codecs.open(..., "w", enocding="utf-8"), > write(s.encode("utf-8")) > if s is a string that is not known to be encoded already One or the other, not both. if you open with codecs.open it will do the magic for you. if you open with open() you have to encode to a byte array (str) before calling write. > It would be good if we provided wrappers for (2) and (3) that handled this > automatically and centralized the open and close logic in one place. > > Perhaps the read_file() and write_file() utility routines in dryrun.py that are > supposed to be split off into their own file would be a good start on > standardizing this. Possibly. I think Chris is probably right. We should probably standarize on using codecs.open everywhere and then be able to assume that read/write handle unicode (like they do in Python 3.0). 214988 40 dpranke 2010-04-20 15:10:13 -0700 (In reply to comment #39) > (In reply to comment #38) > > So, to summarize the thinking in this patch: > > > > 1) assume all text files are encoded on disk as UTF-8 > > More precisely: be explicit about how things are encoded, whatever that > encoding may be. > I was (perhaps badly) attempting to be stronger than that. What I meant was, previously we had probably assumed that all of the files are ASCII. We don't want to assume that, but since we don't want to try and do encoding detection, we should probably assume something, and that should probably be UTF-8. > > 2) read files using codecs.open(..., "r", encoding="utf-8") > > Possibly. This patch uses a combination. codecs.open makes file object return > unicode() strings instead of str byte arrays from read() and friends. We use > that in some palces. cjerdonek was suggesting we standardize, but I didn't do > a good job of that in this patch. I agree with Chris we should standardize, although it doesn't have to happen in this patch. We should file a separate bug to clean up the rest of the open() calls. > > > 3) write files using codecs.open(..., "w", enocding="utf-8"), > > write(s.encode("utf-8")) > > if s is a string that is not known to be encoded already > > One or the other, not both. if you open with codecs.open it will do the magic > for you. if you open with open() you have to encode to a byte array (str) > before calling write. Okay. I wasn't clear about that. 214992 41 eric 2010-04-20 15:14:52 -0700 (In reply to comment #40) > (In reply to comment #39) > > (In reply to comment #38) > > > So, to summarize the thinking in this patch: > > > > > > 1) assume all text files are encoded on disk as UTF-8 > > > > More precisely: be explicit about how things are encoded, whatever that > > encoding may be. > > > > I was (perhaps badly) attempting to be stronger than that. What I meant was, > previously we had probably assumed that all of the files are ASCII. We don't > want to assume that, but since we don't want to try and do encoding detection, > we should probably assume something, and that should probably be UTF-8. Except they weren't ascii. :) The exception Chromium hit when this was landed was due to the diff-processing code trying to write out a unicode string. Previously we were blissfully unaware that diff/wdiff/prettypatch were returning us utf-8 encoded data and we were passing it around as str()s. After this patch, we convert data returned from commands back into unicode() strings. Making some things easier, but requiring us to be explicit about converting our unicode strings back to byte arrays before writing them out to files (or using codecs.open to make our write() calls transparently convert). 214998 42 webkit.review.bot 2010-04-20 15:17:03 -0700 http://trac.webkit.org/changeset/57920 might have broken Leopard Intel Release (Tests) The following changes are on the blame list: http://trac.webkit.org/changeset/57920 http://trac.webkit.org/changeset/57921 215005 43 dpranke 2010-04-20 15:21:36 -0700 (In reply to comment #41) > (In reply to comment #40) > > (In reply to comment #39) > > > (In reply to comment #38) > > > > So, to summarize the thinking in this patch: > > > > > > > > 1) assume all text files are encoded on disk as UTF-8 > > > > > > More precisely: be explicit about how things are encoded, whatever that > > > encoding may be. > > > > > > > I was (perhaps badly) attempting to be stronger than that. What I meant was, > > previously we had probably assumed that all of the files are ASCII. We don't > > want to assume that, but since we don't want to try and do encoding detection, > > we should probably assume something, and that should probably be UTF-8. > > Except they weren't ascii. :) Agreed, obviously. I wasn't trying to suggest there weren't bugs we were runing into. 215219 44 53937 eric 2010-04-21 03:33:19 -0700 Created attachment 53937 Fixed to be way more awesome 215221 45 eric 2010-04-21 03:35:57 -0700 I've updated the patch to deploy "codecs.open" everywhere, as per Chris's suggestion. While I was looking at every open() call, I converted a bunch of them to use "with" to avoid file descriptor leaks. The patch is huge now. However, it does fix the 3 regressions seen when landing the last patch: 1. mac-ews was failing due to having changed how --status-host was passed, our global argument parsing is a hack, at least I've documented that now. 2. webkit-patch upload was broken for svn users due to the svn-create-patch call not passing its arguments as an array. 3. new-run-webkit-tests was broken for chromium due to diff creation logic not specifying an encoding. 215481 46 53937 abarth 2010-04-21 13:46:06 -0700 Comment on attachment 53937 Fixed to be way more awesome This change is too large to convince myself that it's correct, but the approach seems good and we want to do it all at once. One thought: how much of this can we wrap in a filesystem abstraction? I discussed that idea with Dirk on another bug. I don't think we need to do that in this patch, but it's something to keep in mind. 215484 47 eric 2010-04-21 13:50:05 -0700 The file system abstraction is really codecs.open() I learned at the end of this change that I could have even deployed codecs.open wider. We should *never* be using open() directly. codecs.open takes an encoding parameter (just like Python 3.x open() does). encoding=None results in open()-like, return-a-str-object behavior. So in a followup patch we should remove all uses of raw open(). We should also avoid ever closing a file manually. Doing so will fail in teh case of an exception, which is why we use with blocks. :) 215492 48 dpranke 2010-04-21 14:06:25 -0700 (In reply to comment #47) > The file system abstraction is really codecs.open() I learned at the end of > this change that I could have even deployed codecs.open wider. > > We should *never* be using open() directly. codecs.open takes an encoding > parameter (just like Python 3.x open() does). encoding=None results in > open()-like, return-a-str-object behavior. > > So in a followup patch we should remove all uses of raw open(). > > We should also avoid ever closing a file manually. Doing so will fail in teh > case of an exception, which is why we use with blocks. :) Note that with blocks only do try/finally; you should still be aware of needing to do try/catch if you don't want the exceptions to propagate. 215497 49 cjerdonek 2010-04-21 14:18:05 -0700 (In reply to comment #47) > We should *never* be using open() directly. codecs.open takes an encoding > parameter (just like Python 3.x open() does). encoding=None results in > open()-like, return-a-str-object behavior. I just wanted to bring attention to a couple other uses of the codecs module that I noticed in check-webkit-style -- in case they might be useful elsewhere in webkitpy. Mainly this code-- # Change stderr to write with replacement characters so we don't die # if we try to print something containing non-ASCII characters. stderr = codecs.StreamReaderWriter(sys.stderr, codecs.getreader('utf8'), codecs.getwriter('utf8'), 'replace') # Setting an "encoding" attribute on the stream is necessary to # prevent the logging module from raising an error. See # the checker.configure_logging() function for more information. stderr.encoding = "UTF-8" # FIXME: Change webkitpy.style so that we do not need to overwrite # the global sys.stderr. This involves updating the code to # accept a stream parameter where necessary, and not calling # sys.stderr explicitly anywhere. sys.stderr = stderr (This is from http://trac.webkit.org/browser/trunk/WebKitTools/Scripts/check-webkit-style?rev=57467#L61 ) IIRC, this codecs.StreamReaderWriter code was present in its basic form from the beginning. I'm not sure when we might want to use this pattern over codecs.open(), but perhaps it might be useful elsewhere. Note also the use of the errors='replace' parameter, which codecs.open() also accepts. The "errors" parameter in these methods controls how bad bytes should be handled when encountered while reading from or writing to a stream. There may be cases where we want to be more lenient than the default value of errors='strict' and continue processing a file if possible. It doesn't look like the errors parameter is being used in any of the codecs.open() calls in this patch (which could very well be exactly what we want). 215525 50 eric 2010-04-21 15:04:36 -0700 Committed r58014: <http://trac.webkit.org/changeset/58014> 215543 51 53998 eric 2010-04-21 15:47:27 -0700 Created attachment 53998 Fix Chromium Canaries 215544 52 eric 2010-04-21 15:52:39 -0700 Committed r58016: <http://trac.webkit.org/changeset/58016> 215564 53 eric 2010-04-21 16:31:39 -0700 Committed r58023: <http://trac.webkit.org/changeset/58023> 215620 54 eric 2010-04-21 18:23:39 -0700 Was rolled out a second time. 215636 55 eric 2010-04-21 18:34:40 -0700 Committed r58036: <http://trac.webkit.org/changeset/58036> 215663 56 54018 eric 2010-04-21 20:10:29 -0700 Created attachment 54018 Fix for run-webkit-tests --chromium 215666 57 eric 2010-04-21 20:17:23 -0700 Committed r58044: <http://trac.webkit.org/changeset/58044> 215673 58 54019 eric 2010-04-21 20:40:51 -0700 Created attachment 54019 Patch 215688 59 eric 2010-04-21 21:31:42 -0700 Committed r58050: <http://trac.webkit.org/changeset/58050> 215698 60 eric 2010-04-21 22:41:48 -0700 Committed r58054: <http://trac.webkit.org/changeset/58054> 215705 61 eric 2010-04-21 22:50:00 -0700 Committed r58055: <http://trac.webkit.org/changeset/58055> 215716 62 eric 2010-04-21 23:20:04 -0700 Committed r58059: <http://trac.webkit.org/changeset/58059> 215722 63 eric 2010-04-21 23:30:38 -0700 Committed r58060: <http://trac.webkit.org/changeset/58060> 215733 64 eric 2010-04-21 23:39:32 -0700 Committed r58062: <http://trac.webkit.org/changeset/58062> 215807 65 eric 2010-04-22 03:29:25 -0700 Chromium is reporting random hangs in new-run-webkit-tests --chromium after all these changes. I'm not sure what could be causing them yet. We really need a backtrace from the hang. 215810 66 eric 2010-04-22 03:32:43 -0700 http://trac.webkit.org/changeset/58059 looks the most suspicious for possibly causing hangs, but again we need a reproduction including backtrace to really know what's getting hung. Some print-based debugging might lead us in teh right direciton. I'm headed to bed soon, but I'm happy to look at this first thing in the morning (well, probably afternoon at this point). 215816 67 eric 2010-04-22 03:58:23 -0700 (In reply to comment #66) > http://trac.webkit.org/changeset/58059 looks the most suspicious for possibly > causing hangs, but again we need a reproduction including backtrace to really > know what's getting hung. Some print-based debugging might lead us in teh > right direciton. > > I'm headed to bed soon, but I'm happy to look at this first thing in the > morning (well, probably afternoon at this point). That change probably made us vulernable to http://bugs.python.org/issue1236 again. Which I had mistakenly thought was a 2.4 only bug. Perhaps one of the orignial new-run-webkit-test authors can comment on how http://bugs.python.org/issue1236 manifests? Could it be the hangs Yuzo is seeing? Again, we just need a backtrace and then solving the hang shoudl be simple. :) 216214 68 dpranke 2010-04-22 18:53:22 -0700 (In reply to comment #62) > Committed r58059: <http://trac.webkit.org/changeset/58059> This change doesn't actually call format_wdiff_output_as_html() ... presumably this breaks wdiff output? 216282 69 ukai 2010-04-22 22:26:27 -0700 when i run test_webkitpy on cygwin, test-webkitpy: INFO Suppressing most webkitpy logging while running unit tests. webkitpy.test.main: INFO Excluding: webkitpy.common.checkout.scm_unittest (use --all to include) ... ====================================================================== ERROR: Validate that it is safe to pass unicode() objects ---------------------------------------------------------------------- Traceback (most recent call last): File "/cygdrive/c/Users/ukai/src/chromium-webkit/src/third_party/WebKit/WebKit Tools/Scripts/webkitpy/common/system/executive_unittest.py", line 53, in test_run_command_with_unicode output = executive.run_command(["echo", "-n", unicode_tor]) File "/cygdrive/c/Users/ukai/src/chromium-webkit/src/third_party/WebKit/WebKit Tools/Scripts/webkitpy/common/system/executive.py", line 211, in run_command cwd=cwd) File "/usr/lib/python2.5/subprocess.py", line 594, in __init__ errread, errwrite) File "/usr/lib/python2.5/subprocess.py", line 1091, in _execute_child raise child_exception TypeError: execv() arg 2 must contain only strings ====================================================================== FAIL: test_basics (webkitpy.layout_tests.run_webkit_tests_unittest.DryrunTest) ---------------------------------------------------------------------- Traceback (most recent call last): File "/cygdrive/c/Users/ukai/src/chromium-webkit/src/third_party/WebKit/WebKit Tools/Scripts/webkitpy/layout_tests/run_webkit_tests_unittest.py", line 63, in test_basics 'fast/html'])) File "/cygdrive/c/Users/ukai/src/chromium-webkit/src/third_party/WebKit/WebKit Tools/Scripts/webkitpy/layout_tests/run_webkit_tests_unittest.py", line 41, in passing_run res = run_webkit_tests.main(options, args, False) File "/cygdrive/c/Users/ukai/src/chromium-webkit/src/third_party/WebKit/WebKit Tools/Scripts/webkitpy/layout_tests/run_webkit_tests.py", line 1529, in main options.configuration = port_obj.default_configuration() File "/cygdrive/c/Users/ukai/src/chromium-webkit/src/third_party/WebKit/WebKit Tools/Scripts/webkitpy/layout_tests/port/webkit.py", line 304, in default_configuration assert(configuration == "Debug" or configuration == "Release") AssertionError $ python Python 2.5.2 (r252:60911, Dec 2 2008, 09:26:14) [GCC 3.4.4 (cygming special, gdc 0.12, using dmd 0.124)] on cygwin should i use more recent version of python, cygwin? 53625 2010-04-18 04:14:28 -0700 2010-04-18 04:55:16 -0700 Patch bug-37765-20100418041427.patch text/plain 40484 eric ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxv ZwppbmRleCA1OWMyNzc2Li41NGU2ZTIwIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9DaGFuZ2VM b2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNzcgQEAKKzIwMTAtMDQt MTggIEVyaWMgU2VpZGVsICA8ZXJpY0B3ZWJraXQub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFJFR1JFU1NJT04oNTc1MzEpOiB0aGUgY29tbWl0 LXF1ZXVlIHN0aWxsIGhhdGVzIFRvciBBcm5lIFZlc3Riw7gKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM3NzY1CisKKyAgICAgICAgSSBmaXhlZCB0aGUg cXVldWUgdG8gbm90IGlnbm9yZSBUb3IgYXMgYSByZXZpd2VyIGluIHI1NzUzMSwKKyAgICAgICAg YnV0IGluc3RlYWQgaXQgdGhyb3dzIGFuIGV4Y2VwdGlvbiBldmVyeSB0aW1lIGhpcyBuYW1lIGlz IGluIGEgcGF0Y2guCisKKyAgICAgICAgVGhpcyBmaXhlcyBvdXIgRXhlY3V0aXZlLnJ1bl9jb21t YW5kIGNvZGUgdG8gd29yayBhcm91bmQgYSBQb3BlbgorICAgICAgICBidWcgaHR0cDovL2J1Z3Mu cHl0aG9uLm9yZy9pc3N1ZTUyOTAgd2hlcmVieSBweXRob24gdmVyc2lvbnMgYmVmb3JlIDIuNgor ICAgICAgICBkbyBub3QgY29ycmVjdGx5IGhhbmRsZSB1bmljb2RlIG9iamVjdHMgYXMgaW5wdXQg b3Igb3V0cHV0IHRvCisgICAgICAgIFBvcGVuLmNvbW11bmljYXRlLgorCisgICAgICAgIEZvbGxv d2luZyB0aGUgYWR2aXNlIG9mOgorICAgICAgICBodHRwOi8vZmFybWRldi5jb20vdGFsa3MvdW5p Y29kZS8KKyAgICAgICAgSSdtIGF0dGVtcHRpbmcgdG8gdGFrZSB0aGUgcHl0aG9uIHVuaWNvZGUg cGx1bmdlIGFuZCB1c2UgdW5pY29kZSgpCisgICAgICAgIG9iamVjdHMgYXMgc3RyaW5ncyBpbnN0 ZWFkIG9mIHN0cigpIG9iamVjdHMgZXZlcnl3aGVyZSBpbiB3ZWJraXRweS4KKworICAgICAgICBX ZSBkbyBub3QgaGF2ZSB0byB1c2UgdSIiIGluc3RlYWQgb2YgIiIgYmVjYXVzZSB1ImEiID09ICJh IiBhcyBleHBlY3RlZAorICAgICAgICBpbiBQeXRob24uICBQeXRob24gd2lsbCBnZW5lcmF0ZSBh IHdhcm5pbmcgdG8gdGhlIGNvbnNvbGUgaW4gY2FzZXMgd2hlcmUKKyAgICAgICAgYSB1bmljb2Rl KCkgPT0gc3RyKCkgb3BlcmF0aW9uIGNhbm5vdCBiZSBwZXJmb3JtZWQuCisKKyAgICAgICAgSSBh bHNvIGNsZWFuZWQgdXAgdGhlIGlucHV0IGhhbmRsaW5nIGluIHJ1bl9jb21tYW5kIGEgbGl0dGxl IGJ5IGFkZGluZworICAgICAgICBhIG5ldyBfY29tcHV0ZV9pbnB1dCgpIG1ldGhvZCB3aGljaCBj YW4gcmV0dXJuIGVhcmx5IGluc3RlYWQgb2YgaGF2aW5nCisgICAgICAgIHN1Y2ggYSBsb25nL2Ns dXR0ZXJlZCBpZi1ibG9jay4KKworICAgICAgICBFeGVjdXRpdmUucnVuKiBub3cgY29ycmVjdGx5 IGFjY2VwdCBhbmQgcmV0dXJuIHVuaWNvZGUoKSBvYmplY3RzLgorICAgICAgICBJIGF0dGVtcHRl ZCB0byBmaXggYWxsIHRoZSBwbGFjZXMgdGhhdCB3ZSBjYWxsIC53cml0ZSgpIHRvIG1ha2Ugc3Vy ZSB3ZQorICAgICAgICBlbmNvZGUgYW55IHVuaWNvZGUoKSBvYmplY3RzIGludG8gdXRmLTguCisK KyAgICAgICAgSSBhdHRlbXB0ZWQgdG8gZG9jdW1lbnQgYW55IHBsYWNlcyB3aGVyZSB3ZSBhcmUg bm90IGNvcnJlY3RseSBjb252ZXJ0aW5nCisgICAgICAgIHRvL2Zyb20gYnl0ZXMgKHN0cigpIG9i amVjdHMpIHRvIHN0cmluZ3MgKHVuaWNvZGUoKSBvYmplY3RzKS4KKworICAgICAgICAqIFNjcmlw dHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L2FwaV91bml0dGVzdC5weToKKyAgICAgICAgIC0g UmVhZC93cml0ZSB1dGYtOCBmaWxlcyBpbnN0ZWFkIG9mIGFzY2lpLgorICAgICAgICAgLSBVcGRh dGUgdGhlIHRlc3RzIHRvIHVzZSB0ZXN0IGZvciBwcm9wZXIgdW5pY29kZSgpIGhhbmRsaW5nLgor ICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L2NoYW5nZWxvZ191bml0 dGVzdC5weToKKyAgICAgICAgIC0gVXNlIHVuaWNvZGUoKSBzdHJpbmdzIGluc3RlYWQgb2Ygc3Ry KCkgYnl0ZSBhcnJheXMuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tv dXQvc2NtLnB5OgorICAgICAgICAgLSBSZW1vdmUgdXNlIG9mIHN0cigpLgorICAgICAgICAqIFNj cmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3NjbV91bml0dGVzdC5weToKKyAgICAgICAg IC0gUmVhZC93cml0ZSB1dGYtOCBmaWxlcyBhbmQgdXNlIHVuaWNvZGUoKSBzdHJpbmdzIGluIHRl c3RpbmcuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9jb21tb24vY29uZmlnL2NvbW1pdHRl cnMucHk6CisgICAgICAgICAtIFVzZSBcdSBpbnN0ZWFkIG9mIFx4IHRvIG1ha2Ugc2xpZ2h0bHkg Y2xlYXJlciB3aGF0IHdlJ3JlIGRvaW5nLgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvY29t bW9uL25ldC9idWd6aWxsYS5weToKKyAgICAgICAgIC0gQWRkIGEgbmV3IF9zdHJpbmdfY29udGVu dHMoKSBtZXRob2QgYW5kIGV4cGxhaW4gd2h5CisgICAgICAgICAgIHdlIGhhdmUgdG8gY2FsbCB1 bmljb2RlKCkgb24gdGhlIHJlc3VsdCBvZiBzb3VwLnN0cmluZworICAgICAgICAgICBhbmQgd2h5 IGl0J3Mgc2FmZSB0byBkbyBzbyB3L28gbmVlZGluZyB0byBwYXNzIGEgY29kZWMgbmFtZS4KKyAg ICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9uZXQvYnVpbGRib3QucHk6CisgICAgICAg ICAtIFVzZSB1bmljb2RlKCkgaW5zdGVhZCBvZiBzdHIoKSB3aGVuIG5lZWRpbmcgdG8gY29heCBh CisgICAgICAgICAgIE5hdmlnYWJsZVN0cmluZyBvYmplY3QgaW50byBhIHVuaWNvZGUoKSBvYmpl Y3QuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9jb21tb24vbmV0L3N0YXR1c3NlcnZlci5w eToKKyAgICAgICAgIC0gUmVtb3ZlIHVzZSBvZiBzdHIoKQorICAgICAgICAqIFNjcmlwdHMvd2Vi a2l0cHkvY29tbW9uL3ByZXR0eXBhdGNoLnB5OgorICAgICAgICAgLSBXcml0ZSBvdXQgdGhlIHBh dGNoIGZpbGUgYXMgdXRmLTguCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9jb21tb24vc3lz dGVtL2F1dG9pbnN0YWxsLnB5OgorICAgICAgICAgLSBBZGQgYSBGSVhNRSBhYm91dCBlbmNvZGlu Zy4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9zeXN0ZW0vZGVwcmVjYXRlZF9s b2dnaW5nLnB5OgorICAgICAgICAgLSBEb2N1bWVudCB0aGF0IHRlZSgpIHdvcmtzIG9uIGJ5dGVz LCBub3Qgc3RyaW5ncy4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9zeXN0ZW0v ZXhlY3V0aXZlLnB5OgorICAgICAgICAgLSBNYWtlIHJ1biogcHJvcGVybHkgdGFrZSBhbmQgcmV0 dXJuIHVuaWNvZGUoKSBvYmplY3RzLgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvY29tbW9u L3N5c3RlbS9leGVjdXRpdmVfdW5pdHRlc3QucHk6CisgICAgICAgICAtIEFkZGVkIGEgdW5pdCB0 ZXN0IHRvIG1ha2Ugc3VyZSB3ZSBkb24ndCBicmVhayBUb3IgYWdhaW4hCisgICAgICAgICogU2Ny aXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvbGF5b3V0X3BhY2thZ2UvZHVtcF9yZW5kZXJfdHJl ZV90aHJlYWQucHk6CisgICAgICAgICAtIFdyaXRlIG91dCB0aGUgdGVzdCBsaXN0IGFzIHV0Zi04 LgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9wYWNrYWdl L2pzb25fcmVzdWx0c19nZW5lcmF0b3IucHk6CisgICAgICAgICAtIFdyaXRlIG91dCBqc29uIGZp bGVzIGFzIHV0Zi04LgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2xh eW91dF9wYWNrYWdlL21ldGVyZWRfc3RyZWFtLnB5OgorICAgICAgICAgLSBBZGQgRklYTUUgYWJv dXQgZW5jb2RpbmcgaGFuZGxpbmcuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS90b29sL3N0 ZXBzL3N0ZXBzX3VuaXR0ZXN0LnB5OgorICAgICAgICAgLSBGaXhlZCBzcHVyaW91cyBsb2dnaW5n IHNlZW4gd2hlbiBydW5uaW5nIHRlc3Qtd2Via2l0cHkKKwogMjAxMC0wNC0xNyAgQWRhbSBCYXJ0 aCAgPGFiYXJ0aEB3ZWJraXQub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEVyaWMgU2VpZGVs LgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tv dXQvYXBpLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQv YXBpLnB5CmluZGV4IGM0ZTJiNjkuLmU2ZGQzYTEgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1Nj cmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L2FwaS5weQorKysgYi9XZWJLaXRUb29scy9T Y3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9hcGkucHkKQEAgLTUwLDcgKzUwLDggQEAg Y2xhc3MgQ2hlY2tvdXQob2JqZWN0KToKIAogICAgIGRlZiBfbGF0ZXN0X2VudHJ5X2Zvcl9jaGFu Z2Vsb2dfYXRfcmV2aXNpb24oc2VsZiwgY2hhbmdlbG9nX3BhdGgsIHJldmlzaW9uKToKICAgICAg ICAgY2hhbmdlbG9nX2NvbnRlbnRzID0gc2VsZi5fc2NtLmNvbnRlbnRzX2F0X3JldmlzaW9uKGNo YW5nZWxvZ19wYXRoLCByZXZpc2lvbikKLSAgICAgICAgcmV0dXJuIENoYW5nZUxvZy5wYXJzZV9s YXRlc3RfZW50cnlfZnJvbV9maWxlKFN0cmluZ0lPLlN0cmluZ0lPKGNoYW5nZWxvZ19jb250ZW50 cykpCisgICAgICAgIGZha2VfZmlsZSA9IFN0cmluZ0lPLlN0cmluZ0lPKGNoYW5nZWxvZ19jb250 ZW50cy5lbmNvZGUoInV0Zi04IikpCisgICAgICAgIHJldHVybiBDaGFuZ2VMb2cucGFyc2VfbGF0 ZXN0X2VudHJ5X2Zyb21fZmlsZShmYWtlX2ZpbGUpCiAKICAgICBkZWYgY2hhbmdlbG9nX2VudHJp ZXNfZm9yX3JldmlzaW9uKHNlbGYsIHJldmlzaW9uKToKICAgICAgICAgY2hhbmdlZF9maWxlcyA9 IHNlbGYuX3NjbS5jaGFuZ2VkX2ZpbGVzX2Zvcl9yZXZpc2lvbihyZXZpc2lvbikKZGlmZiAtLWdp dCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L2FwaV91bml0 dGVzdC5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L2Fw aV91bml0dGVzdC5weQppbmRleCBlOTljYWVlLi43ZjdhZDgzIDEwMDY0NAotLS0gYS9XZWJLaXRU b29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9hcGlfdW5pdHRlc3QucHkKKysr IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvYXBpX3VuaXR0 ZXN0LnB5CkBAIC0yNiw2ICsyNiw3IEBACiAjIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhF UldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQogIyBPRiBUSElTIFNPRlRX QVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgog CitpbXBvcnQgY29kZWNzCiBpbXBvcnQgb3MKIGltcG9ydCBzaHV0aWwKIGltcG9ydCB0ZW1wZmls ZQpAQCAtMzksMTIgKzQwLDEyIEBAIGZyb20gd2Via2l0cHkudGhpcmRwYXJ0eS5tb2NrIGltcG9y dCBNb2NrCiAKICMgRklYTUU6IENvcGllZCBmcm9tIHNjbV91bml0dGVzdC5weQogZGVmIHdyaXRl X2ludG9fZmlsZV9hdF9wYXRoKGZpbGVfcGF0aCwgY29udGVudHMpOgotICAgIG5ld19maWxlID0g b3BlbihmaWxlX3BhdGgsICd3JykKKyAgICBuZXdfZmlsZSA9IGNvZGVjcy5vcGVuKGZpbGVfcGF0 aCwgInciLCAidXRmLTgiKQogICAgIG5ld19maWxlLndyaXRlKGNvbnRlbnRzKQogICAgIG5ld19m aWxlLmNsb3NlKCkKIAogCi1fY2hhbmdlbG9nMWVudHJ5MSA9ICIiIjIwMTAtMDMtMjUgIEVyaWMg U2VpZGVsICA8ZXJpY0B3ZWJraXQub3JnPgorX2NoYW5nZWxvZzFlbnRyeTEgPSB1IiIiMjAxMC0w My0yNSAgVG9yIEFybmUgVmVzdGJcdTAwZjggIDx2ZXN0Ym9Ad2Via2l0Lm9yZz4KIAogICAgICAg ICBVbnJldmlld2VkIGJ1aWxkIGZpeCB0byB1bi1icmVhayB3ZWJraXQtcGF0Y2ggbGFuZC4KIApA QCAtNTMsNyArNTQsNyBAQCBfY2hhbmdlbG9nMWVudHJ5MSA9ICIiIjIwMTAtMDMtMjUgIEVyaWMg U2VpZGVsICA8ZXJpY0B3ZWJraXQub3JnPgogCiAgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9j b21tb24vY2hlY2tvdXQvYXBpLnB5OiBpbXBvcnQgc2NtLkNvbW1pdE1lc3NhZ2UKICIiIgotX2No YW5nZWxvZzFlbnRyeTIgPSAiIiIyMDEwLTAzLTI1ICBBZGFtIEJhcnRoICA8YWJhcnRoQHdlYmtp dC5vcmc+CitfY2hhbmdlbG9nMWVudHJ5MiA9IHUiIiIyMDEwLTAzLTI1ICBBZGFtIEJhcnRoICA8 YWJhcnRoQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRXJpYyBTZWlkZWwuCiAK QEAgLTYyLDggKzYzLDggQEAgX2NoYW5nZWxvZzFlbnRyeTIgPSAiIiIyMDEwLTAzLTI1ICBBZGFt IEJhcnRoICA8YWJhcnRoQHdlYmtpdC5vcmc+CiAKICAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5 L2NvbW1vbi9jaGVja291dC9hcGkucHk6CiAiIiIKLV9jaGFuZ2Vsb2cxID0gIlxuIi5qb2luKFtf Y2hhbmdlbG9nMWVudHJ5MSwgX2NoYW5nZWxvZzFlbnRyeTJdKQotX2NoYW5nZWxvZzIgPSAiIiIy MDEwLTAzLTI1ICBFcmljIFNlaWRlbCAgPGVyaWNAd2Via2l0Lm9yZz4KK19jaGFuZ2Vsb2cxID0g dSJcbiIuam9pbihbX2NoYW5nZWxvZzFlbnRyeTEsIF9jaGFuZ2Vsb2cxZW50cnkyXSkKK19jaGFu Z2Vsb2cyID0gdSIiIjIwMTAtMDMtMjUgIFRvciBBcm5lIFZlc3RiXHUwMGY4ICA8dmVzdGJvQHdl YmtpdC5vcmc+CiAKICAgICAgICAgVW5yZXZpZXdlZCBidWlsZCBmaXggdG8gdW4tYnJlYWsgd2Vi a2l0LXBhdGNoIGxhbmQuCiAKQEAgLTc5LDcgKzgwLDcgQEAgX2NoYW5nZWxvZzIgPSAiIiIyMDEw LTAzLTI1ICBFcmljIFNlaWRlbCAgPGVyaWNAd2Via2l0Lm9yZz4KICIiIgogCiBjbGFzcyBDb21t aXRNZXNzYWdlRm9yVGhpc0NvbW1pdFRlc3QodW5pdHRlc3QuVGVzdENhc2UpOgotICAgIGV4cGVj dGVkX2NvbW1pdF9tZXNzYWdlID0gIiIiMjAxMC0wMy0yNSAgRXJpYyBTZWlkZWwgIDxlcmljQHdl YmtpdC5vcmc+CisgICAgZXhwZWN0ZWRfY29tbWl0X21lc3NhZ2UgPSB1IiIiMjAxMC0wMy0yNSAg VG9yIEFybmUgVmVzdGJcdTAwZjggIDx2ZXN0Ym9Ad2Via2l0Lm9yZz4KIAogICAgICAgICBVbnJl dmlld2VkIGJ1aWxkIGZpeCB0byB1bi1icmVhayB3ZWJraXQtcGF0Y2ggbGFuZC4KIApAQCAtODcs NyArODgsNyBAQCBjbGFzcyBDb21taXRNZXNzYWdlRm9yVGhpc0NvbW1pdFRlc3QodW5pdHRlc3Qu VGVzdENhc2UpOgogICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MzY2MjkKIAogICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L2Fw aS5weTogaW1wb3J0IHNjbS5Db21taXRNZXNzYWdlCi0yMDEwLTAzLTI1ICBFcmljIFNlaWRlbCAg PGVyaWNAd2Via2l0Lm9yZz4KKzIwMTAtMDMtMjUgIFRvciBBcm5lIFZlc3RiXHUwMGY4ICA8dmVz dGJvQHdlYmtpdC5vcmc+CiAKICAgICAgICAgVW5yZXZpZXdlZCBidWlsZCBmaXggdG8gdW4tYnJl YWsgd2Via2l0LXBhdGNoIGxhbmQuCiAKQEAgLTEzNyw4ICsxMzgsOCBAQCBjbGFzcyBDaGVja291 dFRlc3QodW5pdHRlc3QuVGVzdENhc2UpOgogICAgICAgICBjaGVja291dC5jaGFuZ2Vsb2dfZW50 cmllc19mb3JfcmV2aXNpb24gPSBsYW1iZGEgcmV2aXNpb246IFtDaGFuZ2VMb2dFbnRyeShfY2hh bmdlbG9nMWVudHJ5MSldCiAgICAgICAgIGNvbW1pdGluZm8gPSBjaGVja291dC5jb21taXRfaW5m b19mb3JfcmV2aXNpb24oNCkKICAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChjb21taXRpbmZvLmJ1 Z19pZCgpLCAzNjYyOSkKLSAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChjb21taXRpbmZvLmF1dGhv cl9uYW1lKCksICJFcmljIFNlaWRlbCIpCi0gICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoY29tbWl0 aW5mby5hdXRob3JfZW1haWwoKSwgImVyaWNAd2Via2l0Lm9yZyIpCisgICAgICAgIHNlbGYuYXNz ZXJ0RXF1YWwoY29tbWl0aW5mby5hdXRob3JfbmFtZSgpLCB1IlRvciBBcm5lIFZlc3RiXHUwMGY4 IikKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChjb21taXRpbmZvLmF1dGhvcl9lbWFpbCgpLCAi dmVzdGJvQHdlYmtpdC5vcmciKQogICAgICAgICBzZWxmLmFzc2VydEVxdWFsKGNvbW1pdGluZm8u cmV2aWV3ZXJfdGV4dCgpLCBOb25lKQogICAgICAgICBzZWxmLmFzc2VydEVxdWFsKGNvbW1pdGlu Zm8ucmV2aWV3ZXIoKSwgTm9uZSkKICAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChjb21taXRpbmZv LmNvbW1pdHRlcl9lbWFpbCgpLCAiY29tbWl0dGVyQGV4YW1wbGUuY29tIikKZGlmZiAtLWdpdCBh L1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L2NoYW5nZWxvZ191 bml0dGVzdC5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0 L2NoYW5nZWxvZ191bml0dGVzdC5weQppbmRleCA5MjEwYzljLi4wYmM1Y2JlIDEwMDY0NAotLS0g YS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9jaGFuZ2Vsb2df dW5pdHRlc3QucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hl Y2tvdXQvY2hhbmdlbG9nX3VuaXR0ZXN0LnB5CkBAIC04Nyw3ICs4Nyw3IEBAIGNsYXNzIENoYW5n ZUxvZ3NUZXN0KHVuaXR0ZXN0LlRlc3RDYXNlKToKICcnJwogCiAgICAgZGVmIHRlc3RfbGF0ZXN0 X2VudHJ5X3BhcnNlKHNlbGYpOgotICAgICAgICBjaGFuZ2Vsb2dfY29udGVudHMgPSAiJXNcbiVz IiAlIChzZWxmLl9leGFtcGxlX2VudHJ5LCBzZWxmLl9leGFtcGxlX2NoYW5nZWxvZykKKyAgICAg ICAgY2hhbmdlbG9nX2NvbnRlbnRzID0gdSIlc1xuJXMiICUgKHNlbGYuX2V4YW1wbGVfZW50cnks IHNlbGYuX2V4YW1wbGVfY2hhbmdlbG9nKQogICAgICAgICBjaGFuZ2Vsb2dfZmlsZSA9IFN0cmlu Z0lPKGNoYW5nZWxvZ19jb250ZW50cykKICAgICAgICAgbGF0ZXN0X2VudHJ5ID0gQ2hhbmdlTG9n LnBhcnNlX2xhdGVzdF9lbnRyeV9mcm9tX2ZpbGUoY2hhbmdlbG9nX2ZpbGUpCiAgICAgICAgIHNl bGYuYXNzZXJ0RXF1YWxzKGxhdGVzdF9lbnRyeS5jb250ZW50cygpLCBzZWxmLl9leGFtcGxlX2Vu dHJ5KQpAQCAtMTIxLDcgKzEyMSw3IEBAIGNsYXNzIENoYW5nZUxvZ3NUZXN0KHVuaXR0ZXN0LlRl c3RDYXNlKToKICcnJwogCiAgICAgZGVmIHRlc3Rfc2V0X3Jldmlld2VyKHNlbGYpOgotICAgICAg ICBjaGFuZ2Vsb2dfY29udGVudHMgPSAiJXNcbiVzIiAlIChzZWxmLl9uZXdfZW50cnlfYm9pbGVy cGxhdGUsIHNlbGYuX2V4YW1wbGVfY2hhbmdlbG9nKQorICAgICAgICBjaGFuZ2Vsb2dfY29udGVu dHMgPSB1IiVzXG4lcyIgJSAoc2VsZi5fbmV3X2VudHJ5X2JvaWxlcnBsYXRlLCBzZWxmLl9leGFt cGxlX2NoYW5nZWxvZykKICAgICAgICAgY2hhbmdlbG9nX3BhdGggPSBzZWxmLl93cml0ZV90bXBf ZmlsZV93aXRoX2NvbnRlbnRzKGNoYW5nZWxvZ19jb250ZW50cykKICAgICAgICAgcmV2aWV3ZXJf bmFtZSA9ICdUZXN0IFJldmlld2VyJwogICAgICAgICBDaGFuZ2VMb2coY2hhbmdlbG9nX3BhdGgp LnNldF9yZXZpZXdlcihyZXZpZXdlcl9uYW1lKQpAQCAtMTY5LDcgKzE2OSw3IEBAIGNsYXNzIENo YW5nZUxvZ3NUZXN0KHVuaXR0ZXN0LlRlc3RDYXNlKToKICcnJwogCiAgICAgZGVmIF9hc3NlcnRf dXBkYXRlX2Zvcl9yZXZlcnRfb3V0cHV0KHNlbGYsIGFyZ3MsIGV4cGVjdGVkX2VudHJ5KToKLSAg ICAgICAgY2hhbmdlbG9nX2NvbnRlbnRzID0gIiVzXG4lcyIgJSAoc2VsZi5fbmV3X2VudHJ5X2Jv aWxlcnBsYXRlLCBzZWxmLl9leGFtcGxlX2NoYW5nZWxvZykKKyAgICAgICAgY2hhbmdlbG9nX2Nv bnRlbnRzID0gdSIlc1xuJXMiICUgKHNlbGYuX25ld19lbnRyeV9ib2lsZXJwbGF0ZSwgc2VsZi5f ZXhhbXBsZV9jaGFuZ2Vsb2cpCiAgICAgICAgIGNoYW5nZWxvZ19wYXRoID0gc2VsZi5fd3JpdGVf dG1wX2ZpbGVfd2l0aF9jb250ZW50cyhjaGFuZ2Vsb2dfY29udGVudHMpCiAgICAgICAgIGNoYW5n ZWxvZyA9IENoYW5nZUxvZyhjaGFuZ2Vsb2dfcGF0aCkKICAgICAgICAgY2hhbmdlbG9nLnVwZGF0 ZV9mb3JfcmV2ZXJ0KCphcmdzKQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJr aXRweS9jb21tb24vY2hlY2tvdXQvc2NtLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRw eS9jb21tb24vY2hlY2tvdXQvc2NtLnB5CmluZGV4IDI3MDRmMDcuLmM0ZjQ4Y2UgMTAwNjQ0Ci0t LSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3NjbS5weQor KysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9zY20ucHkK QEAgLTE0NSw3ICsxNDUsNyBAQCBjbGFzcyBTQ006CiAgICAgICAgIHJldHVybiBmaWxlbmFtZXMK IAogICAgIGRlZiBzdHJpcF9yX2Zyb21fc3ZuX3JldmlzaW9uKHNlbGYsIHN2bl9yZXZpc2lvbik6 Ci0gICAgICAgIG1hdGNoID0gcmUubWF0Y2goIl5yKD9QPHN2bl9yZXZpc2lvbj5cZCspIiwgc3Zu X3JldmlzaW9uKQorICAgICAgICBtYXRjaCA9IHJlLm1hdGNoKCJecig/UDxzdm5fcmV2aXNpb24+ XGQrKSIsIHVuaWNvZGUoc3ZuX3JldmlzaW9uKSkKICAgICAgICAgaWYgKG1hdGNoKToKICAgICAg ICAgICAgIHJldHVybiBtYXRjaC5ncm91cCgnc3ZuX3JldmlzaW9uJykKICAgICAgICAgcmV0dXJu IHN2bl9yZXZpc2lvbgpAQCAtMzQ0LDcgKzM0NCw3IEBAIGNsYXNzIFNWTihTQ00pOgogCiAgICAg ZGVmIGNoYW5nZWRfZmlsZXNfZm9yX3JldmlzaW9uKHNlbGYsIHJldmlzaW9uKToKICAgICAgICAg IyBBcyBmYXIgYXMgSSBjYW4gdGVsbCBzdm4gZGlmZiAtLXN1bW1hcml6ZSBvdXRwdXQgbG9va3Mg anVzdCBsaWtlIHN2biBzdGF0dXMgb3V0cHV0LgotICAgICAgICBzdGF0dXNfY29tbWFuZCA9IFsi c3ZuIiwgImRpZmYiLCAiLS1zdW1tYXJpemUiLCAiLWMiLCBzdHIocmV2aXNpb24pXQorICAgICAg ICBzdGF0dXNfY29tbWFuZCA9IFsic3ZuIiwgImRpZmYiLCAiLS1zdW1tYXJpemUiLCAiLWMiLCBy ZXZpc2lvbl0KICAgICAgICAgcmV0dXJuIHNlbGYucnVuX3N0YXR1c19hbmRfZXh0cmFjdF9maWxl bmFtZXMoc3RhdHVzX2NvbW1hbmQsIHNlbGYuX3N0YXR1c19yZWdleHAoIkFDRE1SIikpCiAKICAg ICBkZWYgY29uZmxpY3RlZF9maWxlcyhzZWxmKToKQEAgLTM2NCwxNSArMzY0LDE1IEBAIGNsYXNz IFNWTihTQ00pOgogICAgICAgICByZXR1cm4gcnVuX2NvbW1hbmQoc2VsZi5zY3JpcHRfcGF0aCgi c3ZuLWNyZWF0ZS1wYXRjaCIpLCBjd2Q9c2VsZi5jaGVja291dF9yb290LCByZXR1cm5fc3RkZXJy PUZhbHNlKQogCiAgICAgZGVmIGNvbW1pdHRlcl9lbWFpbF9mb3JfcmV2aXNpb24oc2VsZiwgcmV2 aXNpb24pOgotICAgICAgICByZXR1cm4gcnVuX2NvbW1hbmQoWyJzdm4iLCAicHJvcGdldCIsICJz dm46YXV0aG9yIiwgIi0tcmV2cHJvcCIsICItciIsIHN0cihyZXZpc2lvbildKS5yc3RyaXAoKQor ICAgICAgICByZXR1cm4gcnVuX2NvbW1hbmQoWyJzdm4iLCAicHJvcGdldCIsICJzdm46YXV0aG9y IiwgIi0tcmV2cHJvcCIsICItciIsIHJldmlzaW9uXSkucnN0cmlwKCkKIAogICAgIGRlZiBjb250 ZW50c19hdF9yZXZpc2lvbihzZWxmLCBwYXRoLCByZXZpc2lvbik6CiAgICAgICAgIHJlbW90ZV9w YXRoID0gIiVzLyVzIiAlIChzZWxmLl9yZXBvc2l0b3J5X3VybCgpLCBwYXRoKQotICAgICAgICBy ZXR1cm4gcnVuX2NvbW1hbmQoWyJzdm4iLCAiY2F0IiwgIi1yIiwgc3RyKHJldmlzaW9uKSwgcmVt b3RlX3BhdGhdKQorICAgICAgICByZXR1cm4gcnVuX2NvbW1hbmQoWyJzdm4iLCAiY2F0IiwgIi1y IiwgcmV2aXNpb24sIHJlbW90ZV9wYXRoXSkKIAogICAgIGRlZiBkaWZmX2Zvcl9yZXZpc2lvbihz ZWxmLCByZXZpc2lvbik6CiAgICAgICAgICMgRklYTUU6IFRoaXMgc2hvdWxkIHByb2JhYmx5IHVz ZSBjd2Q9c2VsZi5jaGVja291dF9yb290Ci0gICAgICAgIHJldHVybiBydW5fY29tbWFuZChbJ3N2 bicsICdkaWZmJywgJy1jJywgc3RyKHJldmlzaW9uKV0pCisgICAgICAgIHJldHVybiBydW5fY29t bWFuZChbJ3N2bicsICdkaWZmJywgJy1jJywgcmV2aXNpb25dKQogCiAgICAgZGVmIF9yZXBvc2l0 b3J5X3VybChzZWxmKToKICAgICAgICAgcmV0dXJuIHNlbGYudmFsdWVfZnJvbV9zdm5faW5mbyhz ZWxmLmNoZWNrb3V0X3Jvb3QsICdVUkwnKQpAQCAtNDA1LDcgKzQwNSw3IEBAIGNsYXNzIFNWTihT Q00pOgogICAgICAgICByZXR1cm4gcnVuX2NvbW1hbmQoc3ZuX2NvbW1pdF9hcmdzLCBlcnJvcl9o YW5kbGVyPWNvbW1pdF9lcnJvcl9oYW5kbGVyKQogCiAgICAgZGVmIHN2bl9jb21taXRfbG9nKHNl bGYsIHN2bl9yZXZpc2lvbik6Ci0gICAgICAgIHN2bl9yZXZpc2lvbiA9IHNlbGYuc3RyaXBfcl9m cm9tX3N2bl9yZXZpc2lvbihzdHIoc3ZuX3JldmlzaW9uKSkKKyAgICAgICAgc3ZuX3JldmlzaW9u ID0gc2VsZi5zdHJpcF9yX2Zyb21fc3ZuX3JldmlzaW9uKHN2bl9yZXZpc2lvbikKICAgICAgICAg cmV0dXJuIHJ1bl9jb21tYW5kKFsnc3ZuJywgJ2xvZycsICctLW5vbi1pbnRlcmFjdGl2ZScsICct LXJldmlzaW9uJywgc3ZuX3JldmlzaW9uXSk7CiAKICAgICBkZWYgbGFzdF9zdm5fY29tbWl0X2xv ZyhzZWxmKToKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9u L2NoZWNrb3V0L3NjbV91bml0dGVzdC5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkv Y29tbW9uL2NoZWNrb3V0L3NjbV91bml0dGVzdC5weQppbmRleCBjMGE2NGQ0Li45NzI3ZmI3IDEw MDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9z Y21fdW5pdHRlc3QucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24v Y2hlY2tvdXQvc2NtX3VuaXR0ZXN0LnB5CkBAIC0yOCw2ICsyOCw3IEBACiAjIE9GIFRISVMgU09G VFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0Uu CiAKIGltcG9ydCBiYXNlNjQKK2ltcG9ydCBjb2RlY3MKIGltcG9ydCBnZXRwYXNzCiBpbXBvcnQg b3MKIGltcG9ydCBvcy5wYXRoCkBAIC01NywxMiArNTgsMTIgQEAgZGVmIHJ1bl9zaWxlbnQoYXJn cywgY3dkPU5vbmUpOgogICAgICAgICByYWlzZSBTY3JpcHRFcnJvcignRmFpbGVkIHRvIHJ1biAi JXMiICBleGl0X2NvZGU6ICVkICBjd2Q6ICVzJyAlIChhcmdzLCBleGl0X2NvZGUsIGN3ZCkpCiAK IGRlZiB3cml0ZV9pbnRvX2ZpbGVfYXRfcGF0aChmaWxlX3BhdGgsIGNvbnRlbnRzKToKLSAgICBm aWxlID0gb3BlbihmaWxlX3BhdGgsICd3JykKKyAgICBmaWxlID0gY29kZWNzLm9wZW4oZmlsZV9w YXRoLCAidyIsICJ1dGYtOCIpCiAgICAgZmlsZS53cml0ZShjb250ZW50cykKICAgICBmaWxlLmNs b3NlKCkKIAogZGVmIHJlYWRfZnJvbV9wYXRoKGZpbGVfcGF0aCk6Ci0gICAgZmlsZSA9IG9wZW4o ZmlsZV9wYXRoLCAncicpCisgICAgZmlsZSA9IGNvZGVjcy5vcGVuKGZpbGVfcGF0aCwgInIiLCAi dXRmLTgiKQogICAgIGNvbnRlbnRzID0gZmlsZS5yZWFkKCkKICAgICBmaWxlLmNsb3NlKCkKICAg ICByZXR1cm4gY29udGVudHMKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0 cHkvY29tbW9uL2NvbmZpZy9jb21taXR0ZXJzLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJr aXRweS9jb21tb24vY29uZmlnL2NvbW1pdHRlcnMucHkKaW5kZXggMWJlYzI5MC4uNjZhNGMxYiAx MDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY29uZmlnL2Nv bW1pdHRlcnMucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY29u ZmlnL2NvbW1pdHRlcnMucHkKQEAgLTIzNyw3ICsyMzcsNyBAQCByZXZpZXdlcnNfbGlzdCA9IFsK ICAgICBSZXZpZXdlcigiU3RldmUgRmFsa2VuYnVyZyIsICJzZmFsa2VuQGFwcGxlLmNvbSIsICJz ZmFsa2VuIiksCiAgICAgUmV2aWV3ZXIoIlRpbSBPbWVybmljayIsICJ0aW1vQGFwcGxlLmNvbSIp LAogICAgIFJldmlld2VyKCJUaW1vdGh5IEhhdGNoZXIiLCBbInRpbW90aHlAaGF0Y2hlci5uYW1l IiwgInRpbW90aHlAYXBwbGUuY29tIl0sICJ4ZW5vbiIpLAotICAgIFJldmlld2VyKHUnVG9yIEFy bmUgVmVzdGJceGY4JywgInZlc3Rib0B3ZWJraXQub3JnIiwgInRvcmFybmUiKSwKKyAgICBSZXZp ZXdlcih1IlRvciBBcm5lIFZlc3RiXHUwMGY4IiwgInZlc3Rib0B3ZWJraXQub3JnIiwgInRvcmFy bmUiKSwKICAgICBSZXZpZXdlcigiVmlja2kgTXVybGV5IiwgInZpY2tpQGFwcGxlLmNvbSIpLAog ICAgIFJldmlld2VyKCJYYW4gTG9wZXoiLCBbInhhbi5sb3BlekBnbWFpbC5jb20iLCAieGFuQGdu b21lLm9yZyIsICJ4YW5Ad2Via2l0Lm9yZyJdLCAieGFuIiksCiAgICAgUmV2aWV3ZXIoIll1cnkg U2VtaWtoYXRza3kiLCAieXVyeXNAY2hyb21pdW0ub3JnIiwgInl1cnlzIiksCmRpZmYgLS1naXQg YS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9uZXQvYnVnemlsbGEucHkgYi9X ZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9uZXQvYnVnemlsbGEucHkKaW5kZXgg YmIyMmQxNC4uNGM0ZjUzNCAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRw eS9jb21tb24vbmV0L2J1Z3ppbGxhLnB5CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0 cHkvY29tbW9uL25ldC9idWd6aWxsYS5weQpAQCAtNDExLDcgKzQxMSwxNiBAQCBjbGFzcyBCdWd6 aWxsYShvYmplY3QpOgogICAgICAgICAgICAgaWYgZmxhZ1snc3RhdHVzJ10gPT0gJysnOgogICAg ICAgICAgICAgICAgIGF0dGFjaG1lbnRbcmVzdWx0X2tleV0gPSBmbGFnWydzZXR0ZXInXQogCisg ICAgZGVmIF9zdHJpbmdfY29udGVudHMoc2VsZiwgc291cCk6CisgICAgICAgICMgV2ViS2l0J3Mg YnVnemlsbGEgaW5zdGFuY2UgdXNlcyBVVEYtOC4KKyAgICAgICAgIyBCZWF1dGlmdWxTb3VwIGFs d2F5cyByZXR1cm5zIFVuaWNvZGUgc3RyaW5ncywgaG93ZXZlcgorICAgICAgICAjIHRoZSAuc3Ry aW5nIG1ldGhvZCByZXR1cm5zIGEgKHVuaWNvZGUpIE5hdmlnYWJsZVN0cmluZy4KKyAgICAgICAg IyBOYXZpZ2FibGVTdHJpbmcgY2FuIGNvbmZ1c2Ugb3RoZXIgcGFydHMgb2YgdGhlIGNvZGUsIHNv IHdlCisgICAgICAgICMgY29udmVydCBmcm9tIE5hdmlnYWJsZVN0cmluZyB0byBhIHJlYWwgdW5p Y29kZSgpIG9iamVjdCB1c2luZyB1bmljb2RlKCkuCisgICAgICAgIHJldHVybiB1bmljb2RlKHNv dXAuc3RyaW5nKQorCiAgICAgZGVmIF9wYXJzZV9hdHRhY2htZW50X2VsZW1lbnQoc2VsZiwgZWxl bWVudCwgYnVnX2lkKToKKwogICAgICAgICBhdHRhY2htZW50ID0ge30KICAgICAgICAgYXR0YWNo bWVudFsnYnVnX2lkJ10gPSBidWdfaWQKICAgICAgICAgYXR0YWNobWVudFsnaXNfb2Jzb2xldGUn XSA9IChlbGVtZW50Lmhhc19rZXkoJ2lzb2Jzb2xldGUnKSBhbmQgZWxlbWVudFsnaXNvYnNvbGV0 ZSddID09ICIxIikKQEAgLTQxOSw5ICs0MjgsOSBAQCBjbGFzcyBCdWd6aWxsYShvYmplY3QpOgog ICAgICAgICBhdHRhY2htZW50WydpZCddID0gaW50KGVsZW1lbnQuZmluZCgnYXR0YWNoaWQnKS5z dHJpbmcpCiAgICAgICAgICMgRklYTUU6IE5vIG5lZWQgdG8gcGFyc2Ugb3V0IHRoZSB1cmwgaGVy ZS4KICAgICAgICAgYXR0YWNobWVudFsndXJsJ10gPSBzZWxmLmF0dGFjaG1lbnRfdXJsX2Zvcl9p ZChhdHRhY2htZW50WydpZCddKQotICAgICAgICBhdHRhY2htZW50WyduYW1lJ10gPSB1bmljb2Rl KGVsZW1lbnQuZmluZCgnZGVzYycpLnN0cmluZykKLSAgICAgICAgYXR0YWNobWVudFsnYXR0YWNo ZXJfZW1haWwnXSA9IHN0cihlbGVtZW50LmZpbmQoJ2F0dGFjaGVyJykuc3RyaW5nKQotICAgICAg ICBhdHRhY2htZW50Wyd0eXBlJ10gPSBzdHIoZWxlbWVudC5maW5kKCd0eXBlJykuc3RyaW5nKQor ICAgICAgICBhdHRhY2htZW50WyduYW1lJ10gPSBzZWxmLl9zdHJpbmdfY29udGVudHMoZWxlbWVu dC5maW5kKCdkZXNjJykpCisgICAgICAgIGF0dGFjaG1lbnRbJ2F0dGFjaGVyX2VtYWlsJ10gPSBz ZWxmLl9zdHJpbmdfY29udGVudHMoZWxlbWVudC5maW5kKCdhdHRhY2hlcicpKQorICAgICAgICBh dHRhY2htZW50Wyd0eXBlJ10gPSBzZWxmLl9zdHJpbmdfY29udGVudHMoZWxlbWVudC5maW5kKCd0 eXBlJykpCiAgICAgICAgIHNlbGYuX3BhcnNlX2F0dGFjaG1lbnRfZmxhZygKICAgICAgICAgICAg ICAgICBlbGVtZW50LCAncmV2aWV3JywgYXR0YWNobWVudCwgJ3Jldmlld2VyX2VtYWlsJykKICAg ICAgICAgc2VsZi5fcGFyc2VfYXR0YWNobWVudF9mbGFnKApAQCAtNDMyLDEwICs0NDEsMTAgQEAg Y2xhc3MgQnVnemlsbGEob2JqZWN0KToKICAgICAgICAgc291cCA9IEJlYXV0aWZ1bFNvdXAocGFn ZSkKICAgICAgICAgYnVnID0ge30KICAgICAgICAgYnVnWyJpZCJdID0gaW50KHNvdXAuZmluZCgi YnVnX2lkIikuc3RyaW5nKQotICAgICAgICBidWdbInRpdGxlIl0gPSB1bmljb2RlKHNvdXAuZmlu ZCgic2hvcnRfZGVzYyIpLnN0cmluZykKLSAgICAgICAgYnVnWyJyZXBvcnRlcl9lbWFpbCJdID0g c3RyKHNvdXAuZmluZCgicmVwb3J0ZXIiKS5zdHJpbmcpCi0gICAgICAgIGJ1Z1siYXNzaWduZWRf dG9fZW1haWwiXSA9IHN0cihzb3VwLmZpbmQoImFzc2lnbmVkX3RvIikuc3RyaW5nKQotICAgICAg ICBidWdbImNjX2VtYWlscyJdID0gW3N0cihlbGVtZW50LnN0cmluZykKKyAgICAgICAgYnVnWyJ0 aXRsZSJdID0gc2VsZi5fc3RyaW5nX2NvbnRlbnRzKHNvdXAuZmluZCgic2hvcnRfZGVzYyIpKQor ICAgICAgICBidWdbInJlcG9ydGVyX2VtYWlsIl0gPSBzZWxmLl9zdHJpbmdfY29udGVudHMoc291 cC5maW5kKCJyZXBvcnRlciIpKQorICAgICAgICBidWdbImFzc2lnbmVkX3RvX2VtYWlsIl0gPSBz ZWxmLl9zdHJpbmdfY29udGVudHMoc291cC5maW5kKCJhc3NpZ25lZF90byIpKQorICAgICAgICBi dWdbImNjX2VtYWlscyJdID0gW3NlbGYuX3N0cmluZ19jb250ZW50cyhlbGVtZW50KQogICAgICAg ICAgICAgICAgICAgICAgICAgICAgIGZvciBlbGVtZW50IGluIHNvdXAuZmluZEFsbCgnY2MnKV0K ICAgICAgICAgYnVnWyJhdHRhY2htZW50cyJdID0gW3NlbGYuX3BhcnNlX2F0dGFjaG1lbnRfZWxl bWVudChlbGVtZW50LCBidWdbImlkIl0pIGZvciBlbGVtZW50IGluIHNvdXAuZmluZEFsbCgnYXR0 YWNobWVudCcpXQogICAgICAgICByZXR1cm4gYnVnCkBAIC02MzcsNiArNjQ2LDcgQEAgY2xhc3Mg QnVnemlsbGEob2JqZWN0KToKICAgICAgICAgaWYgY2M6CiAgICAgICAgICAgICBzZWxmLmJyb3dz ZXJbImNjIl0gPSBjYwogICAgICAgICBpZiBibG9ja2VkOgorICAgICAgICAgICAgIyBGSVhNRTog V2hhdCBkb2VzIGJsb2NrZWQgZG8gYW5kIHdoeSBpcyB0aGlzIHVzaW5nIHN0cigpIGluc3RlYWQg b2YgdW5pY29kZSgpPwogICAgICAgICAgICAgc2VsZi5icm93c2VyWyJibG9ja2VkIl0gPSBzdHIo YmxvY2tlZCkKICAgICAgICAgc2VsZi5icm93c2VyWyJzaG9ydF9kZXNjIl0gPSBidWdfdGl0bGUK ICAgICAgICAgc2VsZi5icm93c2VyWyJjb21tZW50Il0gPSBidWdfZGVzY3JpcHRpb24KZGlmZiAt LWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL25ldC9idWlsZGJvdC5w eSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL25ldC9idWlsZGJvdC5weQpp bmRleCBiZTg3ODliLi5kOGFiZjZlIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dl YmtpdHB5L2NvbW1vbi9uZXQvYnVpbGRib3QucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93 ZWJraXRweS9jb21tb24vbmV0L2J1aWxkYm90LnB5CkBAIC00NCw3ICs0NCw3IEBAIF9sb2cgPSBn ZXRfbG9nZ2VyKF9fZmlsZV9fKQogCiBjbGFzcyBCdWlsZGVyKG9iamVjdCk6CiAgICAgZGVmIF9f aW5pdF9fKHNlbGYsIG5hbWUsIGJ1aWxkYm90KToKLSAgICAgICAgc2VsZi5fbmFtZSA9IHVuaWNv ZGUobmFtZSkKKyAgICAgICAgc2VsZi5fbmFtZSA9IG5hbWUKICAgICAgICAgc2VsZi5fYnVpbGRi b3QgPSBidWlsZGJvdAogICAgICAgICBzZWxmLl9idWlsZHNfY2FjaGUgPSB7fQogICAgICAgICBz ZWxmLl9yZXZpc2lvbl90b19idWlsZF9udW1iZXIgPSBOb25lCkBAIC0yMjEsMTIgKzIyMSwxMiBA QCBjbGFzcyBMYXlvdXRUZXN0UmVzdWx0cyhvYmplY3QpOgogICAgICAgICBwYXJzZWRfcmVzdWx0 cyA9IHt9CiAgICAgICAgIHRhYmxlcyA9IEJlYXV0aWZ1bFNvdXAocGFnZSkuZmluZEFsbCgidGFi bGUiKQogICAgICAgICBmb3IgdGFibGUgaW4gdGFibGVzOgotICAgICAgICAgICAgdGFibGVfdGl0 bGUgPSB0YWJsZS5maW5kUHJldmlvdXNTaWJsaW5nKCJwIikuc3RyaW5nCisgICAgICAgICAgICB0 YWJsZV90aXRsZSA9IHVuaWNvZGUodGFibGUuZmluZFByZXZpb3VzU2libGluZygicCIpLnN0cmlu ZykKICAgICAgICAgICAgIGlmIHRhYmxlX3RpdGxlIG5vdCBpbiBjbHMuZXhwZWN0ZWRfa2V5czoK ICAgICAgICAgICAgICAgICAjIFRoaXMgRXhjZXB0aW9uIHNob3VsZCBvbmx5IGV2ZXIgYmUgaGl0 IGlmIHJ1bi13ZWJraXQtdGVzdHMgY2hhbmdlcyBpdHMgcmVzdWx0cy5odG1sIGZvcm1hdC4KLSAg ICAgICAgICAgICAgICByYWlzZSBFeGNlcHRpb24oIlVuaGFuZGxlZCB0aXRsZTogJXMiICUgc3Ry KHRhYmxlX3RpdGxlKSkKKyAgICAgICAgICAgICAgICByYWlzZSBFeGNlcHRpb24oIlVuaGFuZGxl ZCB0aXRsZTogJXMiICUgdGFibGVfdGl0bGUpCiAgICAgICAgICAgICAjIFdlIG1pZ2h0IHdhbnQg dG8gdHJhbnNsYXRlIHRhYmxlIHRpdGxlcyBpbnRvIGlkZW50aWZpZXJzIGJlZm9yZSBzdG9yaW5n LgotICAgICAgICAgICAgcGFyc2VkX3Jlc3VsdHNbdGFibGVfdGl0bGVdID0gW3Jvdy5maW5kKCJh Iikuc3RyaW5nIGZvciByb3cgaW4gdGFibGUuZmluZEFsbCgidHIiKV0KKyAgICAgICAgICAgIHBh cnNlZF9yZXN1bHRzW3RhYmxlX3RpdGxlXSA9IFt1bmljb2RlKHJvdy5maW5kKCJhIikuc3RyaW5n KSBmb3Igcm93IGluIHRhYmxlLmZpbmRBbGwoInRyIildCiAKICAgICAgICAgcmV0dXJuIHBhcnNl ZF9yZXN1bHRzCiAKQEAgLTM1OCw3ICszNTgsNyBAQCBjbGFzcyBCdWlsZEJvdChvYmplY3QpOgog CiAgICAgICAgICMgRmlyc3QgY2VsbCBpcyB0aGUgbmFtZQogICAgICAgICBuYW1lX2xpbmsgPSBz dGF0dXNfY2VsbHNbMF0uZmluZCgnYScpCi0gICAgICAgIGJ1aWxkZXJbIm5hbWUiXSA9IG5hbWVf bGluay5zdHJpbmcKKyAgICAgICAgYnVpbGRlclsibmFtZSJdID0gdW5pY29kZShuYW1lX2xpbmsu c3RyaW5nKQogCiAgICAgICAgIHNlbGYuX3BhcnNlX2xhc3RfYnVpbGRfY2VsbChidWlsZGVyLCBz dGF0dXNfY2VsbHNbMV0pCiAgICAgICAgIHNlbGYuX3BhcnNlX2N1cnJlbnRfYnVpbGRfY2VsbChi dWlsZGVyLCBzdGF0dXNfY2VsbHNbMl0pCkBAIC00MDcsMTMgKzQwNywxMyBAQCBjbGFzcyBCdWls ZEJvdChvYmplY3QpOgogICAgICAgICByZXR1cm4gdXJsbGliMi51cmxvcGVuKGJ1aWxkX3N0YXR1 c191cmwpCiAKICAgICBkZWYgX3BhcnNlX3R3aXN0ZWRfZmlsZV9yb3coc2VsZiwgZmlsZV9yb3cp OgotICAgICAgICBzdHJpbmdfb3JfZW1wdHkgPSBsYW1iZGEgc3RyaW5nOiBzdHIoc3RyaW5nKSBp ZiBzdHJpbmcgZWxzZSAiIgorICAgICAgICBzdHJpbmdfb3JfZW1wdHkgPSBsYW1iZGEgc291cDog dW5pY29kZShzb3VwLnN0cmluZykgaWYgc291cC5zdHJpbmcgZWxzZSB1IiIKICAgICAgICAgZmls ZV9jZWxscyA9IGZpbGVfcm93LmZpbmRBbGwoJ3RkJykKICAgICAgICAgcmV0dXJuIHsKLSAgICAg ICAgICAgICJmaWxlbmFtZSIgOiBzdHJpbmdfb3JfZW1wdHkoZmlsZV9jZWxsc1swXS5maW5kKCJh Iikuc3RyaW5nKSwKLSAgICAgICAgICAgICJzaXplIiA6IHN0cmluZ19vcl9lbXB0eShmaWxlX2Nl bGxzWzFdLnN0cmluZyksCi0gICAgICAgICAgICAidHlwZSIgOiBzdHJpbmdfb3JfZW1wdHkoZmls ZV9jZWxsc1syXS5zdHJpbmcpLAotICAgICAgICAgICAgImVuY29kaW5nIiA6IHN0cmluZ19vcl9l bXB0eShmaWxlX2NlbGxzWzNdLnN0cmluZyksCisgICAgICAgICAgICAiZmlsZW5hbWUiIDogc3Ry aW5nX29yX2VtcHR5KGZpbGVfY2VsbHNbMF0uZmluZCgiYSIpKSwKKyAgICAgICAgICAgICJzaXpl IiA6IHN0cmluZ19vcl9lbXB0eShmaWxlX2NlbGxzWzFdKSwKKyAgICAgICAgICAgICJ0eXBlIiA6 IHN0cmluZ19vcl9lbXB0eShmaWxlX2NlbGxzWzJdKSwKKyAgICAgICAgICAgICJlbmNvZGluZyIg OiBzdHJpbmdfb3JfZW1wdHkoZmlsZV9jZWxsc1szXSksCiAgICAgICAgIH0KIAogICAgIGRlZiBf cGFyc2VfdHdpc3RlZF9kaXJlY3RvcnlfbGlzdGluZyhzZWxmLCBwYWdlKToKZGlmZiAtLWdpdCBh L1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL25ldC9idWlsZGJvdF91bml0dGVz dC5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL25ldC9idWlsZGJvdF91 bml0dGVzdC5weQppbmRleCBhZjkzYmViLi44NjI5NmIzIDEwMDY0NAotLS0gYS9XZWJLaXRUb29s cy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9uZXQvYnVpbGRib3RfdW5pdHRlc3QucHkKKysrIGIv V2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vbmV0L2J1aWxkYm90X3VuaXR0ZXN0 LnB5CkBAIC01MSw3ICs1MSw3IEBAIGNsYXNzIEJ1aWxkZXJUZXN0KHVuaXR0ZXN0LlRlc3RDYXNl KToKIAogICAgIGRlZiBzZXRVcChzZWxmKToKICAgICAgICAgc2VsZi5idWlsZGJvdCA9IEJ1aWxk Qm90KCkKLSAgICAgICAgc2VsZi5idWlsZGVyID0gQnVpbGRlcigiVGVzdCBCdWlsZGVyIiwgc2Vs Zi5idWlsZGJvdCkKKyAgICAgICAgc2VsZi5idWlsZGVyID0gQnVpbGRlcih1IlRlc3QgQnVpbGRl ciBcdTI2NjEiLCBzZWxmLmJ1aWxkYm90KQogICAgICAgICBzZWxmLl9pbnN0YWxsX2ZldGNoX2J1 aWxkKGxhbWJkYSBidWlsZF9udW1iZXI6IFsidGVzdDEiLCAidGVzdDIiXSkKIAogICAgIGRlZiB0 ZXN0X2ZpbmRfZmFpbHVyZV90cmFuc2l0aW9uKHNlbGYpOgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9v bHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vbmV0L3N0YXR1c3NlcnZlci5weSBiL1dlYktpdFRv b2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL25ldC9zdGF0dXNzZXJ2ZXIucHkKaW5kZXggZTg5 ODdhOS4uZDliNTJhMiAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9j b21tb24vbmV0L3N0YXR1c3NlcnZlci5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtp dHB5L2NvbW1vbi9uZXQvc3RhdHVzc2VydmVyLnB5CkBAIC01Miw5ICs1Miw5IEBAIGNsYXNzIFN0 YXR1c1NlcnZlcjoKICAgICAgICAgaWYgbm90IHBhdGNoOgogICAgICAgICAgICAgcmV0dXJuCiAg ICAgICAgIGlmIHBhdGNoLmJ1Z19pZCgpOgotICAgICAgICAgICAgc2VsZi5icm93c2VyWyJidWdf aWQiXSA9IHN0cihwYXRjaC5idWdfaWQoKSkKKyAgICAgICAgICAgIHNlbGYuYnJvd3NlclsiYnVn X2lkIl0gPSB1bmljb2RlKHBhdGNoLmJ1Z19pZCgpKQogICAgICAgICBpZiBwYXRjaC5pZCgpOgot ICAgICAgICAgICAgc2VsZi5icm93c2VyWyJwYXRjaF9pZCJdID0gc3RyKHBhdGNoLmlkKCkpCisg ICAgICAgICAgICBzZWxmLmJyb3dzZXJbInBhdGNoX2lkIl0gPSB1bmljb2RlKHBhdGNoLmlkKCkp CiAKICAgICBkZWYgX2FkZF9yZXN1bHRzX2ZpbGUoc2VsZiwgcmVzdWx0c19maWxlKToKICAgICAg ICAgaWYgbm90IHJlc3VsdHNfZmlsZToKQEAgLTc5LDcgKzc5LDcgQEAgY2xhc3MgU3RhdHVzU2Vy dmVyOgogICAgICAgICB1cGRhdGVfc3ZuX3JldmlzaW9uX3VybCA9ICIlcy91cGRhdGUtc3ZuLXJl dmlzaW9uIiAlIHNlbGYudXJsCiAgICAgICAgIHNlbGYuYnJvd3Nlci5vcGVuKHVwZGF0ZV9zdm5f cmV2aXNpb25fdXJsKQogICAgICAgICBzZWxmLmJyb3dzZXIuc2VsZWN0X2Zvcm0obmFtZT0idXBk YXRlX3N2bl9yZXZpc2lvbiIpCi0gICAgICAgIHNlbGYuYnJvd3NlclsibnVtYmVyIl0gPSBzdHIo c3ZuX3JldmlzaW9uX251bWJlcikKKyAgICAgICAgc2VsZi5icm93c2VyWyJudW1iZXIiXSA9IHVu aWNvZGUoc3ZuX3JldmlzaW9uX251bWJlcikKICAgICAgICAgc2VsZi5icm93c2VyWyJicm9rZW5f Ym90Il0gPSBicm9rZW5fYm90CiAgICAgICAgIHJldHVybiBzZWxmLmJyb3dzZXIuc3VibWl0KCku cmVhZCgpCiAKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9u L3ByZXR0eXBhdGNoLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vcHJl dHR5cGF0Y2gucHkKaW5kZXggODE1N2Y5Yy4uZTdjODc2YSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9v bHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vcHJldHR5cGF0Y2gucHkKKysrIGIvV2ViS2l0VG9v bHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vcHJldHR5cGF0Y2gucHkKQEAgLTM4LDcgKzM4LDcg QEAgY2xhc3MgUHJldHR5UGF0Y2gob2JqZWN0KToKICAgICBkZWYgcHJldHR5X2RpZmZfZmlsZShz ZWxmLCBkaWZmKToKICAgICAgICAgcHJldHR5X2RpZmYgPSBzZWxmLnByZXR0eV9kaWZmKGRpZmYp CiAgICAgICAgIGRpZmZfZmlsZSA9IHRlbXBmaWxlLk5hbWVkVGVtcG9yYXJ5RmlsZShzdWZmaXg9 Ii5odG1sIikKLSAgICAgICAgZGlmZl9maWxlLndyaXRlKHByZXR0eV9kaWZmKQorICAgICAgICBk aWZmX2ZpbGUud3JpdGUocHJldHR5X2RpZmYuZW5jb2RlKCJ1dGYtOCIpKQogICAgICAgICBkaWZm X2ZpbGUuZmx1c2goKQogICAgICAgICByZXR1cm4gZGlmZl9maWxlCiAKZGlmZiAtLWdpdCBhL1dl YktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL3N5c3RlbS9hdXRvaW5zdGFsbC5weSBi L1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL3N5c3RlbS9hdXRvaW5zdGFsbC5w eQppbmRleCAzMmZkMmNmLi5kZGFjZDYyIDEwMDc1NQotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRz L3dlYmtpdHB5L2NvbW1vbi9zeXN0ZW0vYXV0b2luc3RhbGwucHkKKysrIGIvV2ViS2l0VG9vbHMv U2NyaXB0cy93ZWJraXRweS9jb21tb24vc3lzdGVtL2F1dG9pbnN0YWxsLnB5CkBAIC0xMjQsNyAr MTI0LDcgQEAgY2xhc3MgQXV0b0luc3RhbGxlcihvYmplY3QpOgogICAgICAgICBfbG9nLmRlYnVn KCcgICAgIiVzIicgJSBwYXRoKQogICAgICAgICBmaWxlID0gb3BlbihwYXRoLCAidyIpCiAgICAg ICAgIHRyeToKLSAgICAgICAgICAgIGZpbGUud3JpdGUodGV4dCkKKyAgICAgICAgICAgIGZpbGUu d3JpdGUodGV4dCkgIyBGSVhNRTogV2hhdCdzIHRoZSBlbmNvZGluZyBvZiB0aGlzIGZpbGU/CiAg ICAgICAgIGZpbmFsbHk6CiAgICAgICAgICAgICBmaWxlLmNsb3NlKCkKIApkaWZmIC0tZ2l0IGEv V2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vc3lzdGVtL2RlcHJlY2F0ZWRfbG9n Z2luZy5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL3N5c3RlbS9kZXBy ZWNhdGVkX2xvZ2dpbmcucHkKaW5kZXggYmExYzVlYi4uZjdlNTlhMyAxMDA2NDQKLS0tIGEvV2Vi S2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vc3lzdGVtL2RlcHJlY2F0ZWRfbG9nZ2lu Zy5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9zeXN0ZW0vZGVw cmVjYXRlZF9sb2dnaW5nLnB5CkBAIC00NSw5ICs0NSwxMCBAQCBjbGFzcyB0ZWU6CiAgICAgZGVm IF9faW5pdF9fKHNlbGYsICpmaWxlcyk6CiAgICAgICAgIHNlbGYuZmlsZXMgPSBmaWxlcwogCi0g ICAgZGVmIHdyaXRlKHNlbGYsIHN0cmluZyk6CisgICAgIyBDYWxsZXJzIHNob3VsZCBwYXNzIGFu IGFscmVhZHkgZW5jb2RlZCBzdHJpbmcgZm9yIHdyaXRpbmcuCisgICAgZGVmIHdyaXRlKHNlbGYs IGJ5dGVzKToKICAgICAgICAgZm9yIGZpbGUgaW4gc2VsZi5maWxlczoKLSAgICAgICAgICAgIGZp bGUud3JpdGUoc3RyaW5nKQorICAgICAgICAgICAgZmlsZS53cml0ZShieXRlcykKIAogY2xhc3Mg T3V0cHV0VGVlOgogICAgIGRlZiBfX2luaXRfXyhzZWxmKToKZGlmZiAtLWdpdCBhL1dlYktpdFRv b2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL3N5c3RlbS9leGVjdXRpdmUucHkgYi9XZWJLaXRU b29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9zeXN0ZW0vZXhlY3V0aXZlLnB5CmluZGV4IGI2 MTI2ZTQuLmNiZTBlMWYgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkv Y29tbW9uL3N5c3RlbS9leGVjdXRpdmUucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJr aXRweS9jb21tb24vc3lzdGVtL2V4ZWN1dGl2ZS5weQpAQCAtODgsNiArODgsNyBAQCBkZWYgcnVu X2NvbW1hbmQoKmFyZ3MsICoqa3dhcmdzKToKIGNsYXNzIEV4ZWN1dGl2ZShvYmplY3QpOgogCiAg ICAgZGVmIF9ydW5fY29tbWFuZF93aXRoX3RlZWRfb3V0cHV0KHNlbGYsIGFyZ3MsIHRlZWRfb3V0 cHV0KToKKyAgICAgICAgYXJncyA9IG1hcCh1bmljb2RlLCBhcmdzKSAgIyBQb3BlbiB3aWxsIHRo cm93IGFuIGV4Y2VwdGlvbiBpZiBhcmdzIGFyZSBub24tc3RyaW5ncyAobGlrZSBpbnQoKSkKICAg ICAgICAgY2hpbGRfcHJvY2VzcyA9IHN1YnByb2Nlc3MuUG9wZW4oYXJncywKICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3Rkb3V0PXN1YnByb2Nlc3MuUElQRSwKICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3RkZXJyPXN1YnByb2Nlc3Mu U1RET1VUKQpAQCAtOTksOSArMTAwLDE2IEBAIGNsYXNzIEV4ZWN1dGl2ZShvYmplY3QpOgogICAg ICAgICAgICAgb3V0cHV0X2xpbmUgPSBjaGlsZF9wcm9jZXNzLnN0ZG91dC5yZWFkbGluZSgpCiAg ICAgICAgICAgICBpZiBvdXRwdXRfbGluZSA9PSAiIiBhbmQgY2hpbGRfcHJvY2Vzcy5wb2xsKCkg IT0gTm9uZToKICAgICAgICAgICAgICAgICByZXR1cm4gY2hpbGRfcHJvY2Vzcy5wb2xsKCkKKyAg ICAgICAgICAgICMgV2UgYXNzdW1lIHRoYXQgdGhlIGNoaWxkIHByb2Nlc3Mgd3JvdGUgdG8gdXMg aW4gdXRmLTgsCisgICAgICAgICAgICAjIHNvIG5vIHJlLWVuY29kaW5nIGlzIG5lY2Vzc2FyeSBi ZWZvcmUgd3JpdGluZyBoZXJlLgogICAgICAgICAgICAgdGVlZF9vdXRwdXQud3JpdGUob3V0cHV0 X2xpbmUpCiAKLSAgICBkZWYgcnVuX2FuZF90aHJvd19pZl9mYWlsKHNlbGYsIGFyZ3MsIHF1aWV0 PUZhbHNlKToKKyAgICAjIEZJWE1FOiBSZW1vdmUgdGhpcyBkZXByZWNhdGVkIG1ldGhvZCBhbmQg bW92ZSBjYWxsZXJzIHRvIHJ1bl9jb21tYW5kLgorICAgICMgRklYTUU6IFRoaXMgbWV0aG9kIGlz IGEgaGFjayB0byBhbGxvdyBydW5uaW5nIGNvbW1hbmQgd2hpY2ggYm90aAorICAgICMgY2FwdHVy ZSB0aGVpciBvdXRwdXQgYW5kIHByaW50IG91dCB0byBzdGRpbi4gIFVzZWZ1bCBmb3IgdGhpbmdz CisgICAgIyBsaWtlICJidWlsZC13ZWJraXQiIHdoZXJlIHdlIHdhbnQgdG8gZGlzcGxheSB0byB0 aGUgdXNlciB0aGF0IHdlJ3JlIGJ1aWxkaW5nCisgICAgIyBidXQgc3RpbGwgaGF2ZSB0aGUgb3V0 cHV0IHRvIHN0dWZmIGludG8gYSBsb2cgZmlsZS4KKyAgICBkZWYgcnVuX2FuZF90aHJvd19pZl9m YWlsKHNlbGYsIGFyZ3MsIHF1aWV0PUZhbHNlLCBkZWNvZGVfb3V0cHV0PVRydWUpOgogICAgICAg ICAjIENhY2hlIHRoZSBjaGlsZCdzIG91dHB1dCBsb2NhbGx5IHNvIGl0IGNhbiBiZSB1c2VkIGZv ciBlcnJvciByZXBvcnRzLgogICAgICAgICBjaGlsZF9vdXRfZmlsZSA9IFN0cmluZ0lPLlN0cmlu Z0lPKCkKICAgICAgICAgdGVlX3N0ZG91dCA9IHN5cy5zdGRvdXQKQEAgLTExNiw2ICsxMjQsMTAg QEAgY2xhc3MgRXhlY3V0aXZlKG9iamVjdCk6CiAgICAgICAgIGNoaWxkX291dHB1dCA9IGNoaWxk X291dF9maWxlLmdldHZhbHVlKCkKICAgICAgICAgY2hpbGRfb3V0X2ZpbGUuY2xvc2UoKQogCisg ICAgICAgICMgV2UgYXNzdW1lIHRoZSBjaGlsZCBwcm9jZXNzIG91dHB1dCB1dGYtOAorICAgICAg ICBpZiBkZWNvZGVfb3V0cHV0OgorICAgICAgICAgICAgY2hpbGRfb3V0cHV0ID0gY2hpbGRfb3V0 cHV0LmRlY29kZSgidXRmLTgiKQorCiAgICAgICAgIGlmIGV4aXRfY29kZToKICAgICAgICAgICAg IHJhaXNlIFNjcmlwdEVycm9yKHNjcmlwdF9hcmdzPWFyZ3MsCiAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBleGl0X2NvZGU9ZXhpdF9jb2RlLApAQCAtMTQ1LDcgKzE1Nyw3IEBAIGNsYXNz IEV4ZWN1dGl2ZShvYmplY3QpOgogICAgICAgICAgICAgIyBvcy5raWxsIGlzbid0IGF2YWlsYWJs ZSBvbiBXaW5kb3dzLiAgSG93ZXZlciwgd2hlbiBJIHRyaWVkIGl0CiAgICAgICAgICAgICAjIHVz aW5nIEN5Z3dpbiwgaXQgd29ya2VkIGZpbmUuICBXZSBzaG91bGQgaW52ZXN0aWdhdGUgd2hldGhl cgogICAgICAgICAgICAgIyB3ZSBuZWVkIHRoaXMgcGxhdGZvcm0gc3BlY2lmaWMgY29kZSBoZXJl LgotICAgICAgICAgICAgc3VicHJvY2Vzcy5jYWxsKCgndGFza2tpbGwuZXhlJywgJy9mJywgJy9w aWQnLCBzdHIocGlkKSksCisgICAgICAgICAgICBzdWJwcm9jZXNzLmNhbGwoKCd0YXNra2lsbC5l eGUnLCAnL2YnLCAnL3BpZCcsIHVuaWNvZGUocGlkKSksCiAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgc3RkaW49b3Blbihvcy5kZXZudWxsLCAncicpLAogICAgICAgICAgICAgICAgICAgICAg ICAgICAgIHN0ZG91dD1zdWJwcm9jZXNzLlBJUEUsCiAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgc3RkZXJyPXN1YnByb2Nlc3MuUElQRSkKQEAgLTE2MywzMSArMTc1LDM0IEBAIGNsYXNzIEV4 ZWN1dGl2ZShvYmplY3QpOgogICAgIGRlZiBpZ25vcmVfZXJyb3IoZXJyb3IpOgogICAgICAgICBw YXNzCiAKLSAgICAjIEZJWE1FOiBUaGlzIHNob3VsZCBiZSBtZXJnZWQgd2l0aCBydW5fYW5kX3Ro cm93X2lmX2ZhaWwKLQorICAgIGRlZiBfY29tcHV0ZV9zdGRpbihzZWxmLCBpbnB1dCk6CisgICAg ICAgICIiIlJldHVybnMgKHN0ZGluLCBzdHJpbmdfdG9fY29tbXVuaWNhdGUpIiIiCisgICAgICAg IGlmIG5vdCBpbnB1dDoKKyAgICAgICAgICAgIHJldHVybiAoTm9uZSwgTm9uZSkKKyAgICAgICAg aWYgaGFzYXR0cihpbnB1dCwgInJlYWQiKTogICMgQ2hlY2sgaWYgdGhlIGlucHV0IGlzIGEgZmls ZS4KKyAgICAgICAgICAgIHJldHVybiAoaW5wdXQsIE5vbmUpICAjIEFzc3VtZSB0aGUgZmlsZSBp cyBpbiB0aGUgcmlnaHQgZW5jb2RpbmcuCisKKyAgICAgICAgIyBQb3BlbiBpbiBQeXRob24gMi41 IGFuZCBiZWZvcmUgZG9lcyBub3QgYXV0b21hdGljYWxseSBlbmNvZGUgdW5pY29kZSBvYmplY3Rz LgorICAgICAgICAjIGh0dHA6Ly9idWdzLnB5dGhvbi5vcmcvaXNzdWU1MjkwCisgICAgICAgICMg U2VlIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zNzUyOAorICAgICAg ICAjIGZvciBhbiBleGFtcGxlIG9mIGEgcmVncmVzaW9uIGNhdXNlZCBieSBwYXNzaW5nIGEgdW5p Y29kZSBzdHJpbmcgZGlyZWN0bHkuCisgICAgICAgICMgRklYTUU6IFdlIG1heSBuZWVkIHRvIGVu Y29kZSBkaWZmZXJlbnRseSBvbiBkaWZmZXJlbnQgcGxhdGZvcm1zLgorICAgICAgICBpZiBpc2lu c3RhbmNlKGlucHV0LCB1bmljb2RlKToKKyAgICAgICAgICAgIGlucHV0ID0gaW5wdXQuZW5jb2Rl KCJ1dGYtOCIpCisgICAgICAgIHJldHVybiAoc3VicHJvY2Vzcy5QSVBFLCBpbnB1dCkKKworICAg ICMgRklYTUU6IHJ1bl9hbmRfdGhyb3dfaWZfZmFpbCBzaG91bGQgYmUgbWVyZ2VkIGludG8gdGhp cyBtZXRob2QuCiAgICAgZGVmIHJ1bl9jb21tYW5kKHNlbGYsCiAgICAgICAgICAgICAgICAgICAg IGFyZ3MsCiAgICAgICAgICAgICAgICAgICAgIGN3ZD1Ob25lLAogICAgICAgICAgICAgICAgICAg ICBpbnB1dD1Ob25lLAogICAgICAgICAgICAgICAgICAgICBlcnJvcl9oYW5kbGVyPU5vbmUsCiAg ICAgICAgICAgICAgICAgICAgIHJldHVybl9leGl0X2NvZGU9RmFsc2UsCi0gICAgICAgICAgICAg ICAgICAgIHJldHVybl9zdGRlcnI9VHJ1ZSk6Ci0gICAgICAgIGlmIGhhc2F0dHIoaW5wdXQsICdy ZWFkJyk6ICMgQ2hlY2sgaWYgdGhlIGlucHV0IGlzIGEgZmlsZS4KLSAgICAgICAgICAgIHN0ZGlu ID0gaW5wdXQKLSAgICAgICAgICAgIHN0cmluZ190b19jb21tdW5pY2F0ZSA9IE5vbmUKLSAgICAg ICAgZWxzZToKLSAgICAgICAgICAgIHN0ZGluID0gTm9uZQotICAgICAgICAgICAgaWYgaW5wdXQ6 Ci0gICAgICAgICAgICAgICAgc3RkaW4gPSBzdWJwcm9jZXNzLlBJUEUKLSAgICAgICAgICAgICMg c3RyaW5nX3RvX2NvbW11bmljYXRlIHNlZW1zIHRvIG5lZWQgdG8gYmUgYSBzdHIgZm9yIHByb3Bl cgotICAgICAgICAgICAgIyBjb21tdW5pY2F0aW9uIHdpdGggc2hlbGwgY29tbWFuZHMuCi0gICAg ICAgICAgICAjIFNlZSBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzc1 MjgKLSAgICAgICAgICAgICMgRm9yIGFuIGV4YW1wbGUgb2YgYSByZWdyZXNpb24gY2F1c2VkIGJ5 IHBhc3NpbmcgYSB1bmljb2RlIHN0cmluZyB0aHJvdWdoLgotICAgICAgICAgICAgc3RyaW5nX3Rv X2NvbW11bmljYXRlID0gc3RyKGlucHV0KQotICAgICAgICBpZiByZXR1cm5fc3RkZXJyOgotICAg ICAgICAgICAgc3RkZXJyID0gc3VicHJvY2Vzcy5TVERPVVQKLSAgICAgICAgZWxzZToKLSAgICAg ICAgICAgIHN0ZGVyciA9IE5vbmUKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuX3N0ZGVycj1U cnVlLAorICAgICAgICAgICAgICAgICAgICBkZWNvZGVfb3V0cHV0PVRydWUpOgorICAgICAgICBh cmdzID0gbWFwKHVuaWNvZGUsIGFyZ3MpICAjIFBvcGVuIHdpbGwgdGhyb3cgYW4gZXhjZXB0aW9u IGlmIGFyZ3MgYXJlIG5vbi1zdHJpbmdzIChsaWtlIGludCgpKQorICAgICAgICBzdGRpbiwgc3Ry aW5nX3RvX2NvbW11bmljYXRlID0gc2VsZi5fY29tcHV0ZV9zdGRpbihpbnB1dCkKKyAgICAgICAg c3RkZXJyID0gc3VicHJvY2Vzcy5TVERPVVQgaWYgcmV0dXJuX3N0ZGVyciBlbHNlIE5vbmUKIAog ICAgICAgICBwcm9jZXNzID0gc3VicHJvY2Vzcy5Qb3BlbihhcmdzLAogICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBzdGRpbj1zdGRpbiwKQEAgLTE5NSw2ICsyMTAsOSBAQCBjbGFz cyBFeGVjdXRpdmUob2JqZWN0KToKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg c3RkZXJyPXN0ZGVyciwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY3dkPWN3 ZCkKICAgICAgICAgb3V0cHV0ID0gcHJvY2Vzcy5jb21tdW5pY2F0ZShzdHJpbmdfdG9fY29tbXVu aWNhdGUpWzBdCisgICAgICAgICMgcnVuX2NvbW1hbmQgYXV0b21hdGljYWxseSBkZWNvZGVzIHRv IHVuaWNvZGUoKSB1bmxlc3MgZXhwbGljaXRseSB0b2xkIG5vdCB0by4KKyAgICAgICAgaWYgZGVj b2RlX291dHB1dDoKKyAgICAgICAgICAgIG91dHB1dCA9IG91dHB1dC5kZWNvZGUoInV0Zi04IikK ICAgICAgICAgZXhpdF9jb2RlID0gcHJvY2Vzcy53YWl0KCkKIAogICAgICAgICBpZiByZXR1cm5f ZXhpdF9jb2RlOgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21t b24vc3lzdGVtL2V4ZWN1dGl2ZV91bml0dGVzdC5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvY29tbW9uL3N5c3RlbS9leGVjdXRpdmVfdW5pdHRlc3QucHkKaW5kZXggYWMzODBmOC4u NjRjNTUyYiAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24v c3lzdGVtL2V4ZWN1dGl2ZV91bml0dGVzdC5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dl YmtpdHB5L2NvbW1vbi9zeXN0ZW0vZXhlY3V0aXZlX3VuaXR0ZXN0LnB5CkBAIC0xLDQgKzEsNCBA QAotIyBDb3B5cmlnaHQgKEMpIDIwMDkgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4K KyMgQ29weXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAj IENvcHlyaWdodCAoQykgMjAwOSBEYW5pZWwgQmF0ZXMgKGRiYXRlc0BpbnR1ZGF0YS5jb20pLiBB bGwgcmlnaHRzIHJlc2VydmVkLgogIwogIyBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJj ZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKQEAgLTMxLDYgKzMxLDcgQEAgaW1w b3J0IHVuaXR0ZXN0CiAKIGZyb20gd2Via2l0cHkuY29tbW9uLnN5c3RlbS5leGVjdXRpdmUgaW1w b3J0IEV4ZWN1dGl2ZSwgcnVuX2NvbW1hbmQKIAorCiBjbGFzcyBFeGVjdXRpdmVUZXN0KHVuaXR0 ZXN0LlRlc3RDYXNlKToKIAogICAgIGRlZiB0ZXN0X3J1bl9jb21tYW5kX3dpdGhfYmFkX2NvbW1h bmQoc2VsZik6CkBAIC0zOCw1ICszOSwyNiBAQCBjbGFzcyBFeGVjdXRpdmVUZXN0KHVuaXR0ZXN0 LlRlc3RDYXNlKToKICAgICAgICAgICAgIHJ1bl9jb21tYW5kKFsiZm9vX2Jhcl9jb21tYW5kX2Js YWgiXSwgZXJyb3JfaGFuZGxlcj1FeGVjdXRpdmUuaWdub3JlX2Vycm9yLCByZXR1cm5fZXhpdF9j b2RlPVRydWUpCiAgICAgICAgIHNlbGYuZmFpbFVubGVzc1JhaXNlcyhPU0Vycm9yLCBydW5fYmFk X2NvbW1hbmQpCiAKLWlmIF9fbmFtZV9fID09ICdfX21haW5fXyc6Ci0gICAgdW5pdHRlc3QubWFp bigpCisgICAgZGVmIHRlc3RfcnVuX2NvbW1hbmRfd2l0aF91bmljb2RlKHNlbGYpOgorICAgICAg ICAiIiJWYWxpZGF0ZSB0aGF0IGl0IGlzIHNhZmUgdG8gcGFzcyB1bmljb2RlKCkgb2JqZWN0cwor ICAgICAgICB0byBFeGVjdXRpdmUucnVuKiBtZXRob2RzLCBhbmQgdGhleSB3aWxsIHJldHVybiB1 bmljb2RlKCkKKyAgICAgICAgb2JqZWN0cyBieSBkZWZhdWx0IHVubGVzcyBkZWNvZGVfb3V0cHV0 PUZhbHNlIiIiCisgICAgICAgIGV4ZWN1dGl2ZSA9IEV4ZWN1dGl2ZSgpCisgICAgICAgIHVuaWNv ZGVfdG9yID0gdSJXZWJLaXQgXHUyNjYxIFRvciBBcm5lIFZlc3RiXHUwMEY4ISIKKyAgICAgICAg dXRmOF90b3IgPSB1bmljb2RlX3Rvci5lbmNvZGUoInV0Zi04IikKKworICAgICAgICBvdXRwdXQg PSBleGVjdXRpdmUucnVuX2NvbW1hbmQoWyJjYXQiXSwgaW5wdXQ9dW5pY29kZV90b3IpCisgICAg ICAgIHNlbGYuYXNzZXJ0RXF1YWxzKG91dHB1dCwgdW5pY29kZV90b3IpCisKKyAgICAgICAgb3V0 cHV0ID0gZXhlY3V0aXZlLnJ1bl9jb21tYW5kKFsiZWNobyIsICItbiIsIHVuaWNvZGVfdG9yXSkK KyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbHMob3V0cHV0LCB1bmljb2RlX3RvcikKKworICAgICAg ICBvdXRwdXQgPSBleGVjdXRpdmUucnVuX2NvbW1hbmQoWyJlY2hvIiwgIi1uIiwgdW5pY29kZV90 b3JdLCBkZWNvZGVfb3V0cHV0PUZhbHNlKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFscyhvdXRw dXQsIHV0ZjhfdG9yKQorCisgICAgICAgICMgRklYTUU6IFdlIHNob3VsZCBvbmx5IGhhdmUgb25l IHJ1biogbWV0aG9kIHRvIHRlc3QKKyAgICAgICAgb3V0cHV0ID0gZXhlY3V0aXZlLnJ1bl9hbmRf dGhyb3dfaWZfZmFpbChbImVjaG8iLCAiLW4iLCB1bmljb2RlX3Rvcl0sIHF1aWV0PVRydWUpCisg ICAgICAgIHNlbGYuYXNzZXJ0RXF1YWxzKG91dHB1dCwgdW5pY29kZV90b3IpCisKKyAgICAgICAg b3V0cHV0ID0gZXhlY3V0aXZlLnJ1bl9hbmRfdGhyb3dfaWZfZmFpbChbImVjaG8iLCAiLW4iLCB1 bmljb2RlX3Rvcl0sIHF1aWV0PVRydWUsIGRlY29kZV9vdXRwdXQ9RmFsc2UpCisgICAgICAgIHNl bGYuYXNzZXJ0RXF1YWxzKG91dHB1dCwgdXRmOF90b3IpCmRpZmYgLS1naXQgYS9XZWJLaXRUb29s cy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9sYXlvdXRfcGFja2FnZS9kdW1wX3JlbmRl cl90cmVlX3RocmVhZC5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rl c3RzL2xheW91dF9wYWNrYWdlL2R1bXBfcmVuZGVyX3RyZWVfdGhyZWFkLnB5CmluZGV4IDkzYjRj NzkuLjY1NDhlZjEgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5 b3V0X3Rlc3RzL2xheW91dF9wYWNrYWdlL2R1bXBfcmVuZGVyX3RyZWVfdGhyZWFkLnB5CisrKyBi L1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9wYWNrYWdl L2R1bXBfcmVuZGVyX3RyZWVfdGhyZWFkLnB5CkBAIC0zNSw2ICszNSw3IEBAIHRoZSBvdXRwdXQu ICBXaGVuIHRoZXJlIGFyZSBubyBtb3JlIFVSTHMgdG8gcHJvY2VzcyBpbiB0aGUgc2hhcmVkIHF1 ZXVlLCB0aGUKIHRocmVhZCBleGl0cy4KICIiIgogCitpbXBvcnQgY29kZWNzCiBpbXBvcnQgY29w eQogaW1wb3J0IGxvZ2dpbmcKIGltcG9ydCBvcwpAQCAtMjg2LDcgKzI4Nyw3IEBAIGNsYXNzIFRl c3RTaGVsbFRocmVhZCh0aHJlYWRpbmcuVGhyZWFkKToKICAgICAgICAgIyBUaGlzIGlzIGNyZWF0 ZWQgaW4gcnVuX3dlYmtpdF90ZXN0cy5weTpfUHJlcGFyZUxpc3RzQW5kUHJpbnRPdXRwdXQuCiAg ICAgICAgIHRlc3RzX3J1bl9maWxlbmFtZSA9IG9zLnBhdGguam9pbihzZWxmLl9vcHRpb25zLnJl c3VsdHNfZGlyZWN0b3J5LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgInRlc3RzX3J1bi50eHQiKQotICAgICAgICB0ZXN0c19ydW5fZmlsZSA9IG9wZW4odGVzdHNf cnVuX2ZpbGVuYW1lLCAiYSIpCisgICAgICAgIHRlc3RzX3J1bl9maWxlID0gY29kZWNzLm9wZW4o dGVzdHNfcnVuX2ZpbGVuYW1lLCAiYSIsICJ1dGYtOCIpCiAKICAgICAgICAgd2hpbGUgVHJ1ZToK ICAgICAgICAgICAgIGlmIHNlbGYuX2NhbmNlbGVkOgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMv U2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvbGF5b3V0X3BhY2thZ2UvanNvbl9yZXN1bHRz X2dlbmVyYXRvci5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3Rz L2xheW91dF9wYWNrYWdlL2pzb25fcmVzdWx0c19nZW5lcmF0b3IucHkKaW5kZXggYTY4YWI0YS4u Yjk3NTIwZSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRf dGVzdHMvbGF5b3V0X3BhY2thZ2UvanNvbl9yZXN1bHRzX2dlbmVyYXRvci5weQorKysgYi9XZWJL aXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9sYXlvdXRfcGFja2FnZS9qc29u X3Jlc3VsdHNfZ2VuZXJhdG9yLnB5CkBAIC0yNyw2ICsyNyw3IEBACiAjIChJTkNMVURJTkcgTkVH TElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQog IyBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9G IFNVQ0ggREFNQUdFLgogCitpbXBvcnQgY29kZWNzCiBpbXBvcnQgbG9nZ2luZwogaW1wb3J0IG9z CiBpbXBvcnQgc3VicHJvY2VzcwpAQCAtMTE4LDcgKzExOSw3IEBAIGNsYXNzIEpTT05SZXN1bHRz R2VuZXJhdG9yKG9iamVjdCk6CiAgICAgICAgICIiIkdlbmVyYXRlcyB0aGUgSlNPTiBvdXRwdXQg ZmlsZS4iIiIKICAgICAgICAganNvbiA9IHNlbGYuX2dldF9qc29uKCkKICAgICAgICAgaWYganNv bjoKLSAgICAgICAgICAgIHJlc3VsdHNfZmlsZSA9IG9wZW4oc2VsZi5fcmVzdWx0c19maWxlX3Bh dGgsICJ3IikKKyAgICAgICAgICAgIHJlc3VsdHNfZmlsZSA9IGNvZGVjcy5vcGVuKHNlbGYuX3Jl c3VsdHNfZmlsZV9wYXRoLCAidyIsICJ1dGYtOCIpCiAgICAgICAgICAgICByZXN1bHRzX2ZpbGUu d3JpdGUoanNvbikKICAgICAgICAgICAgIHJlc3VsdHNfZmlsZS5jbG9zZSgpCiAKZGlmZiAtLWdp dCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9wYWNr YWdlL21ldGVyZWRfc3RyZWFtLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlv dXRfdGVzdHMvbGF5b3V0X3BhY2thZ2UvbWV0ZXJlZF9zdHJlYW0ucHkKaW5kZXggNzJiMzBhMS4u NWMyNTAzMyAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRf dGVzdHMvbGF5b3V0X3BhY2thZ2UvbWV0ZXJlZF9zdHJlYW0ucHkKKysrIGIvV2ViS2l0VG9vbHMv U2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvbGF5b3V0X3BhY2thZ2UvbWV0ZXJlZF9zdHJl YW0ucHkKQEAgLTU2LDYgKzU2LDggQEAgY2xhc3MgTWV0ZXJlZFN0cmVhbToKICAgICAgICAgc2Vs Zi5fc3RyZWFtID0gc3RyZWFtCiAgICAgICAgIHNlbGYuX2xhc3RfdXBkYXRlID0gIiIKIAorICAg ICMgRklYTUU6IERvZXMgdGhpcyB0YWtlIGEgc3RyaW5nICh1bmljb2RlKSBvciBhbiBhcnJheSBv ZiBieXRlcyAoc3RyKT8KKyAgICAjIElmIGl0IHRha2VzIGEgc3RyaW5nLCBpdCBuZWVkcyB0byBj YWxsIHR4dC5lbmNvZGUoInV0Zi04IikKICAgICBkZWYgd3JpdGUoc2VsZiwgdHh0KToKICAgICAg ICAgIiIiV3JpdGUgdGV4dCBkaXJlY3RseSB0byB0aGUgc3RyZWFtLCBvdmVyd3JpdGluZyBhbmQg cmVzZXR0aW5nIHRoZQogICAgICAgICBtZXRlci4iIiIKQEAgLTY4LDYgKzcwLDggQEAgY2xhc3Mg TWV0ZXJlZFN0cmVhbToKICAgICAgICAgIiIiRmx1c2ggYW55IGJ1ZmZlcmVkIG91dHB1dC4iIiIK ICAgICAgICAgc2VsZi5fc3RyZWFtLmZsdXNoKCkKIAorICAgICMgRklYTUU6IERvZXMgdGhpcyB0 YWtlIGEgc3RyaW5nICh1bmljb2RlKSBvciBhbiBhcnJheSBvZiBieXRlcyAoc3RyKT8KKyAgICAj IElmIGl0IHRha2VzIGEgc3RyaW5nLCBpdCBuZWVkcyB0byBjYWxsIHR4dC5lbmNvZGUoInV0Zi04 IikKICAgICBkZWYgdXBkYXRlKHNlbGYsIHN0cik6CiAgICAgICAgICIiIldyaXRlIGFuIHVwZGF0 ZSB0byB0aGUgc3RyZWFtIHRoYXQgd2lsbCBnZXQgb3ZlcndyaXR0ZW4gYnkgdGhlIG5leHQKICAg ICAgICAgdXBkYXRlKCkgb3IgYnkgYSB3cml0ZSgpLgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMv U2NyaXB0cy93ZWJraXRweS90b29sL2NvbW1hbmRzL3VwbG9hZC5weSBiL1dlYktpdFRvb2xzL1Nj cmlwdHMvd2Via2l0cHkvdG9vbC9jb21tYW5kcy91cGxvYWQucHkKaW5kZXggYmRmMDYwYS4uNzdi MWIwMSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL2NvbW1h bmRzL3VwbG9hZC5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29t bWFuZHMvdXBsb2FkLnB5CkBAIC0yNjIsNyArMjYyLDcgQEAgY2xhc3MgUG9zdENvbW1pdHMoQWJz dHJhY3REZWNsYXJhdGl2ZUNvbW1hbmQpOgogCiAgICAgZGVmIF9kaWZmX2ZpbGVfZm9yX2NvbW1p dChzZWxmLCB0b29sLCBjb21taXRfaWQpOgogICAgICAgICBkaWZmID0gdG9vbC5zY20oKS5jcmVh dGVfcGF0Y2hfZnJvbV9sb2NhbF9jb21taXQoY29tbWl0X2lkKQotICAgICAgICByZXR1cm4gU3Ry aW5nSU8uU3RyaW5nSU8oZGlmZikgIyBhZGRfcGF0Y2hfdG9fYnVnIGV4cGVjdHMgYSBmaWxlLWxp a2Ugb2JqZWN0CisgICAgICAgIHJldHVybiBTdHJpbmdJTy5TdHJpbmdJTyhkaWZmLmVuY29kZSgi dXRmLTgiKSkgIyBhZGRfcGF0Y2hfdG9fYnVnIGV4cGVjdHMgYSBmaWxlLWxpa2Ugb2JqZWN0CiAK ICAgICBkZWYgZXhlY3V0ZShzZWxmLCBvcHRpb25zLCBhcmdzLCB0b29sKToKICAgICAgICAgY29t bWl0X2lkcyA9IHRvb2wuc2NtKCkuY29tbWl0X2lkc19mcm9tX2NvbW1pdGlzaF9hcmd1bWVudHMo YXJncykKQEAgLTQwNCw3ICs0MDQsNyBAQCBjbGFzcyBDcmVhdGVCdWcoQWJzdHJhY3REZWNsYXJh dGl2ZUNvbW1hbmQpOgogICAgICAgICAgICAgY29tbWVudF90ZXh0ICs9IHRvb2wuc2NtKCkuZmls ZXNfY2hhbmdlZF9zdW1tYXJ5X2Zvcl9jb21taXQoY29tbWl0X2lkKQogCiAgICAgICAgIGRpZmYg PSB0b29sLnNjbSgpLmNyZWF0ZV9wYXRjaF9mcm9tX2xvY2FsX2NvbW1pdChjb21taXRfaWQpCi0g ICAgICAgIGRpZmZfZmlsZSA9IFN0cmluZ0lPLlN0cmluZ0lPKGRpZmYpICMgY3JlYXRlX2J1ZyBl eHBlY3RzIGEgZmlsZS1saWtlIG9iamVjdAorICAgICAgICBkaWZmX2ZpbGUgPSBTdHJpbmdJTy5T dHJpbmdJTyhkaWZmLmVuY29kZSgidXRmLTgiKSkgIyBjcmVhdGVfYnVnIGV4cGVjdHMgYSBmaWxl LWxpa2Ugb2JqZWN0CiAgICAgICAgIGJ1Z19pZCA9IHRvb2wuYnVncy5jcmVhdGVfYnVnKGJ1Z190 aXRsZSwgY29tbWVudF90ZXh0LCBvcHRpb25zLmNvbXBvbmVudCwgZGlmZl9maWxlLCAiUGF0Y2gi LCBjYz1vcHRpb25zLmNjLCBtYXJrX2Zvcl9yZXZpZXc9b3B0aW9ucy5yZXZpZXcsIG1hcmtfZm9y X2NvbW1pdF9xdWV1ZT1vcHRpb25zLnJlcXVlc3RfY29tbWl0KQogCiAgICAgICAgIGlmIGJ1Z19p ZCBhbmQgbGVuKGNvbW1pdF9pZHMpID4gMToKQEAgLTQyNCw3ICs0MjQsNyBAQCBjbGFzcyBDcmVh dGVCdWcoQWJzdHJhY3REZWNsYXJhdGl2ZUNvbW1hbmQpOgogICAgICAgICAgICAgY29tbWVudF90 ZXh0ID0gY29tbWl0X21lc3NhZ2UuYm9keShsc3RyaXA9VHJ1ZSkKIAogICAgICAgICBkaWZmID0g dG9vbC5zY20oKS5jcmVhdGVfcGF0Y2goKQotICAgICAgICBkaWZmX2ZpbGUgPSBTdHJpbmdJTy5T dHJpbmdJTyhkaWZmKSAjIGNyZWF0ZV9idWcgZXhwZWN0cyBhIGZpbGUtbGlrZSBvYmplY3QKKyAg ICAgICAgZGlmZl9maWxlID0gU3RyaW5nSU8uU3RyaW5nSU8oZGlmZi5lbmNvZGUoInV0Zi04Iikp ICMgY3JlYXRlX2J1ZyBleHBlY3RzIGEgZmlsZS1saWtlIG9iamVjdAogICAgICAgICBidWdfaWQg PSB0b29sLmJ1Z3MuY3JlYXRlX2J1ZyhidWdfdGl0bGUsIGNvbW1lbnRfdGV4dCwgb3B0aW9ucy5j b21wb25lbnQsIGRpZmZfZmlsZSwgIlBhdGNoIiwgY2M9b3B0aW9ucy5jYywgbWFya19mb3JfcmV2 aWV3PW9wdGlvbnMucmV2aWV3LCBtYXJrX2Zvcl9jb21taXRfcXVldWU9b3B0aW9ucy5yZXF1ZXN0 X2NvbW1pdCkKIAogICAgIGRlZiBwcm9tcHRfZm9yX2J1Z190aXRsZV9hbmRfY29tbWVudChzZWxm KToKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9zdGVwcy9w b3N0ZGlmZi5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9zdGVwcy9wb3N0 ZGlmZi5weQppbmRleCA2YTNkZWU0Li5mN2RkYjk4IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9T Y3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvcG9zdGRpZmYucHkKKysrIGIvV2ViS2l0VG9vbHMv U2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBzL3Bvc3RkaWZmLnB5CkBAIC00NCw3ICs0NCw3IEBA IGNsYXNzIFBvc3REaWZmKEFic3RyYWN0U3RlcCk6CiAKICAgICBkZWYgcnVuKHNlbGYsIHN0YXRl KToKICAgICAgICAgZGlmZiA9IHNlbGYuY2FjaGVkX2xvb2t1cChzdGF0ZSwgImRpZmYiKQotICAg ICAgICBkaWZmX2ZpbGUgPSBTdHJpbmdJTy5TdHJpbmdJTyhkaWZmKSAjIGFkZF9wYXRjaF90b19i dWcgZXhwZWN0cyBhIGZpbGUtbGlrZSBvYmplY3QKKyAgICAgICAgZGlmZl9maWxlID0gU3RyaW5n SU8uU3RyaW5nSU8oZGlmZi5lbmNvZGUoInV0Zi04IikpICMgYWRkX3BhdGNoX3RvX2J1ZyBleHBl Y3RzIGEgZmlsZS1saWtlIG9iamVjdAogICAgICAgICBkZXNjcmlwdGlvbiA9IHNlbGYuX29wdGlv bnMuZGVzY3JpcHRpb24gb3IgIlBhdGNoIgogICAgICAgICBjb21tZW50X3RleHQgPSBOb25lCiAg ICAgICAgIGNvZGVyZXZpZXdfaXNzdWUgPSBzdGF0ZS5nZXQoImNvZGVyZXZpZXdfaXNzdWUiKQpk aWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBzL3Bvc3Rk aWZmZm9yY29tbWl0LnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBz L3Bvc3RkaWZmZm9yY29tbWl0LnB5CmluZGV4IDAzYjllNzguLjQzOWZhMmUgMTAwNjQ0Ci0tLSBh L1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9zdGVwcy9wb3N0ZGlmZmZvcmNvbW1p dC5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvcG9zdGRp ZmZmb3Jjb21taXQucHkKQEAgLTMzLDkgKzMzLDEwIEBAIGZyb20gd2Via2l0cHkudG9vbC5zdGVw cy5hYnN0cmFjdHN0ZXAgaW1wb3J0IEFic3RyYWN0U3RlcAogCiBjbGFzcyBQb3N0RGlmZkZvckNv bW1pdChBYnN0cmFjdFN0ZXApOgogICAgIGRlZiBydW4oc2VsZiwgc3RhdGUpOgorICAgICAgICBk aWZmX2FzX3V0ZjggPSBzZWxmLmNhY2hlZF9sb29rdXAoc3RhdGUsICJkaWZmIikuZW5jb2RlKCJ1 dGYtOCIpCiAgICAgICAgIHNlbGYuX3Rvb2wuYnVncy5hZGRfcGF0Y2hfdG9fYnVnKAogICAgICAg ICAgICAgc3RhdGVbImJ1Z19pZCJdLAotICAgICAgICAgICAgU3RyaW5nSU8uU3RyaW5nSU8oc2Vs Zi5jYWNoZWRfbG9va3VwKHN0YXRlLCAiZGlmZiIpKSwKKyAgICAgICAgICAgIFN0cmluZ0lPLlN0 cmluZ0lPKGRpZmZfYXNfdXRmOCksCiAgICAgICAgICAgICAiUGF0Y2ggZm9yIGxhbmRpbmciLAog ICAgICAgICAgICAgbWFya19mb3JfcmV2aWV3PUZhbHNlLAogICAgICAgICAgICAgbWFya19mb3Jf bGFuZGluZz1UcnVlKQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS90 b29sL3N0ZXBzL3Bvc3RkaWZmZm9ycmV2ZXJ0LnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJr aXRweS90b29sL3N0ZXBzL3Bvc3RkaWZmZm9ycmV2ZXJ0LnB5CmluZGV4IDNiOWRhMDQuLmYzYWNl ZDggMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9zdGVwcy9w b3N0ZGlmZmZvcnJldmVydC5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rv b2wvc3RlcHMvcG9zdGRpZmZmb3JyZXZlcnQucHkKQEAgLTM0LDYgKzM0LDcgQEAgZnJvbSB3ZWJr aXRweS50b29sLnN0ZXBzLmFic3RyYWN0c3RlcCBpbXBvcnQgQWJzdHJhY3RTdGVwCiAKIGNsYXNz IFBvc3REaWZmRm9yUmV2ZXJ0KEFic3RyYWN0U3RlcCk6CiAgICAgZGVmIHJ1bihzZWxmLCBzdGF0 ZSk6CisgICAgICAgIGRpZmZfYXNfdXRmOCA9IHNlbGYuY2FjaGVkX2xvb2t1cChzdGF0ZSwgImRp ZmYiKS5lbmNvZGUoInV0Zi04IikKICAgICAgICAgY29tbWVudF90ZXh0ID0gIkFueSBjb21taXR0 ZXIgY2FuIGxhbmQgdGhpcyBwYXRjaCBhdXRvbWF0aWNhbGx5IGJ5IFwKIG1hcmtpbmcgaXQgY29t bWl0LXF1ZXVlKy4gIFRoZSBjb21taXQtcXVldWUgd2lsbCBidWlsZCBhbmQgdGVzdCBcCiB0aGUg cGF0Y2ggYmVmb3JlIGxhbmRpbmcgdG8gZW5zdXJlIHRoYXQgdGhlIHJvbGxvdXQgd2lsbCBiZSBc CkBAIC00NCw3ICs0NSw3IEBAIGZvbGxvd2luZyBjb21tYW5kOlxuXG5cCiB3aGVyZSBBVFRBQ0hN RU5UX0lEIGlzIHRoZSBJRCBvZiB0aGlzIGF0dGFjaG1lbnQuIgogICAgICAgICBzZWxmLl90b29s LmJ1Z3MuYWRkX3BhdGNoX3RvX2J1ZygKICAgICAgICAgICAgIHN0YXRlWyJidWdfaWQiXSwKLSAg ICAgICAgICAgIFN0cmluZ0lPLlN0cmluZ0lPKHNlbGYuY2FjaGVkX2xvb2t1cChzdGF0ZSwgImRp ZmYiKSksCisgICAgICAgICAgICBTdHJpbmdJTy5TdHJpbmdJTyhkaWZmX2FzX3V0ZjgpLAogICAg ICAgICAgICAgIiVzJXMiICUgKEF0dGFjaG1lbnQucm9sbG91dF9wcmVhbWJsZSwgc3RhdGVbInJl dmlzaW9uIl0pLAogICAgICAgICAgICAgY29tbWVudF90ZXh0PWNvbW1lbnRfdGV4dCwKICAgICAg ICAgICAgIG1hcmtfZm9yX3Jldmlldz1GYWxzZSwKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1Nj cmlwdHMvd2Via2l0cHkvdG9vbC9zdGVwcy9zdGVwc191bml0dGVzdC5weSBiL1dlYktpdFRvb2xz L1NjcmlwdHMvd2Via2l0cHkvdG9vbC9zdGVwcy9zdGVwc191bml0dGVzdC5weQppbmRleCA0MGJl ZTkwLi41YWJmYzZkIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rv b2wvc3RlcHMvc3RlcHNfdW5pdHRlc3QucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJr aXRweS90b29sL3N0ZXBzL3N0ZXBzX3VuaXR0ZXN0LnB5CkBAIC00OCw3ICs0OCw4IEBAIGNsYXNz IFN0ZXBzVGVzdCh1bml0dGVzdC5UZXN0Q2FzZSk6CiAgICAgZGVmIHRlc3RfdXBkYXRlX3N0ZXAo c2VsZik6CiAgICAgICAgIG9wdGlvbnMgPSBNb2NrKCkKICAgICAgICAgb3B0aW9ucy51cGRhdGUg PSBUcnVlCi0gICAgICAgIHNlbGYuX3J1bl9zdGVwKFVwZGF0ZSwgb3B0aW9ucykKKyAgICAgICAg ZXhwZWN0ZWRfc3RkZXJyID0gIlVwZGF0aW5nIHdvcmtpbmcgZGlyZWN0b3J5XG4iCisgICAgICAg IE91dHB1dENhcHR1cmUoKS5hc3NlcnRfb3V0cHV0cyhzZWxmLCBzZWxmLl9ydW5fc3RlcCwgW1Vw ZGF0ZSwgb3B0aW9uc10sIGV4cGVjdGVkX3N0ZGVycj1leHBlY3RlZF9zdGRlcnIpCiAKICAgICBk ZWYgdGVzdF9wcm9tcHRfZm9yX2J1Z19vcl90aXRsZV9zdGVwKHNlbGYpOgogICAgICAgICB0b29s ID0gTW9ja1Rvb2woKQo= 53626 2010-04-18 04:59:06 -0700 2010-04-20 14:32:36 -0700 Patch bug-37765-20100418045904.patch text/plain 55061 eric ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxv ZwppbmRleCA1OWMyNzc2Li41ZWFjMWZiIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9DaGFuZ2VM b2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsOTMgQEAKKzIwMTAtMDQt MTggIEVyaWMgU2VpZGVsICA8ZXJpY0B3ZWJraXQub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFJFR1JFU1NJT04oNTc1MzEpOiB0aGUgY29tbWl0 LXF1ZXVlIHN0aWxsIGhhdGVzIFRvciBBcm5lIFZlc3Riw7gKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM3NzY1CisKKyAgICAgICAgSSBmaXhlZCB0aGUg cXVldWUgdG8gbm90IGlnbm9yZSBUb3IgYXMgYSByZXZpd2VyIGluIHI1NzUzMSwKKyAgICAgICAg YnV0IGluc3RlYWQgaXQgdGhyb3dzIGFuIGV4Y2VwdGlvbiBldmVyeSB0aW1lIGhpcyBuYW1lIGlz IGluIGEgcGF0Y2guCisKKyAgICAgICAgVGhpcyBmaXhlcyBvdXIgRXhlY3V0aXZlLnJ1bl9jb21t YW5kIGNvZGUgdG8gd29yayBhcm91bmQgYSBQb3BlbgorICAgICAgICBidWcgaHR0cDovL2J1Z3Mu cHl0aG9uLm9yZy9pc3N1ZTUyOTAgd2hlcmVieSBweXRob24gdmVyc2lvbnMgYmVmb3JlIDIuNgor ICAgICAgICBkbyBub3QgY29ycmVjdGx5IGhhbmRsZSB1bmljb2RlIG9iamVjdHMgYXMgaW5wdXQg b3Igb3V0cHV0IHRvCisgICAgICAgIFBvcGVuLmNvbW11bmljYXRlLgorCisgICAgICAgIEZvbGxv d2luZyB0aGUgYWR2aWNlIG9mOgorICAgICAgICBodHRwOi8vZmFybWRldi5jb20vdGFsa3MvdW5p Y29kZS8KKyAgICAgICAgSSdtIGF0dGVtcHRpbmcgdG8gdGFrZSB0aGUgcHl0aG9uIHVuaWNvZGUg cGx1bmdlIGFuZCB1c2UgdW5pY29kZSgpCisgICAgICAgIG9iamVjdHMgYXMgc3RyaW5ncyBpbnN0 ZWFkIG9mIHN0cigpIG9iamVjdHMgZXZlcnl3aGVyZSBpbiB3ZWJraXRweS4KKworICAgICAgICBX ZSBkbyBub3QgaGF2ZSB0byB1c2UgdSIiIGluc3RlYWQgb2YgIiIgYmVjYXVzZSB1ImEiID09ICJh IiBhcyBleHBlY3RlZAorICAgICAgICBpbiBQeXRob24uICBQeXRob24gd2lsbCBnZW5lcmF0ZSBh IHdhcm5pbmcgdG8gdGhlIGNvbnNvbGUgaW4gY2FzZXMgd2hlcmUKKyAgICAgICAgYSB1bmljb2Rl KCkgPT0gc3RyKCkgb3BlcmF0aW9uIGNhbm5vdCBiZSBwZXJmb3JtZWQuCisKKyAgICAgICAgSSBh bHNvIGNsZWFuZWQgdXAgdGhlIGlucHV0IGhhbmRsaW5nIGluIHJ1bl9jb21tYW5kIGEgbGl0dGxl IGJ5IGFkZGluZworICAgICAgICBhIG5ldyBfY29tcHV0ZV9pbnB1dCgpIG1ldGhvZCB3aGljaCBj YW4gcmV0dXJuIGVhcmx5IGluc3RlYWQgb2YgaGF2aW5nCisgICAgICAgIHN1Y2ggYSBsb25nL2Ns dXR0ZXJlZCBpZi1ibG9jay4KKworICAgICAgICBFeGVjdXRpdmUucnVuKiBub3cgY29ycmVjdGx5 IGFjY2VwdCBhbmQgcmV0dXJuIHVuaWNvZGUoKSBvYmplY3RzLgorICAgICAgICBJIGF0dGVtcHRl ZCB0byBmaXggYWxsIHRoZSBwbGFjZXMgdGhhdCB3ZSBjYWxsIC53cml0ZSgpIHRvIG1ha2Ugc3Vy ZSB3ZQorICAgICAgICBlbmNvZGUgYW55IHVuaWNvZGUoKSBvYmplY3RzIGludG8gdXRmLTguCisK KyAgICAgICAgQWxsIHBsYWNlcyB3aGljaCB1c2UgU3RyaW5nSU8gbmVlZCB0byBiZSBzdXJlIHRv IHBhc3MgU3RyaW5nSU8gYQorICAgICAgICBwcmUtZW5jb2RlZCBieXRlLWFycmF5IChzdHIgb2Jq ZWN0KSBpbnN0ZWFkIG9mIHVuaWNvZGUgc28gdGhhdAorICAgICAgICBjbGllbnRzIHdoaWNoIHJl YWQgZnJvbSB0aGUgU3RyaW5nSU8gZG9uJ3QgaGF2ZSBlbmNvZGluZyBleGNlcHRpb25zLgorICAg ICAgICBUbyBtYWtlIHRoaXMgZWFzaWVyLCBJIHJlbW92ZWQgdGhlIHBhdGNoX2ZpbGVfb2JqZWN0 IHN1cHBvcnQgZnJvbQorICAgICAgICBhZGRfcGF0Y2hfdG9fYnVnLCBhbmQgY2hhbmdlZCB0aGUg NCBwbGFjZXMgd2hpY2ggcHJldmlvdXNseSB1c2VkCisgICAgICAgIFN0cmluZ0lPIHRvIGNyZWF0 ZSBhIGZha2UgcGF0Y2ggZmlsZS4KKworICAgICAgICBJIGF0dGVtcHRlZCB0byBkb2N1bWVudCBh bnkgcGxhY2VzIHdoZXJlIHdlIGFyZSBub3QgY29ycmVjdGx5IGNvbnZlcnRpbmcKKyAgICAgICAg dG8vZnJvbSBieXRlcyAoc3RyKCkgb2JqZWN0cykgdG8gc3RyaW5ncyAodW5pY29kZSgpIG9iamVj dHMpLgorCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvYXBpX3Vu aXR0ZXN0LnB5OgorICAgICAgICAgLSBSZWFkL3dyaXRlIHV0Zi04IGZpbGVzIGluc3RlYWQgb2Yg YXNjaWkuCisgICAgICAgICAtIFVwZGF0ZSB0aGUgdGVzdHMgdG8gdXNlIHRlc3QgZm9yIHByb3Bl ciB1bmljb2RlKCkgaGFuZGxpbmcuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9jb21tb24v Y2hlY2tvdXQvY2hhbmdlbG9nX3VuaXR0ZXN0LnB5OgorICAgICAgICAgLSBVc2UgdW5pY29kZSgp IHN0cmluZ3MgaW5zdGVhZCBvZiBzdHIoKSBieXRlIGFycmF5cy4KKyAgICAgICAgKiBTY3JpcHRz L3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9zY20ucHk6CisgICAgICAgICAtIFJlbW92ZSB1c2Ug b2Ygc3RyKCkuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2Nt X3VuaXR0ZXN0LnB5OgorICAgICAgICAgLSBSZWFkL3dyaXRlIHV0Zi04IGZpbGVzIGFuZCB1c2Ug dW5pY29kZSgpIHN0cmluZ3MgaW4gdGVzdGluZy4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5 L2NvbW1vbi9jb25maWcvY29tbWl0dGVycy5weToKKyAgICAgICAgIC0gVXNlIFx1IGluc3RlYWQg b2YgXHggdG8gbWFrZSBzbGlnaHRseSBjbGVhcmVyIHdoYXQgd2UncmUgZG9pbmcuCisgICAgICAg ICogU2NyaXB0cy93ZWJraXRweS9jb21tb24vbmV0L2J1Z3ppbGxhLnB5OgorICAgICAgICAgLSBB ZGQgYSBuZXcgX3N0cmluZ19jb250ZW50cygpIG1ldGhvZCBhbmQgZXhwbGFpbiB3aHkKKyAgICAg ICAgICAgd2UgaGF2ZSB0byBjYWxsIHVuaWNvZGUoKSBvbiB0aGUgcmVzdWx0IG9mIHNvdXAuc3Ry aW5nCisgICAgICAgICAgIGFuZCB3aHkgaXQncyBzYWZlIHRvIGRvIHNvIHcvbyBuZWVkaW5nIHRv IHBhc3MgYSBjb2RlYyBuYW1lLgorICAgICAgICAgLSBSZW1vdmUgdGhlICh1bnVzZWQpIHN1cHBv cnQgZm9yIHBhc3NpbmcgYSBmaWxlIG9iamVjdCB0byBhZGRfcGF0Y2hfdG9fYnVnKCkuCisgICAg ICAgICogU2NyaXB0cy93ZWJraXRweS9jb21tb24vbmV0L2J1aWxkYm90LnB5OgorICAgICAgICAg LSBVc2UgdW5pY29kZSgpIGluc3RlYWQgb2Ygc3RyKCkgd2hlbiBuZWVkaW5nIHRvIGNvYXggYQor ICAgICAgICAgICBOYXZpZ2FibGVTdHJpbmcgb2JqZWN0IGludG8gYSB1bmljb2RlKCkgb2JqZWN0 LgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvY29tbW9uL25ldC9zdGF0dXNzZXJ2ZXIucHk6 CisgICAgICAgICAtIFJlbW92ZSB1c2Ugb2Ygc3RyKCkKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtp dHB5L2NvbW1vbi9wcmV0dHlwYXRjaC5weToKKyAgICAgICAgIC0gV3JpdGUgb3V0IHRoZSBwYXRj aCBmaWxlIGFzIHV0Zi04LgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvY29tbW9uL3N5c3Rl bS9hdXRvaW5zdGFsbC5weToKKyAgICAgICAgIC0gQWRkIGEgRklYTUUgYWJvdXQgZW5jb2Rpbmcu CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9jb21tb24vc3lzdGVtL2RlcHJlY2F0ZWRfbG9n Z2luZy5weToKKyAgICAgICAgIC0gRG9jdW1lbnQgdGhhdCB0ZWUoKSB3b3JrcyBvbiBieXRlcywg bm90IHN0cmluZ3MuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9jb21tb24vc3lzdGVtL2V4 ZWN1dGl2ZS5weToKKyAgICAgICAgIC0gTWFrZSBydW4qIHByb3Blcmx5IHRha2UgYW5kIHJldHVy biB1bmljb2RlKCkgb2JqZWN0cy4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9z eXN0ZW0vZXhlY3V0aXZlX3VuaXR0ZXN0LnB5OgorICAgICAgICAgLSBBZGRlZCBhIHVuaXQgdGVz dCB0byBtYWtlIHN1cmUgd2UgZG9uJ3QgYnJlYWsgVG9yIGFnYWluIQorICAgICAgICAqIFNjcmlw dHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9wYWNrYWdlL2R1bXBfcmVuZGVyX3RyZWVf dGhyZWFkLnB5OgorICAgICAgICAgLSBXcml0ZSBvdXQgdGhlIHRlc3QgbGlzdCBhcyB1dGYtOC4K KyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9sYXlvdXRfcGFja2FnZS9q c29uX3Jlc3VsdHNfZ2VuZXJhdG9yLnB5OgorICAgICAgICAgLSBXcml0ZSBvdXQganNvbiBmaWxl cyBhcyB1dGYtOC4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9sYXlv dXRfcGFja2FnZS9tZXRlcmVkX3N0cmVhbS5weToKKyAgICAgICAgIC0gQWRkIEZJWE1FIGFib3V0 IGVuY29kaW5nIGhhbmRsaW5nLgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvdG9vbC9jb21t YW5kcy91cGxvYWQucHk6CisgICAgICAgICAtIFBhc3MgdGhlIGRpZmYgZGlyZWN0bHkgdG8gYWRk X3BhdGNoX3RvX2J1ZyBpbnN0ZWFkIG9mIGNyZWF0aW5nIGEgU3RyaW5nSU8gZmlsZSB3cmFwcGVy LgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvdG9vbC9tb2NrdG9vbC5weToKKyAgICAgICAg IC0gUmVuYW1lIGFkZF9wYXRjaF90b19idWcgYXJndW1lbnQgdG8gbWF0Y2ggYnVnemlsbGEucHkK KyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvcG9zdGRpZmYucHk6CisgICAg ICAgICAtIFBhc3MgdGhlIGRpZmYgZGlyZWN0bHkgdG8gYWRkX3BhdGNoX3RvX2J1ZyBpbnN0ZWFk IG9mIGNyZWF0aW5nIGEgU3RyaW5nSU8gZmlsZSB3cmFwcGVyLgorICAgICAgICAqIFNjcmlwdHMv d2Via2l0cHkvdG9vbC9zdGVwcy9wb3N0ZGlmZmZvcmNvbW1pdC5weTogZGl0dG8uCisgICAgICAg ICogU2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBzL3Bvc3RkaWZmZm9ycmV2ZXJ0LnB5OiBkaXR0 by4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvc3RlcHNfdW5pdHRlc3Qu cHk6CisgICAgICAgICAtIEZpeGVkIHNwdXJpb3VzIGxvZ2dpbmcgc2VlbiB3aGVuIHJ1bm5pbmcg dGVzdC13ZWJraXRweQorCiAyMDEwLTA0LTE3ICBBZGFtIEJhcnRoICA8YWJhcnRoQHdlYmtpdC5v cmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRXJpYyBTZWlkZWwuCmRpZmYgLS1naXQgYS9XZWJL aXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9hcGkucHkgYi9XZWJLaXRU b29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9hcGkucHkKaW5kZXggYzRlMmI2 OS4uZTZkZDNhMSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21t b24vY2hlY2tvdXQvYXBpLnB5CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29t bW9uL2NoZWNrb3V0L2FwaS5weQpAQCAtNTAsNyArNTAsOCBAQCBjbGFzcyBDaGVja291dChvYmpl Y3QpOgogCiAgICAgZGVmIF9sYXRlc3RfZW50cnlfZm9yX2NoYW5nZWxvZ19hdF9yZXZpc2lvbihz ZWxmLCBjaGFuZ2Vsb2dfcGF0aCwgcmV2aXNpb24pOgogICAgICAgICBjaGFuZ2Vsb2dfY29udGVu dHMgPSBzZWxmLl9zY20uY29udGVudHNfYXRfcmV2aXNpb24oY2hhbmdlbG9nX3BhdGgsIHJldmlz aW9uKQotICAgICAgICByZXR1cm4gQ2hhbmdlTG9nLnBhcnNlX2xhdGVzdF9lbnRyeV9mcm9tX2Zp bGUoU3RyaW5nSU8uU3RyaW5nSU8oY2hhbmdlbG9nX2NvbnRlbnRzKSkKKyAgICAgICAgZmFrZV9m aWxlID0gU3RyaW5nSU8uU3RyaW5nSU8oY2hhbmdlbG9nX2NvbnRlbnRzLmVuY29kZSgidXRmLTgi KSkKKyAgICAgICAgcmV0dXJuIENoYW5nZUxvZy5wYXJzZV9sYXRlc3RfZW50cnlfZnJvbV9maWxl KGZha2VfZmlsZSkKIAogICAgIGRlZiBjaGFuZ2Vsb2dfZW50cmllc19mb3JfcmV2aXNpb24oc2Vs ZiwgcmV2aXNpb24pOgogICAgICAgICBjaGFuZ2VkX2ZpbGVzID0gc2VsZi5fc2NtLmNoYW5nZWRf ZmlsZXNfZm9yX3JldmlzaW9uKHJldmlzaW9uKQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2Ny aXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvYXBpX3VuaXR0ZXN0LnB5IGIvV2ViS2l0VG9v bHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvYXBpX3VuaXR0ZXN0LnB5CmluZGV4 IGU5OWNhZWUuLjdmN2FkODMgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0 cHkvY29tbW9uL2NoZWNrb3V0L2FwaV91bml0dGVzdC5weQorKysgYi9XZWJLaXRUb29scy9TY3Jp cHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9hcGlfdW5pdHRlc3QucHkKQEAgLTI2LDYgKzI2 LDcgQEAKICMgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBB TlkgV0FZIE9VVCBPRiBUSEUgVVNFCiAjIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNF RCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCiAKK2ltcG9ydCBjb2RlY3MKIGlt cG9ydCBvcwogaW1wb3J0IHNodXRpbAogaW1wb3J0IHRlbXBmaWxlCkBAIC0zOSwxMiArNDAsMTIg QEAgZnJvbSB3ZWJraXRweS50aGlyZHBhcnR5Lm1vY2sgaW1wb3J0IE1vY2sKIAogIyBGSVhNRTog Q29waWVkIGZyb20gc2NtX3VuaXR0ZXN0LnB5CiBkZWYgd3JpdGVfaW50b19maWxlX2F0X3BhdGgo ZmlsZV9wYXRoLCBjb250ZW50cyk6Ci0gICAgbmV3X2ZpbGUgPSBvcGVuKGZpbGVfcGF0aCwgJ3cn KQorICAgIG5ld19maWxlID0gY29kZWNzLm9wZW4oZmlsZV9wYXRoLCAidyIsICJ1dGYtOCIpCiAg ICAgbmV3X2ZpbGUud3JpdGUoY29udGVudHMpCiAgICAgbmV3X2ZpbGUuY2xvc2UoKQogCiAKLV9j aGFuZ2Vsb2cxZW50cnkxID0gIiIiMjAxMC0wMy0yNSAgRXJpYyBTZWlkZWwgIDxlcmljQHdlYmtp dC5vcmc+CitfY2hhbmdlbG9nMWVudHJ5MSA9IHUiIiIyMDEwLTAzLTI1ICBUb3IgQXJuZSBWZXN0 Ylx1MDBmOCAgPHZlc3Rib0B3ZWJraXQub3JnPgogCiAgICAgICAgIFVucmV2aWV3ZWQgYnVpbGQg Zml4IHRvIHVuLWJyZWFrIHdlYmtpdC1wYXRjaCBsYW5kLgogCkBAIC01Myw3ICs1NCw3IEBAIF9j aGFuZ2Vsb2cxZW50cnkxID0gIiIiMjAxMC0wMy0yNSAgRXJpYyBTZWlkZWwgIDxlcmljQHdlYmtp dC5vcmc+CiAKICAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9hcGku cHk6IGltcG9ydCBzY20uQ29tbWl0TWVzc2FnZQogIiIiCi1fY2hhbmdlbG9nMWVudHJ5MiA9ICIi IjIwMTAtMDMtMjUgIEFkYW0gQmFydGggIDxhYmFydGhAd2Via2l0Lm9yZz4KK19jaGFuZ2Vsb2cx ZW50cnkyID0gdSIiIjIwMTAtMDMtMjUgIEFkYW0gQmFydGggIDxhYmFydGhAd2Via2l0Lm9yZz4K IAogICAgICAgICBSZXZpZXdlZCBieSBFcmljIFNlaWRlbC4KIApAQCAtNjIsOCArNjMsOCBAQCBf Y2hhbmdlbG9nMWVudHJ5MiA9ICIiIjIwMTAtMDMtMjUgIEFkYW0gQmFydGggIDxhYmFydGhAd2Vi a2l0Lm9yZz4KIAogICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L2Fw aS5weToKICIiIgotX2NoYW5nZWxvZzEgPSAiXG4iLmpvaW4oW19jaGFuZ2Vsb2cxZW50cnkxLCBf Y2hhbmdlbG9nMWVudHJ5Ml0pCi1fY2hhbmdlbG9nMiA9ICIiIjIwMTAtMDMtMjUgIEVyaWMgU2Vp ZGVsICA8ZXJpY0B3ZWJraXQub3JnPgorX2NoYW5nZWxvZzEgPSB1IlxuIi5qb2luKFtfY2hhbmdl bG9nMWVudHJ5MSwgX2NoYW5nZWxvZzFlbnRyeTJdKQorX2NoYW5nZWxvZzIgPSB1IiIiMjAxMC0w My0yNSAgVG9yIEFybmUgVmVzdGJcdTAwZjggIDx2ZXN0Ym9Ad2Via2l0Lm9yZz4KIAogICAgICAg ICBVbnJldmlld2VkIGJ1aWxkIGZpeCB0byB1bi1icmVhayB3ZWJraXQtcGF0Y2ggbGFuZC4KIApA QCAtNzksNyArODAsNyBAQCBfY2hhbmdlbG9nMiA9ICIiIjIwMTAtMDMtMjUgIEVyaWMgU2VpZGVs ICA8ZXJpY0B3ZWJraXQub3JnPgogIiIiCiAKIGNsYXNzIENvbW1pdE1lc3NhZ2VGb3JUaGlzQ29t bWl0VGVzdCh1bml0dGVzdC5UZXN0Q2FzZSk6Ci0gICAgZXhwZWN0ZWRfY29tbWl0X21lc3NhZ2Ug PSAiIiIyMDEwLTAzLTI1ICBFcmljIFNlaWRlbCAgPGVyaWNAd2Via2l0Lm9yZz4KKyAgICBleHBl Y3RlZF9jb21taXRfbWVzc2FnZSA9IHUiIiIyMDEwLTAzLTI1ICBUb3IgQXJuZSBWZXN0Ylx1MDBm OCAgPHZlc3Rib0B3ZWJraXQub3JnPgogCiAgICAgICAgIFVucmV2aWV3ZWQgYnVpbGQgZml4IHRv IHVuLWJyZWFrIHdlYmtpdC1wYXRjaCBsYW5kLgogCkBAIC04Nyw3ICs4OCw3IEBAIGNsYXNzIENv bW1pdE1lc3NhZ2VGb3JUaGlzQ29tbWl0VGVzdCh1bml0dGVzdC5UZXN0Q2FzZSk6CiAgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zNjYyOQogCiAgICAgICAg ICogU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvYXBpLnB5OiBpbXBvcnQgc2NtLkNv bW1pdE1lc3NhZ2UKLTIwMTAtMDMtMjUgIEVyaWMgU2VpZGVsICA8ZXJpY0B3ZWJraXQub3JnPgor MjAxMC0wMy0yNSAgVG9yIEFybmUgVmVzdGJcdTAwZjggIDx2ZXN0Ym9Ad2Via2l0Lm9yZz4KIAog ICAgICAgICBVbnJldmlld2VkIGJ1aWxkIGZpeCB0byB1bi1icmVhayB3ZWJraXQtcGF0Y2ggbGFu ZC4KIApAQCAtMTM3LDggKzEzOCw4IEBAIGNsYXNzIENoZWNrb3V0VGVzdCh1bml0dGVzdC5UZXN0 Q2FzZSk6CiAgICAgICAgIGNoZWNrb3V0LmNoYW5nZWxvZ19lbnRyaWVzX2Zvcl9yZXZpc2lvbiA9 IGxhbWJkYSByZXZpc2lvbjogW0NoYW5nZUxvZ0VudHJ5KF9jaGFuZ2Vsb2cxZW50cnkxKV0KICAg ICAgICAgY29tbWl0aW5mbyA9IGNoZWNrb3V0LmNvbW1pdF9pbmZvX2Zvcl9yZXZpc2lvbig0KQog ICAgICAgICBzZWxmLmFzc2VydEVxdWFsKGNvbW1pdGluZm8uYnVnX2lkKCksIDM2NjI5KQotICAg ICAgICBzZWxmLmFzc2VydEVxdWFsKGNvbW1pdGluZm8uYXV0aG9yX25hbWUoKSwgIkVyaWMgU2Vp ZGVsIikKLSAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChjb21taXRpbmZvLmF1dGhvcl9lbWFpbCgp LCAiZXJpY0B3ZWJraXQub3JnIikKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChjb21taXRpbmZv LmF1dGhvcl9uYW1lKCksIHUiVG9yIEFybmUgVmVzdGJcdTAwZjgiKQorICAgICAgICBzZWxmLmFz c2VydEVxdWFsKGNvbW1pdGluZm8uYXV0aG9yX2VtYWlsKCksICJ2ZXN0Ym9Ad2Via2l0Lm9yZyIp CiAgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoY29tbWl0aW5mby5yZXZpZXdlcl90ZXh0KCksIE5v bmUpCiAgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoY29tbWl0aW5mby5yZXZpZXdlcigpLCBOb25l KQogICAgICAgICBzZWxmLmFzc2VydEVxdWFsKGNvbW1pdGluZm8uY29tbWl0dGVyX2VtYWlsKCks ICJjb21taXR0ZXJAZXhhbXBsZS5jb20iKQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0 cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvY2hhbmdlbG9nLnB5IGIvV2ViS2l0VG9vbHMvU2Ny aXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvY2hhbmdlbG9nLnB5CmluZGV4IGU5Mzg5NmYu Ljg2MmRjNDggMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9u L2NoZWNrb3V0L2NoYW5nZWxvZy5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5 L2NvbW1vbi9jaGVja291dC9jaGFuZ2Vsb2cucHkKQEAgLTEwMiwxMiArMTAyLDEzIEBAIGNsYXNz IENoYW5nZUxvZyhvYmplY3QpOgogICAgICAgICBkYXRlX2xpbmVfcmVnZXhwID0gcmUuY29tcGls ZShDaGFuZ2VMb2dFbnRyeS5kYXRlX2xpbmVfcmVnZXhwKQogICAgICAgICBlbnRyeV9saW5lcyA9 IFtdCiAgICAgICAgICMgVGhlIGZpcnN0IGxpbmUgc2hvdWxkIGJlIGEgZGF0ZSBsaW5lLgotICAg ICAgICBmaXJzdF9saW5lID0gY2hhbmdlbG9nX2ZpbGUucmVhZGxpbmUoKQorICAgICAgICBmaXJz dF9saW5lID0gdW5pY29kZShjaGFuZ2Vsb2dfZmlsZS5yZWFkbGluZSgpLCAidXRmLTgiKQogICAg ICAgICBpZiBub3QgZGF0ZV9saW5lX3JlZ2V4cC5tYXRjaChmaXJzdF9saW5lKToKICAgICAgICAg ICAgIHJldHVybiBOb25lCiAgICAgICAgIGVudHJ5X2xpbmVzLmFwcGVuZChmaXJzdF9saW5lKQog CiAgICAgICAgIGZvciBsaW5lIGluIGNoYW5nZWxvZ19maWxlOgorICAgICAgICAgICAgbGluZSA9 IHVuaWNvZGUobGluZSwgInV0Zi04IikKICAgICAgICAgICAgICMgSWYgd2UndmUgaGl0IHRoZSBu ZXh0IGVudHJ5LCByZXR1cm4uCiAgICAgICAgICAgICBpZiBkYXRlX2xpbmVfcmVnZXhwLm1hdGNo KGxpbmUpOgogICAgICAgICAgICAgICAgICMgUmVtb3ZlIHRoZSBleHRyYSBuZXdsaW5lIGF0IHRo ZSBlbmQKQEAgLTExNyw3ICsxMTgsOSBAQCBjbGFzcyBDaGFuZ2VMb2cob2JqZWN0KToKIAogICAg IGRlZiBsYXRlc3RfZW50cnkoc2VsZik6CiAgICAgICAgICMgQ2hhbmdlTG9nIGZpbGVzIGFyZSBh bHdheXMgVVRGLTgsIHdlIHJlYWQgdGhlbSBpbiBhcyBzdWNoIHRvIHN1cHBvcnQgUmV2aWV3ZXJz IHdpdGggdW5pY29kZSBpbiB0aGVpciBuYW1lcy4KLSAgICAgICAgY2hhbmdlbG9nX2ZpbGUgPSBj b2RlY3Mub3BlbihzZWxmLnBhdGgsICJyIiwgInV0Zi04IikKKyAgICAgICAgIyBXZSBkb24ndCB1 c2UgY29kZWNzLm9wZW4gaGVyZSB0byBtYWtlIHRoZSBhcGkgZm9yIHBhcnNlX2xhdGVzdF9lbnRy eV9mcm9tX2ZpbGUgY2xlYXJlci4KKyAgICAgICAgIyBJZiB3ZSBkaWQsIHRoZW4gaXQgd291bGQg YmUgdW5jbGVhciBhcyB0byB3aG9zIHJlcG9uc2liaWxpdHkgZGVjb2Rpbmcgb2YgdGhlIGZpbGUg c2hvdWxkIGJlLgorICAgICAgICBjaGFuZ2Vsb2dfZmlsZSA9IG9wZW4oc2VsZi5wYXRoLCAiciIp CiAgICAgICAgIHRyeToKICAgICAgICAgICAgIHJldHVybiBzZWxmLnBhcnNlX2xhdGVzdF9lbnRy eV9mcm9tX2ZpbGUoY2hhbmdlbG9nX2ZpbGUpCiAgICAgICAgIGZpbmFsbHk6CmRpZmYgLS1naXQg YS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9jaGFuZ2Vsb2df dW5pdHRlc3QucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291 dC9jaGFuZ2Vsb2dfdW5pdHRlc3QucHkKaW5kZXggOTIxMGM5Yy4uOWU3YWIyYyAxMDA2NDQKLS0t IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvY2hhbmdlbG9n X3VuaXR0ZXN0LnB5CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2No ZWNrb3V0L2NoYW5nZWxvZ191bml0dGVzdC5weQpAQCAtODcsOCArODcsOCBAQCBjbGFzcyBDaGFu Z2VMb2dzVGVzdCh1bml0dGVzdC5UZXN0Q2FzZSk6CiAnJycKIAogICAgIGRlZiB0ZXN0X2xhdGVz dF9lbnRyeV9wYXJzZShzZWxmKToKLSAgICAgICAgY2hhbmdlbG9nX2NvbnRlbnRzID0gIiVzXG4l cyIgJSAoc2VsZi5fZXhhbXBsZV9lbnRyeSwgc2VsZi5fZXhhbXBsZV9jaGFuZ2Vsb2cpCi0gICAg ICAgIGNoYW5nZWxvZ19maWxlID0gU3RyaW5nSU8oY2hhbmdlbG9nX2NvbnRlbnRzKQorICAgICAg ICBjaGFuZ2Vsb2dfY29udGVudHMgPSB1IiVzXG4lcyIgJSAoc2VsZi5fZXhhbXBsZV9lbnRyeSwg c2VsZi5fZXhhbXBsZV9jaGFuZ2Vsb2cpCisgICAgICAgIGNoYW5nZWxvZ19maWxlID0gU3RyaW5n SU8oY2hhbmdlbG9nX2NvbnRlbnRzLmVuY29kZSgidXRmLTgiKSkKICAgICAgICAgbGF0ZXN0X2Vu dHJ5ID0gQ2hhbmdlTG9nLnBhcnNlX2xhdGVzdF9lbnRyeV9mcm9tX2ZpbGUoY2hhbmdlbG9nX2Zp bGUpCiAgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWxzKGxhdGVzdF9lbnRyeS5jb250ZW50cygpLCBz ZWxmLl9leGFtcGxlX2VudHJ5KQogICAgICAgICBzZWxmLmFzc2VydEVxdWFscyhsYXRlc3RfZW50 cnkuYXV0aG9yX25hbWUoKSwgIlBldGVyIEthc3RpbmciKQpAQCAtMTIxLDcgKzEyMSw3IEBAIGNs YXNzIENoYW5nZUxvZ3NUZXN0KHVuaXR0ZXN0LlRlc3RDYXNlKToKICcnJwogCiAgICAgZGVmIHRl c3Rfc2V0X3Jldmlld2VyKHNlbGYpOgotICAgICAgICBjaGFuZ2Vsb2dfY29udGVudHMgPSAiJXNc biVzIiAlIChzZWxmLl9uZXdfZW50cnlfYm9pbGVycGxhdGUsIHNlbGYuX2V4YW1wbGVfY2hhbmdl bG9nKQorICAgICAgICBjaGFuZ2Vsb2dfY29udGVudHMgPSB1IiVzXG4lcyIgJSAoc2VsZi5fbmV3 X2VudHJ5X2JvaWxlcnBsYXRlLCBzZWxmLl9leGFtcGxlX2NoYW5nZWxvZykKICAgICAgICAgY2hh bmdlbG9nX3BhdGggPSBzZWxmLl93cml0ZV90bXBfZmlsZV93aXRoX2NvbnRlbnRzKGNoYW5nZWxv Z19jb250ZW50cykKICAgICAgICAgcmV2aWV3ZXJfbmFtZSA9ICdUZXN0IFJldmlld2VyJwogICAg ICAgICBDaGFuZ2VMb2coY2hhbmdlbG9nX3BhdGgpLnNldF9yZXZpZXdlcihyZXZpZXdlcl9uYW1l KQpAQCAtMTY5LDcgKzE2OSw3IEBAIGNsYXNzIENoYW5nZUxvZ3NUZXN0KHVuaXR0ZXN0LlRlc3RD YXNlKToKICcnJwogCiAgICAgZGVmIF9hc3NlcnRfdXBkYXRlX2Zvcl9yZXZlcnRfb3V0cHV0KHNl bGYsIGFyZ3MsIGV4cGVjdGVkX2VudHJ5KToKLSAgICAgICAgY2hhbmdlbG9nX2NvbnRlbnRzID0g IiVzXG4lcyIgJSAoc2VsZi5fbmV3X2VudHJ5X2JvaWxlcnBsYXRlLCBzZWxmLl9leGFtcGxlX2No YW5nZWxvZykKKyAgICAgICAgY2hhbmdlbG9nX2NvbnRlbnRzID0gdSIlc1xuJXMiICUgKHNlbGYu X25ld19lbnRyeV9ib2lsZXJwbGF0ZSwgc2VsZi5fZXhhbXBsZV9jaGFuZ2Vsb2cpCiAgICAgICAg IGNoYW5nZWxvZ19wYXRoID0gc2VsZi5fd3JpdGVfdG1wX2ZpbGVfd2l0aF9jb250ZW50cyhjaGFu Z2Vsb2dfY29udGVudHMpCiAgICAgICAgIGNoYW5nZWxvZyA9IENoYW5nZUxvZyhjaGFuZ2Vsb2df cGF0aCkKICAgICAgICAgY2hhbmdlbG9nLnVwZGF0ZV9mb3JfcmV2ZXJ0KCphcmdzKQpkaWZmIC0t Z2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvY29tbWl0 aW5mby5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L2Nv bW1pdGluZm8ucHkKaW5kZXggN2MzMzE1Zi4uNDQ4ZDUzMCAxMDA2NDQKLS0tIGEvV2ViS2l0VG9v bHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvY29tbWl0aW5mby5weQorKysgYi9X ZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9jb21taXRpbmZvLnB5 CkBAIC0yOCw4ICsyOCw2IEBACiAjCiAjIFdlYktpdCdzIHB5dGhvbiBtb2R1bGUgZm9yIGhvbGRp bmcgaW5mb3JtYXRpb24gb24gYSBjb21taXQKIAotaW1wb3J0IFN0cmluZ0lPCi0KIGZyb20gd2Vi a2l0cHkuY29tbW9uLmNoZWNrb3V0LmNoYW5nZWxvZyBpbXBvcnQgdmlld19zb3VyY2VfdXJsCiBm cm9tIHdlYmtpdHB5LmNvbW1vbi5jb25maWcuY29tbWl0dGVycyBpbXBvcnQgQ29tbWl0dGVyTGlz dAogCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVj a291dC9zY20ucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291 dC9zY20ucHkKaW5kZXggMjcwNGYwNy4uYzRmNDhjZSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMv U2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtLnB5CisrKyBiL1dlYktpdFRvb2xz L1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3NjbS5weQpAQCAtMTQ1LDcgKzE0NSw3 IEBAIGNsYXNzIFNDTToKICAgICAgICAgcmV0dXJuIGZpbGVuYW1lcwogCiAgICAgZGVmIHN0cmlw X3JfZnJvbV9zdm5fcmV2aXNpb24oc2VsZiwgc3ZuX3JldmlzaW9uKToKLSAgICAgICAgbWF0Y2gg PSByZS5tYXRjaCgiXnIoP1A8c3ZuX3JldmlzaW9uPlxkKykiLCBzdm5fcmV2aXNpb24pCisgICAg ICAgIG1hdGNoID0gcmUubWF0Y2goIl5yKD9QPHN2bl9yZXZpc2lvbj5cZCspIiwgdW5pY29kZShz dm5fcmV2aXNpb24pKQogICAgICAgICBpZiAobWF0Y2gpOgogICAgICAgICAgICAgcmV0dXJuIG1h dGNoLmdyb3VwKCdzdm5fcmV2aXNpb24nKQogICAgICAgICByZXR1cm4gc3ZuX3JldmlzaW9uCkBA IC0zNDQsNyArMzQ0LDcgQEAgY2xhc3MgU1ZOKFNDTSk6CiAKICAgICBkZWYgY2hhbmdlZF9maWxl c19mb3JfcmV2aXNpb24oc2VsZiwgcmV2aXNpb24pOgogICAgICAgICAjIEFzIGZhciBhcyBJIGNh biB0ZWxsIHN2biBkaWZmIC0tc3VtbWFyaXplIG91dHB1dCBsb29rcyBqdXN0IGxpa2Ugc3ZuIHN0 YXR1cyBvdXRwdXQuCi0gICAgICAgIHN0YXR1c19jb21tYW5kID0gWyJzdm4iLCAiZGlmZiIsICIt LXN1bW1hcml6ZSIsICItYyIsIHN0cihyZXZpc2lvbildCisgICAgICAgIHN0YXR1c19jb21tYW5k ID0gWyJzdm4iLCAiZGlmZiIsICItLXN1bW1hcml6ZSIsICItYyIsIHJldmlzaW9uXQogICAgICAg ICByZXR1cm4gc2VsZi5ydW5fc3RhdHVzX2FuZF9leHRyYWN0X2ZpbGVuYW1lcyhzdGF0dXNfY29t bWFuZCwgc2VsZi5fc3RhdHVzX3JlZ2V4cCgiQUNETVIiKSkKIAogICAgIGRlZiBjb25mbGljdGVk X2ZpbGVzKHNlbGYpOgpAQCAtMzY0LDE1ICszNjQsMTUgQEAgY2xhc3MgU1ZOKFNDTSk6CiAgICAg ICAgIHJldHVybiBydW5fY29tbWFuZChzZWxmLnNjcmlwdF9wYXRoKCJzdm4tY3JlYXRlLXBhdGNo IiksIGN3ZD1zZWxmLmNoZWNrb3V0X3Jvb3QsIHJldHVybl9zdGRlcnI9RmFsc2UpCiAKICAgICBk ZWYgY29tbWl0dGVyX2VtYWlsX2Zvcl9yZXZpc2lvbihzZWxmLCByZXZpc2lvbik6Ci0gICAgICAg IHJldHVybiBydW5fY29tbWFuZChbInN2biIsICJwcm9wZ2V0IiwgInN2bjphdXRob3IiLCAiLS1y ZXZwcm9wIiwgIi1yIiwgc3RyKHJldmlzaW9uKV0pLnJzdHJpcCgpCisgICAgICAgIHJldHVybiBy dW5fY29tbWFuZChbInN2biIsICJwcm9wZ2V0IiwgInN2bjphdXRob3IiLCAiLS1yZXZwcm9wIiwg Ii1yIiwgcmV2aXNpb25dKS5yc3RyaXAoKQogCiAgICAgZGVmIGNvbnRlbnRzX2F0X3JldmlzaW9u KHNlbGYsIHBhdGgsIHJldmlzaW9uKToKICAgICAgICAgcmVtb3RlX3BhdGggPSAiJXMvJXMiICUg KHNlbGYuX3JlcG9zaXRvcnlfdXJsKCksIHBhdGgpCi0gICAgICAgIHJldHVybiBydW5fY29tbWFu ZChbInN2biIsICJjYXQiLCAiLXIiLCBzdHIocmV2aXNpb24pLCByZW1vdGVfcGF0aF0pCisgICAg ICAgIHJldHVybiBydW5fY29tbWFuZChbInN2biIsICJjYXQiLCAiLXIiLCByZXZpc2lvbiwgcmVt b3RlX3BhdGhdKQogCiAgICAgZGVmIGRpZmZfZm9yX3JldmlzaW9uKHNlbGYsIHJldmlzaW9uKToK ICAgICAgICAgIyBGSVhNRTogVGhpcyBzaG91bGQgcHJvYmFibHkgdXNlIGN3ZD1zZWxmLmNoZWNr b3V0X3Jvb3QKLSAgICAgICAgcmV0dXJuIHJ1bl9jb21tYW5kKFsnc3ZuJywgJ2RpZmYnLCAnLWMn LCBzdHIocmV2aXNpb24pXSkKKyAgICAgICAgcmV0dXJuIHJ1bl9jb21tYW5kKFsnc3ZuJywgJ2Rp ZmYnLCAnLWMnLCByZXZpc2lvbl0pCiAKICAgICBkZWYgX3JlcG9zaXRvcnlfdXJsKHNlbGYpOgog ICAgICAgICByZXR1cm4gc2VsZi52YWx1ZV9mcm9tX3N2bl9pbmZvKHNlbGYuY2hlY2tvdXRfcm9v dCwgJ1VSTCcpCkBAIC00MDUsNyArNDA1LDcgQEAgY2xhc3MgU1ZOKFNDTSk6CiAgICAgICAgIHJl dHVybiBydW5fY29tbWFuZChzdm5fY29tbWl0X2FyZ3MsIGVycm9yX2hhbmRsZXI9Y29tbWl0X2Vy cm9yX2hhbmRsZXIpCiAKICAgICBkZWYgc3ZuX2NvbW1pdF9sb2coc2VsZiwgc3ZuX3JldmlzaW9u KToKLSAgICAgICAgc3ZuX3JldmlzaW9uID0gc2VsZi5zdHJpcF9yX2Zyb21fc3ZuX3JldmlzaW9u KHN0cihzdm5fcmV2aXNpb24pKQorICAgICAgICBzdm5fcmV2aXNpb24gPSBzZWxmLnN0cmlwX3Jf ZnJvbV9zdm5fcmV2aXNpb24oc3ZuX3JldmlzaW9uKQogICAgICAgICByZXR1cm4gcnVuX2NvbW1h bmQoWydzdm4nLCAnbG9nJywgJy0tbm9uLWludGVyYWN0aXZlJywgJy0tcmV2aXNpb24nLCBzdm5f cmV2aXNpb25dKTsKIAogICAgIGRlZiBsYXN0X3N2bl9jb21taXRfbG9nKHNlbGYpOgpkaWZmIC0t Z2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtX3Vu aXR0ZXN0LnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQv c2NtX3VuaXR0ZXN0LnB5CmluZGV4IGMwYTY0ZDQuLjk3MjdmYjcgMTAwNjQ0Ci0tLSBhL1dlYktp dFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3NjbV91bml0dGVzdC5weQor KysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9zY21fdW5p dHRlc3QucHkKQEAgLTI4LDYgKzI4LDcgQEAKICMgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBB RFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KIAogaW1wb3J0IGJhc2U2 NAoraW1wb3J0IGNvZGVjcwogaW1wb3J0IGdldHBhc3MKIGltcG9ydCBvcwogaW1wb3J0IG9zLnBh dGgKQEAgLTU3LDEyICs1OCwxMiBAQCBkZWYgcnVuX3NpbGVudChhcmdzLCBjd2Q9Tm9uZSk6CiAg ICAgICAgIHJhaXNlIFNjcmlwdEVycm9yKCdGYWlsZWQgdG8gcnVuICIlcyIgIGV4aXRfY29kZTog JWQgIGN3ZDogJXMnICUgKGFyZ3MsIGV4aXRfY29kZSwgY3dkKSkKIAogZGVmIHdyaXRlX2ludG9f ZmlsZV9hdF9wYXRoKGZpbGVfcGF0aCwgY29udGVudHMpOgotICAgIGZpbGUgPSBvcGVuKGZpbGVf cGF0aCwgJ3cnKQorICAgIGZpbGUgPSBjb2RlY3Mub3BlbihmaWxlX3BhdGgsICJ3IiwgInV0Zi04 IikKICAgICBmaWxlLndyaXRlKGNvbnRlbnRzKQogICAgIGZpbGUuY2xvc2UoKQogCiBkZWYgcmVh ZF9mcm9tX3BhdGgoZmlsZV9wYXRoKToKLSAgICBmaWxlID0gb3BlbihmaWxlX3BhdGgsICdyJykK KyAgICBmaWxlID0gY29kZWNzLm9wZW4oZmlsZV9wYXRoLCAiciIsICJ1dGYtOCIpCiAgICAgY29u dGVudHMgPSBmaWxlLnJlYWQoKQogICAgIGZpbGUuY2xvc2UoKQogICAgIHJldHVybiBjb250ZW50 cwpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY29uZmln L2NvbW1pdHRlcnMucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jb25m aWcvY29tbWl0dGVycy5weQppbmRleCAxYmVjMjkwLi42NmE0YzFiIDEwMDY0NAotLS0gYS9XZWJL aXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jb25maWcvY29tbWl0dGVycy5weQorKysg Yi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jb25maWcvY29tbWl0dGVycy5w eQpAQCAtMjM3LDcgKzIzNyw3IEBAIHJldmlld2Vyc19saXN0ID0gWwogICAgIFJldmlld2VyKCJT dGV2ZSBGYWxrZW5idXJnIiwgInNmYWxrZW5AYXBwbGUuY29tIiwgInNmYWxrZW4iKSwKICAgICBS ZXZpZXdlcigiVGltIE9tZXJuaWNrIiwgInRpbW9AYXBwbGUuY29tIiksCiAgICAgUmV2aWV3ZXIo IlRpbW90aHkgSGF0Y2hlciIsIFsidGltb3RoeUBoYXRjaGVyLm5hbWUiLCAidGltb3RoeUBhcHBs ZS5jb20iXSwgInhlbm9uIiksCi0gICAgUmV2aWV3ZXIodSdUb3IgQXJuZSBWZXN0Ylx4ZjgnLCAi dmVzdGJvQHdlYmtpdC5vcmciLCAidG9yYXJuZSIpLAorICAgIFJldmlld2VyKHUiVG9yIEFybmUg VmVzdGJcdTAwZjgiLCAidmVzdGJvQHdlYmtpdC5vcmciLCAidG9yYXJuZSIpLAogICAgIFJldmll d2VyKCJWaWNraSBNdXJsZXkiLCAidmlja2lAYXBwbGUuY29tIiksCiAgICAgUmV2aWV3ZXIoIlhh biBMb3BleiIsIFsieGFuLmxvcGV6QGdtYWlsLmNvbSIsICJ4YW5AZ25vbWUub3JnIiwgInhhbkB3 ZWJraXQub3JnIl0sICJ4YW4iKSwKICAgICBSZXZpZXdlcigiWXVyeSBTZW1pa2hhdHNreSIsICJ5 dXJ5c0BjaHJvbWl1bS5vcmciLCAieXVyeXMiKSwKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1Nj cmlwdHMvd2Via2l0cHkvY29tbW9uL25ldC9idWd6aWxsYS5weSBiL1dlYktpdFRvb2xzL1Njcmlw dHMvd2Via2l0cHkvY29tbW9uL25ldC9idWd6aWxsYS5weQppbmRleCBiYjIyZDE0Li4yZGQ0ZDIw IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9uZXQvYnVn emlsbGEucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vbmV0L2J1 Z3ppbGxhLnB5CkBAIC0zMiw2ICszMiw3IEBACiAKIGltcG9ydCBvcy5wYXRoCiBpbXBvcnQgcmUK K2ltcG9ydCBTdHJpbmdJTwogaW1wb3J0IHN1YnByb2Nlc3MKIAogZnJvbSBkYXRldGltZSBpbXBv cnQgZGF0ZXRpbWUgIyB1c2VkIGluIHRpbWVzdGFtcCgpCkBAIC00MTEsNyArNDEyLDE2IEBAIGNs YXNzIEJ1Z3ppbGxhKG9iamVjdCk6CiAgICAgICAgICAgICBpZiBmbGFnWydzdGF0dXMnXSA9PSAn Kyc6CiAgICAgICAgICAgICAgICAgYXR0YWNobWVudFtyZXN1bHRfa2V5XSA9IGZsYWdbJ3NldHRl ciddCiAKKyAgICBkZWYgX3N0cmluZ19jb250ZW50cyhzZWxmLCBzb3VwKToKKyAgICAgICAgIyBX ZWJLaXQncyBidWd6aWxsYSBpbnN0YW5jZSB1c2VzIFVURi04LgorICAgICAgICAjIEJlYXV0aWZ1 bFNvdXAgYWx3YXlzIHJldHVybnMgVW5pY29kZSBzdHJpbmdzLCBob3dldmVyCisgICAgICAgICMg dGhlIC5zdHJpbmcgbWV0aG9kIHJldHVybnMgYSAodW5pY29kZSkgTmF2aWdhYmxlU3RyaW5nLgor ICAgICAgICAjIE5hdmlnYWJsZVN0cmluZyBjYW4gY29uZnVzZSBvdGhlciBwYXJ0cyBvZiB0aGUg Y29kZSwgc28gd2UKKyAgICAgICAgIyBjb252ZXJ0IGZyb20gTmF2aWdhYmxlU3RyaW5nIHRvIGEg cmVhbCB1bmljb2RlKCkgb2JqZWN0IHVzaW5nIHVuaWNvZGUoKS4KKyAgICAgICAgcmV0dXJuIHVu aWNvZGUoc291cC5zdHJpbmcpCisKICAgICBkZWYgX3BhcnNlX2F0dGFjaG1lbnRfZWxlbWVudChz ZWxmLCBlbGVtZW50LCBidWdfaWQpOgorCiAgICAgICAgIGF0dGFjaG1lbnQgPSB7fQogICAgICAg ICBhdHRhY2htZW50WydidWdfaWQnXSA9IGJ1Z19pZAogICAgICAgICBhdHRhY2htZW50Wydpc19v YnNvbGV0ZSddID0gKGVsZW1lbnQuaGFzX2tleSgnaXNvYnNvbGV0ZScpIGFuZCBlbGVtZW50Wydp c29ic29sZXRlJ10gPT0gIjEiKQpAQCAtNDE5LDkgKzQyOSw5IEBAIGNsYXNzIEJ1Z3ppbGxhKG9i amVjdCk6CiAgICAgICAgIGF0dGFjaG1lbnRbJ2lkJ10gPSBpbnQoZWxlbWVudC5maW5kKCdhdHRh Y2hpZCcpLnN0cmluZykKICAgICAgICAgIyBGSVhNRTogTm8gbmVlZCB0byBwYXJzZSBvdXQgdGhl IHVybCBoZXJlLgogICAgICAgICBhdHRhY2htZW50Wyd1cmwnXSA9IHNlbGYuYXR0YWNobWVudF91 cmxfZm9yX2lkKGF0dGFjaG1lbnRbJ2lkJ10pCi0gICAgICAgIGF0dGFjaG1lbnRbJ25hbWUnXSA9 IHVuaWNvZGUoZWxlbWVudC5maW5kKCdkZXNjJykuc3RyaW5nKQotICAgICAgICBhdHRhY2htZW50 WydhdHRhY2hlcl9lbWFpbCddID0gc3RyKGVsZW1lbnQuZmluZCgnYXR0YWNoZXInKS5zdHJpbmcp Ci0gICAgICAgIGF0dGFjaG1lbnRbJ3R5cGUnXSA9IHN0cihlbGVtZW50LmZpbmQoJ3R5cGUnKS5z dHJpbmcpCisgICAgICAgIGF0dGFjaG1lbnRbJ25hbWUnXSA9IHNlbGYuX3N0cmluZ19jb250ZW50 cyhlbGVtZW50LmZpbmQoJ2Rlc2MnKSkKKyAgICAgICAgYXR0YWNobWVudFsnYXR0YWNoZXJfZW1h aWwnXSA9IHNlbGYuX3N0cmluZ19jb250ZW50cyhlbGVtZW50LmZpbmQoJ2F0dGFjaGVyJykpCisg ICAgICAgIGF0dGFjaG1lbnRbJ3R5cGUnXSA9IHNlbGYuX3N0cmluZ19jb250ZW50cyhlbGVtZW50 LmZpbmQoJ3R5cGUnKSkKICAgICAgICAgc2VsZi5fcGFyc2VfYXR0YWNobWVudF9mbGFnKAogICAg ICAgICAgICAgICAgIGVsZW1lbnQsICdyZXZpZXcnLCBhdHRhY2htZW50LCAncmV2aWV3ZXJfZW1h aWwnKQogICAgICAgICBzZWxmLl9wYXJzZV9hdHRhY2htZW50X2ZsYWcoCkBAIC00MzIsMTAgKzQ0 MiwxMCBAQCBjbGFzcyBCdWd6aWxsYShvYmplY3QpOgogICAgICAgICBzb3VwID0gQmVhdXRpZnVs U291cChwYWdlKQogICAgICAgICBidWcgPSB7fQogICAgICAgICBidWdbImlkIl0gPSBpbnQoc291 cC5maW5kKCJidWdfaWQiKS5zdHJpbmcpCi0gICAgICAgIGJ1Z1sidGl0bGUiXSA9IHVuaWNvZGUo c291cC5maW5kKCJzaG9ydF9kZXNjIikuc3RyaW5nKQotICAgICAgICBidWdbInJlcG9ydGVyX2Vt YWlsIl0gPSBzdHIoc291cC5maW5kKCJyZXBvcnRlciIpLnN0cmluZykKLSAgICAgICAgYnVnWyJh c3NpZ25lZF90b19lbWFpbCJdID0gc3RyKHNvdXAuZmluZCgiYXNzaWduZWRfdG8iKS5zdHJpbmcp Ci0gICAgICAgIGJ1Z1siY2NfZW1haWxzIl0gPSBbc3RyKGVsZW1lbnQuc3RyaW5nKQorICAgICAg ICBidWdbInRpdGxlIl0gPSBzZWxmLl9zdHJpbmdfY29udGVudHMoc291cC5maW5kKCJzaG9ydF9k ZXNjIikpCisgICAgICAgIGJ1Z1sicmVwb3J0ZXJfZW1haWwiXSA9IHNlbGYuX3N0cmluZ19jb250 ZW50cyhzb3VwLmZpbmQoInJlcG9ydGVyIikpCisgICAgICAgIGJ1Z1siYXNzaWduZWRfdG9fZW1h aWwiXSA9IHNlbGYuX3N0cmluZ19jb250ZW50cyhzb3VwLmZpbmQoImFzc2lnbmVkX3RvIikpCisg ICAgICAgIGJ1Z1siY2NfZW1haWxzIl0gPSBbc2VsZi5fc3RyaW5nX2NvbnRlbnRzKGVsZW1lbnQp CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZm9yIGVsZW1lbnQgaW4gc291cC5maW5kQWxs KCdjYycpXQogICAgICAgICBidWdbImF0dGFjaG1lbnRzIl0gPSBbc2VsZi5fcGFyc2VfYXR0YWNo bWVudF9lbGVtZW50KGVsZW1lbnQsIGJ1Z1siaWQiXSkgZm9yIGVsZW1lbnQgaW4gc291cC5maW5k QWxsKCdhdHRhY2htZW50JyldCiAgICAgICAgIHJldHVybiBidWcKQEAgLTUzMiw3ICs1NDIsNyBA QCBjbGFzcyBCdWd6aWxsYShvYmplY3QpOgogCiAgICAgZGVmIF9maWxsX2F0dGFjaG1lbnRfZm9y bShzZWxmLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZGVzY3JpcHRpb24sCi0gICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBwYXRjaF9maWxlX29iamVjdCwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIGRpZmYsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBj b21tZW50X3RleHQ9Tm9uZSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1hcmtfZm9y X3Jldmlldz1GYWxzZSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1hcmtfZm9yX2Nv bW1pdF9xdWV1ZT1GYWxzZSwKQEAgLTU1Miw2ICs1NjIsOSBAQCBjbGFzcyBCdWd6aWxsYShvYmpl Y3QpOgogICAgICAgICAgICAgcGF0Y2hfbmFtZSA9ICJidWctJXMtJXMucGF0Y2giICUgKGJ1Z19p ZCwgdGltZXN0YW1wKCkpCiAgICAgICAgIGVsc2U6CiAgICAgICAgICAgICBwYXRjaF9uYW1lID0i JXMucGF0Y2giICUgdGltZXN0YW1wKCkKKworICAgICAgICAjIENsaWVudEZvcm0gZXhwZWN0cyBh IGZpbGUtbGlrZSBvYmplY3QKKyAgICAgICAgcGF0Y2hfZmlsZV9vYmplY3QgPSBTdHJpbmdJTy5T dHJpbmdJTyhkaWZmLmVuY29kZSgidXRmLTgiKSkKICAgICAgICAgc2VsZi5icm93c2VyLmFkZF9m aWxlKHBhdGNoX2ZpbGVfb2JqZWN0LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgInRl eHQvcGxhaW4iLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcGF0Y2hfbmFtZSwKQEAg LTU1OSw3ICs1NzIsNyBAQCBjbGFzcyBCdWd6aWxsYShvYmplY3QpOgogCiAgICAgZGVmIGFkZF9w YXRjaF90b19idWcoc2VsZiwKICAgICAgICAgICAgICAgICAgICAgICAgICBidWdfaWQsCi0gICAg ICAgICAgICAgICAgICAgICAgICAgcGF0Y2hfZmlsZV9vYmplY3QsCisgICAgICAgICAgICAgICAg ICAgICAgICAgZGlmZiwKICAgICAgICAgICAgICAgICAgICAgICAgICBkZXNjcmlwdGlvbiwKICAg ICAgICAgICAgICAgICAgICAgICAgICBjb21tZW50X3RleHQ9Tm9uZSwKICAgICAgICAgICAgICAg ICAgICAgICAgICBtYXJrX2Zvcl9yZXZpZXc9RmFsc2UsCkBAIC01NzgsOCArNTkxLDkgQEAgY2xh c3MgQnVnemlsbGEob2JqZWN0KToKICAgICAgICAgc2VsZi5icm93c2VyLm9wZW4oIiVzYXR0YWNo bWVudC5jZ2k/YWN0aW9uPWVudGVyJmJ1Z2lkPSVzIiAlICgKICAgICAgICAgICAgICAgICAgICAg ICAgICAgc2VsZi5idWdfc2VydmVyX3VybCwgYnVnX2lkKSkKICAgICAgICAgc2VsZi5icm93c2Vy LnNlbGVjdF9mb3JtKG5hbWU9ImVudHJ5Zm9ybSIpCisKICAgICAgICAgc2VsZi5fZmlsbF9hdHRh Y2htZW50X2Zvcm0oZGVzY3JpcHRpb24sCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHBhdGNoX2ZpbGVfb2JqZWN0LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBkaWZmLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBtYXJrX2Zvcl9yZXZp ZXc9bWFya19mb3JfcmV2aWV3LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBt YXJrX2Zvcl9jb21taXRfcXVldWU9bWFya19mb3JfY29tbWl0X3F1ZXVlLAogICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBtYXJrX2Zvcl9sYW5kaW5nPW1hcmtfZm9yX2xhbmRpbmcs CkBAIC02MTIsNyArNjI2LDcgQEAgY2xhc3MgQnVnemlsbGEob2JqZWN0KToKICAgICAgICAgICAg ICAgICAgICBidWdfdGl0bGUsCiAgICAgICAgICAgICAgICAgICAgYnVnX2Rlc2NyaXB0aW9uLAog ICAgICAgICAgICAgICAgICAgIGNvbXBvbmVudD1Ob25lLAotICAgICAgICAgICAgICAgICAgIHBh dGNoX2ZpbGVfb2JqZWN0PU5vbmUsCisgICAgICAgICAgICAgICAgICAgZGlmZj1Ob25lLAogICAg ICAgICAgICAgICAgICAgIHBhdGNoX2Rlc2NyaXB0aW9uPU5vbmUsCiAgICAgICAgICAgICAgICAg ICAgY2M9Tm9uZSwKICAgICAgICAgICAgICAgICAgICBibG9ja2VkPU5vbmUsCkBAIC02MzcsMTQg KzY1MSwxNCBAQCBjbGFzcyBCdWd6aWxsYShvYmplY3QpOgogICAgICAgICBpZiBjYzoKICAgICAg ICAgICAgIHNlbGYuYnJvd3NlclsiY2MiXSA9IGNjCiAgICAgICAgIGlmIGJsb2NrZWQ6Ci0gICAg ICAgICAgICBzZWxmLmJyb3dzZXJbImJsb2NrZWQiXSA9IHN0cihibG9ja2VkKQorICAgICAgICAg ICAgc2VsZi5icm93c2VyWyJibG9ja2VkIl0gPSB1bmljb2RlKGJsb2NrZWQpCiAgICAgICAgIHNl bGYuYnJvd3Nlclsic2hvcnRfZGVzYyJdID0gYnVnX3RpdGxlCiAgICAgICAgIHNlbGYuYnJvd3Nl clsiY29tbWVudCJdID0gYnVnX2Rlc2NyaXB0aW9uCiAKLSAgICAgICAgaWYgcGF0Y2hfZmlsZV9v YmplY3Q6CisgICAgICAgIGlmIGRpZmY6CiAgICAgICAgICAgICBzZWxmLl9maWxsX2F0dGFjaG1l bnRfZm9ybSgKICAgICAgICAgICAgICAgICAgICAgcGF0Y2hfZGVzY3JpcHRpb24sCi0gICAgICAg ICAgICAgICAgICAgIHBhdGNoX2ZpbGVfb2JqZWN0LAorICAgICAgICAgICAgICAgICAgICBkaWZm LAogICAgICAgICAgICAgICAgICAgICBtYXJrX2Zvcl9yZXZpZXc9bWFya19mb3JfcmV2aWV3LAog ICAgICAgICAgICAgICAgICAgICBtYXJrX2Zvcl9jb21taXRfcXVldWU9bWFya19mb3JfY29tbWl0 X3F1ZXVlKQogCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1v bi9uZXQvYnVpbGRib3QucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9u ZXQvYnVpbGRib3QucHkKaW5kZXggYmU4Nzg5Yi4uM2EzZjMyNCAxMDA2NDQKLS0tIGEvV2ViS2l0 VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vbmV0L2J1aWxkYm90LnB5CisrKyBiL1dlYktp dFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL25ldC9idWlsZGJvdC5weQpAQCAtNDQsNyAr NDQsNyBAQCBfbG9nID0gZ2V0X2xvZ2dlcihfX2ZpbGVfXykKIAogY2xhc3MgQnVpbGRlcihvYmpl Y3QpOgogICAgIGRlZiBfX2luaXRfXyhzZWxmLCBuYW1lLCBidWlsZGJvdCk6Ci0gICAgICAgIHNl bGYuX25hbWUgPSB1bmljb2RlKG5hbWUpCisgICAgICAgIHNlbGYuX25hbWUgPSBuYW1lCiAgICAg ICAgIHNlbGYuX2J1aWxkYm90ID0gYnVpbGRib3QKICAgICAgICAgc2VsZi5fYnVpbGRzX2NhY2hl ID0ge30KICAgICAgICAgc2VsZi5fcmV2aXNpb25fdG9fYnVpbGRfbnVtYmVyID0gTm9uZQpAQCAt MjIxLDEyICsyMjEsMTIgQEAgY2xhc3MgTGF5b3V0VGVzdFJlc3VsdHMob2JqZWN0KToKICAgICAg ICAgcGFyc2VkX3Jlc3VsdHMgPSB7fQogICAgICAgICB0YWJsZXMgPSBCZWF1dGlmdWxTb3VwKHBh Z2UpLmZpbmRBbGwoInRhYmxlIikKICAgICAgICAgZm9yIHRhYmxlIGluIHRhYmxlczoKLSAgICAg ICAgICAgIHRhYmxlX3RpdGxlID0gdGFibGUuZmluZFByZXZpb3VzU2libGluZygicCIpLnN0cmlu ZworICAgICAgICAgICAgdGFibGVfdGl0bGUgPSB1bmljb2RlKHRhYmxlLmZpbmRQcmV2aW91c1Np YmxpbmcoInAiKS5zdHJpbmcpCiAgICAgICAgICAgICBpZiB0YWJsZV90aXRsZSBub3QgaW4gY2xz LmV4cGVjdGVkX2tleXM6CiAgICAgICAgICAgICAgICAgIyBUaGlzIEV4Y2VwdGlvbiBzaG91bGQg b25seSBldmVyIGJlIGhpdCBpZiBydW4td2Via2l0LXRlc3RzIGNoYW5nZXMgaXRzIHJlc3VsdHMu aHRtbCBmb3JtYXQuCi0gICAgICAgICAgICAgICAgcmFpc2UgRXhjZXB0aW9uKCJVbmhhbmRsZWQg dGl0bGU6ICVzIiAlIHN0cih0YWJsZV90aXRsZSkpCisgICAgICAgICAgICAgICAgcmFpc2UgRXhj ZXB0aW9uKCJVbmhhbmRsZWQgdGl0bGU6ICVzIiAlIHRhYmxlX3RpdGxlKQogICAgICAgICAgICAg IyBXZSBtaWdodCB3YW50IHRvIHRyYW5zbGF0ZSB0YWJsZSB0aXRsZXMgaW50byBpZGVudGlmaWVy cyBiZWZvcmUgc3RvcmluZy4KLSAgICAgICAgICAgIHBhcnNlZF9yZXN1bHRzW3RhYmxlX3RpdGxl XSA9IFtyb3cuZmluZCgiYSIpLnN0cmluZyBmb3Igcm93IGluIHRhYmxlLmZpbmRBbGwoInRyIild CisgICAgICAgICAgICBwYXJzZWRfcmVzdWx0c1t0YWJsZV90aXRsZV0gPSBbdW5pY29kZShyb3cu ZmluZCgiYSIpLnN0cmluZykgZm9yIHJvdyBpbiB0YWJsZS5maW5kQWxsKCJ0ciIpXQogCiAgICAg ICAgIHJldHVybiBwYXJzZWRfcmVzdWx0cwogCkBAIC0zNTgsNyArMzU4LDcgQEAgY2xhc3MgQnVp bGRCb3Qob2JqZWN0KToKIAogICAgICAgICAjIEZpcnN0IGNlbGwgaXMgdGhlIG5hbWUKICAgICAg ICAgbmFtZV9saW5rID0gc3RhdHVzX2NlbGxzWzBdLmZpbmQoJ2EnKQotICAgICAgICBidWlsZGVy WyJuYW1lIl0gPSBuYW1lX2xpbmsuc3RyaW5nCisgICAgICAgIGJ1aWxkZXJbIm5hbWUiXSA9IHVu aWNvZGUobmFtZV9saW5rLnN0cmluZykKIAogICAgICAgICBzZWxmLl9wYXJzZV9sYXN0X2J1aWxk X2NlbGwoYnVpbGRlciwgc3RhdHVzX2NlbGxzWzFdKQogICAgICAgICBzZWxmLl9wYXJzZV9jdXJy ZW50X2J1aWxkX2NlbGwoYnVpbGRlciwgc3RhdHVzX2NlbGxzWzJdKQpAQCAtNDA3LDEzICs0MDcs MTMgQEAgY2xhc3MgQnVpbGRCb3Qob2JqZWN0KToKICAgICAgICAgcmV0dXJuIHVybGxpYjIudXJs b3BlbihidWlsZF9zdGF0dXNfdXJsKQogCiAgICAgZGVmIF9wYXJzZV90d2lzdGVkX2ZpbGVfcm93 KHNlbGYsIGZpbGVfcm93KToKLSAgICAgICAgc3RyaW5nX29yX2VtcHR5ID0gbGFtYmRhIHN0cmlu Zzogc3RyKHN0cmluZykgaWYgc3RyaW5nIGVsc2UgIiIKKyAgICAgICAgc3RyaW5nX29yX2VtcHR5 ID0gbGFtYmRhIHNvdXA6IHVuaWNvZGUoc291cC5zdHJpbmcpIGlmIHNvdXAuc3RyaW5nIGVsc2Ug dSIiCiAgICAgICAgIGZpbGVfY2VsbHMgPSBmaWxlX3Jvdy5maW5kQWxsKCd0ZCcpCiAgICAgICAg IHJldHVybiB7Ci0gICAgICAgICAgICAiZmlsZW5hbWUiIDogc3RyaW5nX29yX2VtcHR5KGZpbGVf Y2VsbHNbMF0uZmluZCgiYSIpLnN0cmluZyksCi0gICAgICAgICAgICAic2l6ZSIgOiBzdHJpbmdf b3JfZW1wdHkoZmlsZV9jZWxsc1sxXS5zdHJpbmcpLAotICAgICAgICAgICAgInR5cGUiIDogc3Ry aW5nX29yX2VtcHR5KGZpbGVfY2VsbHNbMl0uc3RyaW5nKSwKLSAgICAgICAgICAgICJlbmNvZGlu ZyIgOiBzdHJpbmdfb3JfZW1wdHkoZmlsZV9jZWxsc1szXS5zdHJpbmcpLAorICAgICAgICAgICAg ImZpbGVuYW1lIjogc3RyaW5nX29yX2VtcHR5KGZpbGVfY2VsbHNbMF0uZmluZCgiYSIpKSwKKyAg ICAgICAgICAgICJzaXplIjogc3RyaW5nX29yX2VtcHR5KGZpbGVfY2VsbHNbMV0pLAorICAgICAg ICAgICAgInR5cGUiOiBzdHJpbmdfb3JfZW1wdHkoZmlsZV9jZWxsc1syXSksCisgICAgICAgICAg ICAiZW5jb2RpbmciOiBzdHJpbmdfb3JfZW1wdHkoZmlsZV9jZWxsc1szXSksCiAgICAgICAgIH0K IAogICAgIGRlZiBfcGFyc2VfdHdpc3RlZF9kaXJlY3RvcnlfbGlzdGluZyhzZWxmLCBwYWdlKToK ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL25ldC9idWls ZGJvdF91bml0dGVzdC5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL25l dC9idWlsZGJvdF91bml0dGVzdC5weQppbmRleCBhZjkzYmViLi44NjI5NmIzIDEwMDY0NAotLS0g YS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9uZXQvYnVpbGRib3RfdW5pdHRl c3QucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vbmV0L2J1aWxk Ym90X3VuaXR0ZXN0LnB5CkBAIC01MSw3ICs1MSw3IEBAIGNsYXNzIEJ1aWxkZXJUZXN0KHVuaXR0 ZXN0LlRlc3RDYXNlKToKIAogICAgIGRlZiBzZXRVcChzZWxmKToKICAgICAgICAgc2VsZi5idWls ZGJvdCA9IEJ1aWxkQm90KCkKLSAgICAgICAgc2VsZi5idWlsZGVyID0gQnVpbGRlcigiVGVzdCBC dWlsZGVyIiwgc2VsZi5idWlsZGJvdCkKKyAgICAgICAgc2VsZi5idWlsZGVyID0gQnVpbGRlcih1 IlRlc3QgQnVpbGRlciBcdTI2NjEiLCBzZWxmLmJ1aWxkYm90KQogICAgICAgICBzZWxmLl9pbnN0 YWxsX2ZldGNoX2J1aWxkKGxhbWJkYSBidWlsZF9udW1iZXI6IFsidGVzdDEiLCAidGVzdDIiXSkK IAogICAgIGRlZiB0ZXN0X2ZpbmRfZmFpbHVyZV90cmFuc2l0aW9uKHNlbGYpOgpkaWZmIC0tZ2l0 IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vbmV0L3N0YXR1c3NlcnZlci5w eSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL25ldC9zdGF0dXNzZXJ2ZXIu cHkKaW5kZXggZTg5ODdhOS4uZDliNTJhMiAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0 cy93ZWJraXRweS9jb21tb24vbmV0L3N0YXR1c3NlcnZlci5weQorKysgYi9XZWJLaXRUb29scy9T Y3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9uZXQvc3RhdHVzc2VydmVyLnB5CkBAIC01Miw5ICs1Miw5 IEBAIGNsYXNzIFN0YXR1c1NlcnZlcjoKICAgICAgICAgaWYgbm90IHBhdGNoOgogICAgICAgICAg ICAgcmV0dXJuCiAgICAgICAgIGlmIHBhdGNoLmJ1Z19pZCgpOgotICAgICAgICAgICAgc2VsZi5i cm93c2VyWyJidWdfaWQiXSA9IHN0cihwYXRjaC5idWdfaWQoKSkKKyAgICAgICAgICAgIHNlbGYu YnJvd3NlclsiYnVnX2lkIl0gPSB1bmljb2RlKHBhdGNoLmJ1Z19pZCgpKQogICAgICAgICBpZiBw YXRjaC5pZCgpOgotICAgICAgICAgICAgc2VsZi5icm93c2VyWyJwYXRjaF9pZCJdID0gc3RyKHBh dGNoLmlkKCkpCisgICAgICAgICAgICBzZWxmLmJyb3dzZXJbInBhdGNoX2lkIl0gPSB1bmljb2Rl KHBhdGNoLmlkKCkpCiAKICAgICBkZWYgX2FkZF9yZXN1bHRzX2ZpbGUoc2VsZiwgcmVzdWx0c19m aWxlKToKICAgICAgICAgaWYgbm90IHJlc3VsdHNfZmlsZToKQEAgLTc5LDcgKzc5LDcgQEAgY2xh c3MgU3RhdHVzU2VydmVyOgogICAgICAgICB1cGRhdGVfc3ZuX3JldmlzaW9uX3VybCA9ICIlcy91 cGRhdGUtc3ZuLXJldmlzaW9uIiAlIHNlbGYudXJsCiAgICAgICAgIHNlbGYuYnJvd3Nlci5vcGVu KHVwZGF0ZV9zdm5fcmV2aXNpb25fdXJsKQogICAgICAgICBzZWxmLmJyb3dzZXIuc2VsZWN0X2Zv cm0obmFtZT0idXBkYXRlX3N2bl9yZXZpc2lvbiIpCi0gICAgICAgIHNlbGYuYnJvd3NlclsibnVt YmVyIl0gPSBzdHIoc3ZuX3JldmlzaW9uX251bWJlcikKKyAgICAgICAgc2VsZi5icm93c2VyWyJu dW1iZXIiXSA9IHVuaWNvZGUoc3ZuX3JldmlzaW9uX251bWJlcikKICAgICAgICAgc2VsZi5icm93 c2VyWyJicm9rZW5fYm90Il0gPSBicm9rZW5fYm90CiAgICAgICAgIHJldHVybiBzZWxmLmJyb3dz ZXIuc3VibWl0KCkucmVhZCgpCiAKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvY29tbW9uL3ByZXR0eXBhdGNoLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRw eS9jb21tb24vcHJldHR5cGF0Y2gucHkKaW5kZXggODE1N2Y5Yy4uZTdjODc2YSAxMDA2NDQKLS0t IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vcHJldHR5cGF0Y2gucHkKKysr IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vcHJldHR5cGF0Y2gucHkKQEAg LTM4LDcgKzM4LDcgQEAgY2xhc3MgUHJldHR5UGF0Y2gob2JqZWN0KToKICAgICBkZWYgcHJldHR5 X2RpZmZfZmlsZShzZWxmLCBkaWZmKToKICAgICAgICAgcHJldHR5X2RpZmYgPSBzZWxmLnByZXR0 eV9kaWZmKGRpZmYpCiAgICAgICAgIGRpZmZfZmlsZSA9IHRlbXBmaWxlLk5hbWVkVGVtcG9yYXJ5 RmlsZShzdWZmaXg9Ii5odG1sIikKLSAgICAgICAgZGlmZl9maWxlLndyaXRlKHByZXR0eV9kaWZm KQorICAgICAgICBkaWZmX2ZpbGUud3JpdGUocHJldHR5X2RpZmYuZW5jb2RlKCJ1dGYtOCIpKQog ICAgICAgICBkaWZmX2ZpbGUuZmx1c2goKQogICAgICAgICByZXR1cm4gZGlmZl9maWxlCiAKZGlm ZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL3N5c3RlbS9hdXRv aW5zdGFsbC5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL3N5c3RlbS9h dXRvaW5zdGFsbC5weQppbmRleCAzMmZkMmNmLi4zNTAwNmIxIDEwMDc1NQotLS0gYS9XZWJLaXRU b29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9zeXN0ZW0vYXV0b2luc3RhbGwucHkKKysrIGIv V2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vc3lzdGVtL2F1dG9pbnN0YWxsLnB5 CkBAIC0xMjQsNyArMTI0LDcgQEAgY2xhc3MgQXV0b0luc3RhbGxlcihvYmplY3QpOgogICAgICAg ICBfbG9nLmRlYnVnKCcgICAgIiVzIicgJSBwYXRoKQogICAgICAgICBmaWxlID0gb3BlbihwYXRo LCAidyIpCiAgICAgICAgIHRyeToKLSAgICAgICAgICAgIGZpbGUud3JpdGUodGV4dCkKKyAgICAg ICAgICAgIGZpbGUud3JpdGUodGV4dCkgICMgRklYTUU6IFdoYXQncyB0aGUgZW5jb2Rpbmcgb2Yg dGhpcyBmaWxlPwogICAgICAgICBmaW5hbGx5OgogICAgICAgICAgICAgZmlsZS5jbG9zZSgpCiAK ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL3N5c3RlbS9k ZXByZWNhdGVkX2xvZ2dpbmcucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1v bi9zeXN0ZW0vZGVwcmVjYXRlZF9sb2dnaW5nLnB5CmluZGV4IGJhMWM1ZWIuLmY3ZTU5YTMgMTAw NjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL3N5c3RlbS9kZXBy ZWNhdGVkX2xvZ2dpbmcucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21t b24vc3lzdGVtL2RlcHJlY2F0ZWRfbG9nZ2luZy5weQpAQCAtNDUsOSArNDUsMTAgQEAgY2xhc3Mg dGVlOgogICAgIGRlZiBfX2luaXRfXyhzZWxmLCAqZmlsZXMpOgogICAgICAgICBzZWxmLmZpbGVz ID0gZmlsZXMKIAotICAgIGRlZiB3cml0ZShzZWxmLCBzdHJpbmcpOgorICAgICMgQ2FsbGVycyBz aG91bGQgcGFzcyBhbiBhbHJlYWR5IGVuY29kZWQgc3RyaW5nIGZvciB3cml0aW5nLgorICAgIGRl ZiB3cml0ZShzZWxmLCBieXRlcyk6CiAgICAgICAgIGZvciBmaWxlIGluIHNlbGYuZmlsZXM6Ci0g ICAgICAgICAgICBmaWxlLndyaXRlKHN0cmluZykKKyAgICAgICAgICAgIGZpbGUud3JpdGUoYnl0 ZXMpCiAKIGNsYXNzIE91dHB1dFRlZToKICAgICBkZWYgX19pbml0X18oc2VsZik6CmRpZmYgLS1n aXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9zeXN0ZW0vZXhlY3V0aXZl LnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vc3lzdGVtL2V4ZWN1dGl2 ZS5weQppbmRleCBiNjEyNmU0Li5jYmUwZTFmIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3Jp cHRzL3dlYmtpdHB5L2NvbW1vbi9zeXN0ZW0vZXhlY3V0aXZlLnB5CisrKyBiL1dlYktpdFRvb2xz L1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL3N5c3RlbS9leGVjdXRpdmUucHkKQEAgLTg4LDYgKzg4 LDcgQEAgZGVmIHJ1bl9jb21tYW5kKCphcmdzLCAqKmt3YXJncyk6CiBjbGFzcyBFeGVjdXRpdmUo b2JqZWN0KToKIAogICAgIGRlZiBfcnVuX2NvbW1hbmRfd2l0aF90ZWVkX291dHB1dChzZWxmLCBh cmdzLCB0ZWVkX291dHB1dCk6CisgICAgICAgIGFyZ3MgPSBtYXAodW5pY29kZSwgYXJncykgICMg UG9wZW4gd2lsbCB0aHJvdyBhbiBleGNlcHRpb24gaWYgYXJncyBhcmUgbm9uLXN0cmluZ3MgKGxp a2UgaW50KCkpCiAgICAgICAgIGNoaWxkX3Byb2Nlc3MgPSBzdWJwcm9jZXNzLlBvcGVuKGFyZ3Ms CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN0ZG91dD1zdWJwcm9j ZXNzLlBJUEUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN0ZGVy cj1zdWJwcm9jZXNzLlNURE9VVCkKQEAgLTk5LDkgKzEwMCwxNiBAQCBjbGFzcyBFeGVjdXRpdmUo b2JqZWN0KToKICAgICAgICAgICAgIG91dHB1dF9saW5lID0gY2hpbGRfcHJvY2Vzcy5zdGRvdXQu cmVhZGxpbmUoKQogICAgICAgICAgICAgaWYgb3V0cHV0X2xpbmUgPT0gIiIgYW5kIGNoaWxkX3By b2Nlc3MucG9sbCgpICE9IE5vbmU6CiAgICAgICAgICAgICAgICAgcmV0dXJuIGNoaWxkX3Byb2Nl c3MucG9sbCgpCisgICAgICAgICAgICAjIFdlIGFzc3VtZSB0aGF0IHRoZSBjaGlsZCBwcm9jZXNz IHdyb3RlIHRvIHVzIGluIHV0Zi04LAorICAgICAgICAgICAgIyBzbyBubyByZS1lbmNvZGluZyBp cyBuZWNlc3NhcnkgYmVmb3JlIHdyaXRpbmcgaGVyZS4KICAgICAgICAgICAgIHRlZWRfb3V0cHV0 LndyaXRlKG91dHB1dF9saW5lKQogCi0gICAgZGVmIHJ1bl9hbmRfdGhyb3dfaWZfZmFpbChzZWxm LCBhcmdzLCBxdWlldD1GYWxzZSk6CisgICAgIyBGSVhNRTogUmVtb3ZlIHRoaXMgZGVwcmVjYXRl ZCBtZXRob2QgYW5kIG1vdmUgY2FsbGVycyB0byBydW5fY29tbWFuZC4KKyAgICAjIEZJWE1FOiBU aGlzIG1ldGhvZCBpcyBhIGhhY2sgdG8gYWxsb3cgcnVubmluZyBjb21tYW5kIHdoaWNoIGJvdGgK KyAgICAjIGNhcHR1cmUgdGhlaXIgb3V0cHV0IGFuZCBwcmludCBvdXQgdG8gc3RkaW4uICBVc2Vm dWwgZm9yIHRoaW5ncworICAgICMgbGlrZSAiYnVpbGQtd2Via2l0IiB3aGVyZSB3ZSB3YW50IHRv IGRpc3BsYXkgdG8gdGhlIHVzZXIgdGhhdCB3ZSdyZSBidWlsZGluZworICAgICMgYnV0IHN0aWxs IGhhdmUgdGhlIG91dHB1dCB0byBzdHVmZiBpbnRvIGEgbG9nIGZpbGUuCisgICAgZGVmIHJ1bl9h bmRfdGhyb3dfaWZfZmFpbChzZWxmLCBhcmdzLCBxdWlldD1GYWxzZSwgZGVjb2RlX291dHB1dD1U cnVlKToKICAgICAgICAgIyBDYWNoZSB0aGUgY2hpbGQncyBvdXRwdXQgbG9jYWxseSBzbyBpdCBj YW4gYmUgdXNlZCBmb3IgZXJyb3IgcmVwb3J0cy4KICAgICAgICAgY2hpbGRfb3V0X2ZpbGUgPSBT dHJpbmdJTy5TdHJpbmdJTygpCiAgICAgICAgIHRlZV9zdGRvdXQgPSBzeXMuc3Rkb3V0CkBAIC0x MTYsNiArMTI0LDEwIEBAIGNsYXNzIEV4ZWN1dGl2ZShvYmplY3QpOgogICAgICAgICBjaGlsZF9v dXRwdXQgPSBjaGlsZF9vdXRfZmlsZS5nZXR2YWx1ZSgpCiAgICAgICAgIGNoaWxkX291dF9maWxl LmNsb3NlKCkKIAorICAgICAgICAjIFdlIGFzc3VtZSB0aGUgY2hpbGQgcHJvY2VzcyBvdXRwdXQg dXRmLTgKKyAgICAgICAgaWYgZGVjb2RlX291dHB1dDoKKyAgICAgICAgICAgIGNoaWxkX291dHB1 dCA9IGNoaWxkX291dHB1dC5kZWNvZGUoInV0Zi04IikKKwogICAgICAgICBpZiBleGl0X2NvZGU6 CiAgICAgICAgICAgICByYWlzZSBTY3JpcHRFcnJvcihzY3JpcHRfYXJncz1hcmdzLAogICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgZXhpdF9jb2RlPWV4aXRfY29kZSwKQEAgLTE0NSw3ICsx NTcsNyBAQCBjbGFzcyBFeGVjdXRpdmUob2JqZWN0KToKICAgICAgICAgICAgICMgb3Mua2lsbCBp c24ndCBhdmFpbGFibGUgb24gV2luZG93cy4gIEhvd2V2ZXIsIHdoZW4gSSB0cmllZCBpdAogICAg ICAgICAgICAgIyB1c2luZyBDeWd3aW4sIGl0IHdvcmtlZCBmaW5lLiAgV2Ugc2hvdWxkIGludmVz dGlnYXRlIHdoZXRoZXIKICAgICAgICAgICAgICMgd2UgbmVlZCB0aGlzIHBsYXRmb3JtIHNwZWNp ZmljIGNvZGUgaGVyZS4KLSAgICAgICAgICAgIHN1YnByb2Nlc3MuY2FsbCgoJ3Rhc2traWxsLmV4 ZScsICcvZicsICcvcGlkJywgc3RyKHBpZCkpLAorICAgICAgICAgICAgc3VicHJvY2Vzcy5jYWxs KCgndGFza2tpbGwuZXhlJywgJy9mJywgJy9waWQnLCB1bmljb2RlKHBpZCkpLAogICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHN0ZGluPW9wZW4ob3MuZGV2bnVsbCwgJ3InKSwKICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBzdGRvdXQ9c3VicHJvY2Vzcy5QSVBFLAogICAgICAgICAgICAg ICAgICAgICAgICAgICAgIHN0ZGVycj1zdWJwcm9jZXNzLlBJUEUpCkBAIC0xNjMsMzEgKzE3NSwz NCBAQCBjbGFzcyBFeGVjdXRpdmUob2JqZWN0KToKICAgICBkZWYgaWdub3JlX2Vycm9yKGVycm9y KToKICAgICAgICAgcGFzcwogCi0gICAgIyBGSVhNRTogVGhpcyBzaG91bGQgYmUgbWVyZ2VkIHdp dGggcnVuX2FuZF90aHJvd19pZl9mYWlsCi0KKyAgICBkZWYgX2NvbXB1dGVfc3RkaW4oc2VsZiwg aW5wdXQpOgorICAgICAgICAiIiJSZXR1cm5zIChzdGRpbiwgc3RyaW5nX3RvX2NvbW11bmljYXRl KSIiIgorICAgICAgICBpZiBub3QgaW5wdXQ6CisgICAgICAgICAgICByZXR1cm4gKE5vbmUsIE5v bmUpCisgICAgICAgIGlmIGhhc2F0dHIoaW5wdXQsICJyZWFkIik6ICAjIENoZWNrIGlmIHRoZSBp bnB1dCBpcyBhIGZpbGUuCisgICAgICAgICAgICByZXR1cm4gKGlucHV0LCBOb25lKSAgIyBBc3N1 bWUgdGhlIGZpbGUgaXMgaW4gdGhlIHJpZ2h0IGVuY29kaW5nLgorCisgICAgICAgICMgUG9wZW4g aW4gUHl0aG9uIDIuNSBhbmQgYmVmb3JlIGRvZXMgbm90IGF1dG9tYXRpY2FsbHkgZW5jb2RlIHVu aWNvZGUgb2JqZWN0cy4KKyAgICAgICAgIyBodHRwOi8vYnVncy5weXRob24ub3JnL2lzc3VlNTI5 MAorICAgICAgICAjIFNlZSBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 Mzc1MjgKKyAgICAgICAgIyBmb3IgYW4gZXhhbXBsZSBvZiBhIHJlZ3Jlc2lvbiBjYXVzZWQgYnkg cGFzc2luZyBhIHVuaWNvZGUgc3RyaW5nIGRpcmVjdGx5LgorICAgICAgICAjIEZJWE1FOiBXZSBt YXkgbmVlZCB0byBlbmNvZGUgZGlmZmVyZW50bHkgb24gZGlmZmVyZW50IHBsYXRmb3Jtcy4KKyAg ICAgICAgaWYgaXNpbnN0YW5jZShpbnB1dCwgdW5pY29kZSk6CisgICAgICAgICAgICBpbnB1dCA9 IGlucHV0LmVuY29kZSgidXRmLTgiKQorICAgICAgICByZXR1cm4gKHN1YnByb2Nlc3MuUElQRSwg aW5wdXQpCisKKyAgICAjIEZJWE1FOiBydW5fYW5kX3Rocm93X2lmX2ZhaWwgc2hvdWxkIGJlIG1l cmdlZCBpbnRvIHRoaXMgbWV0aG9kLgogICAgIGRlZiBydW5fY29tbWFuZChzZWxmLAogICAgICAg ICAgICAgICAgICAgICBhcmdzLAogICAgICAgICAgICAgICAgICAgICBjd2Q9Tm9uZSwKICAgICAg ICAgICAgICAgICAgICAgaW5wdXQ9Tm9uZSwKICAgICAgICAgICAgICAgICAgICAgZXJyb3JfaGFu ZGxlcj1Ob25lLAogICAgICAgICAgICAgICAgICAgICByZXR1cm5fZXhpdF9jb2RlPUZhbHNlLAot ICAgICAgICAgICAgICAgICAgICByZXR1cm5fc3RkZXJyPVRydWUpOgotICAgICAgICBpZiBoYXNh dHRyKGlucHV0LCAncmVhZCcpOiAjIENoZWNrIGlmIHRoZSBpbnB1dCBpcyBhIGZpbGUuCi0gICAg ICAgICAgICBzdGRpbiA9IGlucHV0Ci0gICAgICAgICAgICBzdHJpbmdfdG9fY29tbXVuaWNhdGUg PSBOb25lCi0gICAgICAgIGVsc2U6Ci0gICAgICAgICAgICBzdGRpbiA9IE5vbmUKLSAgICAgICAg ICAgIGlmIGlucHV0OgotICAgICAgICAgICAgICAgIHN0ZGluID0gc3VicHJvY2Vzcy5QSVBFCi0g ICAgICAgICAgICAjIHN0cmluZ190b19jb21tdW5pY2F0ZSBzZWVtcyB0byBuZWVkIHRvIGJlIGEg c3RyIGZvciBwcm9wZXIKLSAgICAgICAgICAgICMgY29tbXVuaWNhdGlvbiB3aXRoIHNoZWxsIGNv bW1hbmRzLgotICAgICAgICAgICAgIyBTZWUgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTM3NTI4Ci0gICAgICAgICAgICAjIEZvciBhbiBleGFtcGxlIG9mIGEgcmVncmVz aW9uIGNhdXNlZCBieSBwYXNzaW5nIGEgdW5pY29kZSBzdHJpbmcgdGhyb3VnaC4KLSAgICAgICAg ICAgIHN0cmluZ190b19jb21tdW5pY2F0ZSA9IHN0cihpbnB1dCkKLSAgICAgICAgaWYgcmV0dXJu X3N0ZGVycjoKLSAgICAgICAgICAgIHN0ZGVyciA9IHN1YnByb2Nlc3MuU1RET1VUCi0gICAgICAg IGVsc2U6Ci0gICAgICAgICAgICBzdGRlcnIgPSBOb25lCisgICAgICAgICAgICAgICAgICAgIHJl dHVybl9zdGRlcnI9VHJ1ZSwKKyAgICAgICAgICAgICAgICAgICAgZGVjb2RlX291dHB1dD1UcnVl KToKKyAgICAgICAgYXJncyA9IG1hcCh1bmljb2RlLCBhcmdzKSAgIyBQb3BlbiB3aWxsIHRocm93 IGFuIGV4Y2VwdGlvbiBpZiBhcmdzIGFyZSBub24tc3RyaW5ncyAobGlrZSBpbnQoKSkKKyAgICAg ICAgc3RkaW4sIHN0cmluZ190b19jb21tdW5pY2F0ZSA9IHNlbGYuX2NvbXB1dGVfc3RkaW4oaW5w dXQpCisgICAgICAgIHN0ZGVyciA9IHN1YnByb2Nlc3MuU1RET1VUIGlmIHJldHVybl9zdGRlcnIg ZWxzZSBOb25lCiAKICAgICAgICAgcHJvY2VzcyA9IHN1YnByb2Nlc3MuUG9wZW4oYXJncywKICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3RkaW49c3RkaW4sCkBAIC0xOTUsNiAr MjEwLDkgQEAgY2xhc3MgRXhlY3V0aXZlKG9iamVjdCk6CiAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIHN0ZGVycj1zdGRlcnIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIGN3ZD1jd2QpCiAgICAgICAgIG91dHB1dCA9IHByb2Nlc3MuY29tbXVuaWNhdGUoc3Ry aW5nX3RvX2NvbW11bmljYXRlKVswXQorICAgICAgICAjIHJ1bl9jb21tYW5kIGF1dG9tYXRpY2Fs bHkgZGVjb2RlcyB0byB1bmljb2RlKCkgdW5sZXNzIGV4cGxpY2l0bHkgdG9sZCBub3QgdG8uCisg ICAgICAgIGlmIGRlY29kZV9vdXRwdXQ6CisgICAgICAgICAgICBvdXRwdXQgPSBvdXRwdXQuZGVj b2RlKCJ1dGYtOCIpCiAgICAgICAgIGV4aXRfY29kZSA9IHByb2Nlc3Mud2FpdCgpCiAKICAgICAg ICAgaWYgcmV0dXJuX2V4aXRfY29kZToKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMv d2Via2l0cHkvY29tbW9uL3N5c3RlbS9leGVjdXRpdmVfdW5pdHRlc3QucHkgYi9XZWJLaXRUb29s cy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9zeXN0ZW0vZXhlY3V0aXZlX3VuaXR0ZXN0LnB5Cmlu ZGV4IGFjMzgwZjguLjY0YzU1MmIgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvY29tbW9uL3N5c3RlbS9leGVjdXRpdmVfdW5pdHRlc3QucHkKKysrIGIvV2ViS2l0VG9v bHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vc3lzdGVtL2V4ZWN1dGl2ZV91bml0dGVzdC5weQpA QCAtMSw0ICsxLDQgQEAKLSMgQ29weXJpZ2h0IChDKSAyMDA5IEdvb2dsZSBJbmMuIEFsbCByaWdo dHMgcmVzZXJ2ZWQuCisjIENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUgSW5jLiBBbGwgcmlnaHRz IHJlc2VydmVkLgogIyBDb3B5cmlnaHQgKEMpIDIwMDkgRGFuaWVsIEJhdGVzIChkYmF0ZXNAaW50 dWRhdGEuY29tKS4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KICMKICMgUmVkaXN0cmlidXRpb24gYW5k IHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CkBAIC0zMSw2 ICszMSw3IEBAIGltcG9ydCB1bml0dGVzdAogCiBmcm9tIHdlYmtpdHB5LmNvbW1vbi5zeXN0ZW0u ZXhlY3V0aXZlIGltcG9ydCBFeGVjdXRpdmUsIHJ1bl9jb21tYW5kCiAKKwogY2xhc3MgRXhlY3V0 aXZlVGVzdCh1bml0dGVzdC5UZXN0Q2FzZSk6CiAKICAgICBkZWYgdGVzdF9ydW5fY29tbWFuZF93 aXRoX2JhZF9jb21tYW5kKHNlbGYpOgpAQCAtMzgsNSArMzksMjYgQEAgY2xhc3MgRXhlY3V0aXZl VGVzdCh1bml0dGVzdC5UZXN0Q2FzZSk6CiAgICAgICAgICAgICBydW5fY29tbWFuZChbImZvb19i YXJfY29tbWFuZF9ibGFoIl0sIGVycm9yX2hhbmRsZXI9RXhlY3V0aXZlLmlnbm9yZV9lcnJvciwg cmV0dXJuX2V4aXRfY29kZT1UcnVlKQogICAgICAgICBzZWxmLmZhaWxVbmxlc3NSYWlzZXMoT1NF cnJvciwgcnVuX2JhZF9jb21tYW5kKQogCi1pZiBfX25hbWVfXyA9PSAnX19tYWluX18nOgotICAg IHVuaXR0ZXN0Lm1haW4oKQorICAgIGRlZiB0ZXN0X3J1bl9jb21tYW5kX3dpdGhfdW5pY29kZShz ZWxmKToKKyAgICAgICAgIiIiVmFsaWRhdGUgdGhhdCBpdCBpcyBzYWZlIHRvIHBhc3MgdW5pY29k ZSgpIG9iamVjdHMKKyAgICAgICAgdG8gRXhlY3V0aXZlLnJ1biogbWV0aG9kcywgYW5kIHRoZXkg d2lsbCByZXR1cm4gdW5pY29kZSgpCisgICAgICAgIG9iamVjdHMgYnkgZGVmYXVsdCB1bmxlc3Mg ZGVjb2RlX291dHB1dD1GYWxzZSIiIgorICAgICAgICBleGVjdXRpdmUgPSBFeGVjdXRpdmUoKQor ICAgICAgICB1bmljb2RlX3RvciA9IHUiV2ViS2l0IFx1MjY2MSBUb3IgQXJuZSBWZXN0Ylx1MDBG OCEiCisgICAgICAgIHV0ZjhfdG9yID0gdW5pY29kZV90b3IuZW5jb2RlKCJ1dGYtOCIpCisKKyAg ICAgICAgb3V0cHV0ID0gZXhlY3V0aXZlLnJ1bl9jb21tYW5kKFsiY2F0Il0sIGlucHV0PXVuaWNv ZGVfdG9yKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFscyhvdXRwdXQsIHVuaWNvZGVfdG9yKQor CisgICAgICAgIG91dHB1dCA9IGV4ZWN1dGl2ZS5ydW5fY29tbWFuZChbImVjaG8iLCAiLW4iLCB1 bmljb2RlX3Rvcl0pCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWxzKG91dHB1dCwgdW5pY29kZV90 b3IpCisKKyAgICAgICAgb3V0cHV0ID0gZXhlY3V0aXZlLnJ1bl9jb21tYW5kKFsiZWNobyIsICIt biIsIHVuaWNvZGVfdG9yXSwgZGVjb2RlX291dHB1dD1GYWxzZSkKKyAgICAgICAgc2VsZi5hc3Nl cnRFcXVhbHMob3V0cHV0LCB1dGY4X3RvcikKKworICAgICAgICAjIEZJWE1FOiBXZSBzaG91bGQg b25seSBoYXZlIG9uZSBydW4qIG1ldGhvZCB0byB0ZXN0CisgICAgICAgIG91dHB1dCA9IGV4ZWN1 dGl2ZS5ydW5fYW5kX3Rocm93X2lmX2ZhaWwoWyJlY2hvIiwgIi1uIiwgdW5pY29kZV90b3JdLCBx dWlldD1UcnVlKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFscyhvdXRwdXQsIHVuaWNvZGVfdG9y KQorCisgICAgICAgIG91dHB1dCA9IGV4ZWN1dGl2ZS5ydW5fYW5kX3Rocm93X2lmX2ZhaWwoWyJl Y2hvIiwgIi1uIiwgdW5pY29kZV90b3JdLCBxdWlldD1UcnVlLCBkZWNvZGVfb3V0cHV0PUZhbHNl KQorICAgICAgICBzZWxmLmFzc2VydEVxdWFscyhvdXRwdXQsIHV0ZjhfdG9yKQpkaWZmIC0tZ2l0 IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvbGF5b3V0X3BhY2th Z2UvZHVtcF9yZW5kZXJfdHJlZV90aHJlYWQucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy9sYXlvdXRfcGFja2FnZS9kdW1wX3JlbmRlcl90cmVlX3RocmVhZC5w eQppbmRleCA5M2I0Yzc5Li42NTQ4ZWYxIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRz L3dlYmtpdHB5L2xheW91dF90ZXN0cy9sYXlvdXRfcGFja2FnZS9kdW1wX3JlbmRlcl90cmVlX3Ro cmVhZC5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9s YXlvdXRfcGFja2FnZS9kdW1wX3JlbmRlcl90cmVlX3RocmVhZC5weQpAQCAtMzUsNiArMzUsNyBA QCB0aGUgb3V0cHV0LiAgV2hlbiB0aGVyZSBhcmUgbm8gbW9yZSBVUkxzIHRvIHByb2Nlc3MgaW4g dGhlIHNoYXJlZCBxdWV1ZSwgdGhlCiB0aHJlYWQgZXhpdHMuCiAiIiIKIAoraW1wb3J0IGNvZGVj cwogaW1wb3J0IGNvcHkKIGltcG9ydCBsb2dnaW5nCiBpbXBvcnQgb3MKQEAgLTI4Niw3ICsyODcs NyBAQCBjbGFzcyBUZXN0U2hlbGxUaHJlYWQodGhyZWFkaW5nLlRocmVhZCk6CiAgICAgICAgICMg VGhpcyBpcyBjcmVhdGVkIGluIHJ1bl93ZWJraXRfdGVzdHMucHk6X1ByZXBhcmVMaXN0c0FuZFBy aW50T3V0cHV0LgogICAgICAgICB0ZXN0c19ydW5fZmlsZW5hbWUgPSBvcy5wYXRoLmpvaW4oc2Vs Zi5fb3B0aW9ucy5yZXN1bHRzX2RpcmVjdG9yeSwKICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICJ0ZXN0c19ydW4udHh0IikKLSAgICAgICAgdGVzdHNfcnVuX2ZpbGUg PSBvcGVuKHRlc3RzX3J1bl9maWxlbmFtZSwgImEiKQorICAgICAgICB0ZXN0c19ydW5fZmlsZSA9 IGNvZGVjcy5vcGVuKHRlc3RzX3J1bl9maWxlbmFtZSwgImEiLCAidXRmLTgiKQogCiAgICAgICAg IHdoaWxlIFRydWU6CiAgICAgICAgICAgICBpZiBzZWxmLl9jYW5jZWxlZDoKZGlmZiAtLWdpdCBh L1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9wYWNrYWdl L2pzb25fcmVzdWx0c19nZW5lcmF0b3IucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5 L2xheW91dF90ZXN0cy9sYXlvdXRfcGFja2FnZS9qc29uX3Jlc3VsdHNfZ2VuZXJhdG9yLnB5Cmlu ZGV4IGE2OGFiNGEuLmI5NzUyMGUgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9wYWNrYWdlL2pzb25fcmVzdWx0c19nZW5lcmF0b3Iu cHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvbGF5b3V0 X3BhY2thZ2UvanNvbl9yZXN1bHRzX2dlbmVyYXRvci5weQpAQCAtMjcsNiArMjcsNyBAQAogIyAo SU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VU IE9GIFRIRSBVU0UKICMgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQ T1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KIAoraW1wb3J0IGNvZGVjcwogaW1wb3J0IGxvZ2dp bmcKIGltcG9ydCBvcwogaW1wb3J0IHN1YnByb2Nlc3MKQEAgLTExOCw3ICsxMTksNyBAQCBjbGFz cyBKU09OUmVzdWx0c0dlbmVyYXRvcihvYmplY3QpOgogICAgICAgICAiIiJHZW5lcmF0ZXMgdGhl IEpTT04gb3V0cHV0IGZpbGUuIiIiCiAgICAgICAgIGpzb24gPSBzZWxmLl9nZXRfanNvbigpCiAg ICAgICAgIGlmIGpzb246Ci0gICAgICAgICAgICByZXN1bHRzX2ZpbGUgPSBvcGVuKHNlbGYuX3Jl c3VsdHNfZmlsZV9wYXRoLCAidyIpCisgICAgICAgICAgICByZXN1bHRzX2ZpbGUgPSBjb2RlY3Mu b3BlbihzZWxmLl9yZXN1bHRzX2ZpbGVfcGF0aCwgInciLCAidXRmLTgiKQogICAgICAgICAgICAg cmVzdWx0c19maWxlLndyaXRlKGpzb24pCiAgICAgICAgICAgICByZXN1bHRzX2ZpbGUuY2xvc2Uo KQogCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0 cy9sYXlvdXRfcGFja2FnZS9tZXRlcmVkX3N0cmVhbS5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMv d2Via2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9wYWNrYWdlL21ldGVyZWRfc3RyZWFtLnB5Cmlu ZGV4IDcyYjMwYTEuLjVjMjUwMzMgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9wYWNrYWdlL21ldGVyZWRfc3RyZWFtLnB5CisrKyBi L1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9wYWNrYWdl L21ldGVyZWRfc3RyZWFtLnB5CkBAIC01Niw2ICs1Niw4IEBAIGNsYXNzIE1ldGVyZWRTdHJlYW06 CiAgICAgICAgIHNlbGYuX3N0cmVhbSA9IHN0cmVhbQogICAgICAgICBzZWxmLl9sYXN0X3VwZGF0 ZSA9ICIiCiAKKyAgICAjIEZJWE1FOiBEb2VzIHRoaXMgdGFrZSBhIHN0cmluZyAodW5pY29kZSkg b3IgYW4gYXJyYXkgb2YgYnl0ZXMgKHN0cik/CisgICAgIyBJZiBpdCB0YWtlcyBhIHN0cmluZywg aXQgbmVlZHMgdG8gY2FsbCB0eHQuZW5jb2RlKCJ1dGYtOCIpCiAgICAgZGVmIHdyaXRlKHNlbGYs IHR4dCk6CiAgICAgICAgICIiIldyaXRlIHRleHQgZGlyZWN0bHkgdG8gdGhlIHN0cmVhbSwgb3Zl cndyaXRpbmcgYW5kIHJlc2V0dGluZyB0aGUKICAgICAgICAgbWV0ZXIuIiIiCkBAIC02OCw2ICs3 MCw4IEBAIGNsYXNzIE1ldGVyZWRTdHJlYW06CiAgICAgICAgICIiIkZsdXNoIGFueSBidWZmZXJl ZCBvdXRwdXQuIiIiCiAgICAgICAgIHNlbGYuX3N0cmVhbS5mbHVzaCgpCiAKKyAgICAjIEZJWE1F OiBEb2VzIHRoaXMgdGFrZSBhIHN0cmluZyAodW5pY29kZSkgb3IgYW4gYXJyYXkgb2YgYnl0ZXMg KHN0cik/CisgICAgIyBJZiBpdCB0YWtlcyBhIHN0cmluZywgaXQgbmVlZHMgdG8gY2FsbCB0eHQu ZW5jb2RlKCJ1dGYtOCIpCiAgICAgZGVmIHVwZGF0ZShzZWxmLCBzdHIpOgogICAgICAgICAiIiJX cml0ZSBhbiB1cGRhdGUgdG8gdGhlIHN0cmVhbSB0aGF0IHdpbGwgZ2V0IG92ZXJ3cml0dGVuIGJ5 IHRoZSBuZXh0CiAgICAgICAgIHVwZGF0ZSgpIG9yIGJ5IGEgd3JpdGUoKS4KZGlmZiAtLWdpdCBh L1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvbWFjX3VuaXR0 ZXN0LnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9t YWNfdW5pdHRlc3QucHkKaW5kZXggZTQ3YTRhNC4uNjk4YzZkMCAxMDA2NDQKLS0tIGEvV2ViS2l0 VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9tYWNfdW5pdHRlc3QucHkK KysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9tYWNf dW5pdHRlc3QucHkKQEAgLTQwLDcgKzQwLDcgQEAgY2xhc3MgTWFjVGVzdCh1bml0dGVzdC5UZXN0 Q2FzZSk6CiAgICAgICAgIHJlbGF0aXZlX3BhdGhzID0gW3BhdGhbbGVuKHBvcnQucGF0aF9mcm9t X3dlYmtpdF9iYXNlKCkpOl0gZm9yIHBhdGggaW4gc2tpcHBlZF9wYXRoc10KICAgICAgICAgc2Vs Zi5hc3NlcnRFcXVhbChyZWxhdGl2ZV9wYXRocywgWydMYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMt bGVvcGFyZC9Ta2lwcGVkJywgJ0xheW91dFRlc3RzL3BsYXRmb3JtL21hYy9Ta2lwcGVkJ10pCiAK LSAgICBleGFtcGxlX3NraXBwZWRfZmlsZSA9ICIiIgorICAgIGV4YW1wbGVfc2tpcHBlZF9maWxl ID0gdSIiIgogIyA8cmRhcjovL3Byb2JsZW0vNTY0Nzk1Mj4gZmFzdC9ldmVudHMvbW91c2VvdXQt b24td2luZG93Lmh0bWwgbmVlZHMgbWFjIERSVCB0byBpc3N1ZSBtb3VzZSBvdXQgZXZlbnRzCiBm YXN0L2V2ZW50cy9tb3VzZW91dC1vbi13aW5kb3cuaHRtbAogCkBAIC01OCw3ICs1OCw3IEBAIHN2 Zy9iYXRpay90ZXh0L3NtYWxsRm9udHMuc3ZnCiAKICAgICBkZWYgdGVzdF9za2lwcGVkX2ZpbGVf cGF0aHMoc2VsZik6CiAgICAgICAgIHBvcnQgPSBtYWMuTWFjUG9ydCgpCi0gICAgICAgIHNraXBw ZWRfZmlsZSA9IFN0cmluZ0lPLlN0cmluZ0lPKHNlbGYuZXhhbXBsZV9za2lwcGVkX2ZpbGUpCisg ICAgICAgIHNraXBwZWRfZmlsZSA9IFN0cmluZ0lPLlN0cmluZ0lPKHNlbGYuZXhhbXBsZV9za2lw cGVkX2ZpbGUuZW5jb2RlKCJ1dGYtOCIpKQogICAgICAgICBzZWxmLmFzc2VydEVxdWFsKHBvcnQu X3Rlc3RzX2Zyb21fc2tpcHBlZF9maWxlKHNraXBwZWRfZmlsZSksIHNlbGYuZXhhbXBsZV9za2lw cGVkX3Rlc3RzKQogCiAKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkv dG9vbC9jb21tYW5kcy9lYXJseXdhcm5pbmdzeXN0ZW0ucHkgYi9XZWJLaXRUb29scy9TY3JpcHRz L3dlYmtpdHB5L3Rvb2wvY29tbWFuZHMvZWFybHl3YXJuaW5nc3lzdGVtLnB5CmluZGV4IDllYTM0 YzAuLjc1MDVjNjIgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9v bC9jb21tYW5kcy9lYXJseXdhcm5pbmdzeXN0ZW0ucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0 cy93ZWJraXRweS90b29sL2NvbW1hbmRzL2Vhcmx5d2FybmluZ3N5c3RlbS5weQpAQCAtMjYsOCAr MjYsNiBAQAogIyAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElO IEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKICMgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJ U0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KIAotZnJvbSBTdHJpbmdJTyBp bXBvcnQgU3RyaW5nSU8KLQogZnJvbSB3ZWJraXRweS50b29sLmNvbW1hbmRzLnF1ZXVlcyBpbXBv cnQgQWJzdHJhY3RSZXZpZXdRdWV1ZQogZnJvbSB3ZWJraXRweS5jb21tb24uY29uZmlnLmNvbW1p dHRlcnMgaW1wb3J0IENvbW1pdHRlckxpc3QKIGZyb20gd2Via2l0cHkuY29tbW9uLmNvbmZpZy5w b3J0cyBpbXBvcnQgV2ViS2l0UG9ydApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93 ZWJraXRweS90b29sL2NvbW1hbmRzL3F1ZXVlcy5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvdG9vbC9jb21tYW5kcy9xdWV1ZXMucHkKaW5kZXggZjBkYTM3OS4uMzMxODUzMSAxMDA2 NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL2NvbW1hbmRzL3F1ZXVl cy5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29tbWFuZHMvcXVl dWVzLnB5CkBAIC03MSw4ICs3MSw5IEBAIGNsYXNzIEFic3RyYWN0UXVldWUoQ29tbWFuZCwgUXVl dWVFbmdpbmVEZWxlZ2F0ZSk6CiAgICAgZGVmIHJ1bl93ZWJraXRfcGF0Y2goc2VsZiwgYXJncyk6 CiAgICAgICAgIHdlYmtpdF9wYXRjaF9hcmdzID0gW3NlbGYudG9vbC5wYXRoKCldCiAgICAgICAg ICMgRklYTUU6IFRoaXMgaXMgYSBoYWNrLCB3ZSBzaG91bGQgaGF2ZSBhIG1vcmUgZ2VuZXJhbCB3 YXkgdG8gcGFzcyBnbG9iYWwgb3B0aW9ucy4KLSAgICAgICAgd2Via2l0X3BhdGNoX2FyZ3MgKz0g WyItLXN0YXR1cy1ob3N0PSVzIiAlIHNlbGYudG9vbC5zdGF0dXNfc2VydmVyLmhvc3RdCi0gICAg ICAgIHdlYmtpdF9wYXRjaF9hcmdzICs9IG1hcChzdHIsIGFyZ3MpCisgICAgICAgIHdlYmtpdF9w YXRjaF9hcmdzLmFwcGVuZCgiLS1zdGF0dXMtaG9zdCIpCisgICAgICAgIHdlYmtpdF9wYXRjaF9h cmdzLmFwcGVuZChzZWxmLnRvb2wuc3RhdHVzX3NlcnZlci5ob3N0KQorICAgICAgICB3ZWJraXRf cGF0Y2hfYXJncy5leHRlbmQoYXJncykKICAgICAgICAgcmV0dXJuIHNlbGYudG9vbC5leGVjdXRp dmUucnVuX2FuZF90aHJvd19pZl9mYWlsKHdlYmtpdF9wYXRjaF9hcmdzKQogCiAgICAgZGVmIF9s b2dfZGlyZWN0b3J5KHNlbGYpOgpAQCAtMTIzLDcgKzEyNCw3IEBAIGNsYXNzIEFic3RyYWN0UXVl dWUoQ29tbWFuZCwgUXVldWVFbmdpbmVEZWxlZ2F0ZSk6CiAgICAgICAgIGlmIGlzX2Vycm9yOgog ICAgICAgICAgICAgbWVzc2FnZSA9ICJFcnJvcjogJXMiICUgbWVzc2FnZQogICAgICAgICBvdXRw dXQgPSBzY3JpcHRfZXJyb3IubWVzc2FnZV93aXRoX291dHB1dChvdXRwdXRfbGltaXQ9MTAyNCox MDI0KSAjIDFNQgotICAgICAgICByZXR1cm4gdG9vbC5zdGF0dXNfc2VydmVyLnVwZGF0ZV9zdGF0 dXMoY2xzLm5hbWUsIG1lc3NhZ2UsIHN0YXRlWyJwYXRjaCJdLCBTdHJpbmdJTyhvdXRwdXQpKQor ICAgICAgICByZXR1cm4gdG9vbC5zdGF0dXNfc2VydmVyLnVwZGF0ZV9zdGF0dXMoY2xzLm5hbWUs IG1lc3NhZ2UsIHN0YXRlWyJwYXRjaCJdLCBTdHJpbmdJTyhvdXRwdXQuZW5jb2RlKCJ1dGYtOCIp KSkKIAogCiBjbGFzcyBBYnN0cmFjdFBhdGNoUXVldWUoQWJzdHJhY3RRdWV1ZSk6CmRpZmYgLS1n aXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29tbWFuZHMvcXVldWVzX3Vu aXR0ZXN0LnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL2NvbW1hbmRzL3F1 ZXVlc191bml0dGVzdC5weQppbmRleCBmMGY3Yzg2Li5lZTU1MTI4IDEwMDY0NAotLS0gYS9XZWJL aXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29tbWFuZHMvcXVldWVzX3VuaXR0ZXN0LnB5 CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9jb21tYW5kcy9xdWV1ZXNf dW5pdHRlc3QucHkKQEAgLTc1LDcgKzc1LDcgQEAgY2xhc3MgQWJzdHJhY3RRdWV1ZVRlc3QoQ29t bWFuZHNUZXN0KToKICAgICAgICAgcXVldWUuYmluZF90b190b29sKHRvb2wpCiAKICAgICAgICAg cXVldWUucnVuX3dlYmtpdF9wYXRjaChydW5fYXJncykKLSAgICAgICAgZXhwZWN0ZWRfcnVuX2Fy Z3MgPSBbImVjaG8iLCAiLS1zdGF0dXMtaG9zdD1leGFtcGxlLmNvbSJdICsgbWFwKHN0ciwgcnVu X2FyZ3MpCisgICAgICAgIGV4cGVjdGVkX3J1bl9hcmdzID0gWyJlY2hvIiwgIi0tc3RhdHVzLWhv c3QiLCAiZXhhbXBsZS5jb20iXSArIHJ1bl9hcmdzCiAgICAgICAgIHRvb2wuZXhlY3V0aXZlLnJ1 bl9hbmRfdGhyb3dfaWZfZmFpbC5hc3NlcnRfY2FsbGVkX3dpdGgoZXhwZWN0ZWRfcnVuX2FyZ3Mp CiAKICAgICBkZWYgdGVzdF9ydW5fd2Via2l0X3BhdGNoKHNlbGYpOgpAQCAtMTUwLDcgKzE1MCw3 IEBAIFdhcm5pbmcsIGF0dGFjaG1lbnQgMTI4IG9uIGJ1ZyA0MiBoYXMgaW52YWxpZCBjb21taXR0 ZXIgKG5vbi1jb21taXR0ZXJAZXhhbXBsZS5jCiBXYXJuaW5nLCBhdHRhY2htZW50IDEyOCBvbiBi dWcgNDIgaGFzIGludmFsaWQgY29tbWl0dGVyIChub24tY29tbWl0dGVyQGV4YW1wbGUuY29tKQog MSBwYXRjaCBpbiBjb21taXQtcXVldWUgWzEwNl0KICIiIiwKLSAgICAgICAgICAgICJwcm9jZXNz X3dvcmtfaXRlbSI6ICJNT0NLIHJ1bl9hbmRfdGhyb3dfaWZfZmFpbDogWydlY2hvJywgJy0tc3Rh dHVzLWhvc3Q9ZXhhbXBsZS5jb20nLCAnbGFuZC1hdHRhY2htZW50JywgJy0tZm9yY2UtY2xlYW4n LCAnLS1idWlsZCcsICctLXRlc3QnLCAnLS1ub24taW50ZXJhY3RpdmUnLCAnLS1pZ25vcmUtYnVp bGRlcnMnLCAnLS1idWlsZC1zdHlsZT1ib3RoJywgJy0tcXVpZXQnLCAnNzY1NDMnXVxuIiwKKyAg ICAgICAgICAgICJwcm9jZXNzX3dvcmtfaXRlbSI6ICJNT0NLIHJ1bl9hbmRfdGhyb3dfaWZfZmFp bDogWydlY2hvJywgJy0tc3RhdHVzLWhvc3QnLCAnZXhhbXBsZS5jb20nLCAnbGFuZC1hdHRhY2ht ZW50JywgJy0tZm9yY2UtY2xlYW4nLCAnLS1idWlsZCcsICctLXRlc3QnLCAnLS1ub24taW50ZXJh Y3RpdmUnLCAnLS1pZ25vcmUtYnVpbGRlcnMnLCAnLS1idWlsZC1zdHlsZT1ib3RoJywgJy0tcXVp ZXQnLCA3NjU0M11cbiIsCiAgICAgICAgIH0KICAgICAgICAgc2VsZi5hc3NlcnRfcXVldWVfb3V0 cHV0cyhDb21taXRRdWV1ZSgpLCB0b29sPXRvb2wsIHdvcmtfaXRlbT1yb2xsb3V0X3BhdGNoLCBl eHBlY3RlZF9zdGRlcnI9ZXhwZWN0ZWRfc3RkZXJyKQogCmRpZmYgLS1naXQgYS9XZWJLaXRUb29s cy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29tbWFuZHMvdXBsb2FkLnB5IGIvV2ViS2l0VG9vbHMv U2NyaXB0cy93ZWJraXRweS90b29sL2NvbW1hbmRzL3VwbG9hZC5weQppbmRleCBiZGYwNjBhLi4z M2JjYTdhIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29t bWFuZHMvdXBsb2FkLnB5CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9j b21tYW5kcy91cGxvYWQucHkKQEAgLTMwLDcgKzMwLDYgQEAKIAogaW1wb3J0IG9zCiBpbXBvcnQg cmUKLWltcG9ydCBTdHJpbmdJTwogaW1wb3J0IHN5cwogCiBmcm9tIG9wdHBhcnNlIGltcG9ydCBt YWtlX29wdGlvbgpAQCAtMjYwLDEwICsyNTksNiBAQCBjbGFzcyBQb3N0Q29tbWl0cyhBYnN0cmFj dERlY2xhcmF0aXZlQ29tbWFuZCk6CiAgICAgICAgICAgICBjb21tZW50X3RleHQgKz0gdG9vbC5z Y20oKS5maWxlc19jaGFuZ2VkX3N1bW1hcnlfZm9yX2NvbW1pdChjb21taXRfaWQpCiAgICAgICAg IHJldHVybiBjb21tZW50X3RleHQKIAotICAgIGRlZiBfZGlmZl9maWxlX2Zvcl9jb21taXQoc2Vs ZiwgdG9vbCwgY29tbWl0X2lkKToKLSAgICAgICAgZGlmZiA9IHRvb2wuc2NtKCkuY3JlYXRlX3Bh dGNoX2Zyb21fbG9jYWxfY29tbWl0KGNvbW1pdF9pZCkKLSAgICAgICAgcmV0dXJuIFN0cmluZ0lP LlN0cmluZ0lPKGRpZmYpICMgYWRkX3BhdGNoX3RvX2J1ZyBleHBlY3RzIGEgZmlsZS1saWtlIG9i amVjdAotCiAgICAgZGVmIGV4ZWN1dGUoc2VsZiwgb3B0aW9ucywgYXJncywgdG9vbCk6CiAgICAg ICAgIGNvbW1pdF9pZHMgPSB0b29sLnNjbSgpLmNvbW1pdF9pZHNfZnJvbV9jb21taXRpc2hfYXJn dW1lbnRzKGFyZ3MpCiAgICAgICAgIGlmIGxlbihjb21taXRfaWRzKSA+IDEwOiAjIFdlIGNvdWxk IGxvd2VyIHRoaXMgbGltaXQsIDEwIGlzIHRvbyBtYW55IGZvciBvbmUgYnVnIGFzLWlzLgpAQCAt Mjg0LDEwICsyNzksMTAgQEAgY2xhc3MgUG9zdENvbW1pdHMoQWJzdHJhY3REZWNsYXJhdGl2ZUNv bW1hbmQpOgogICAgICAgICAgICAgICAgIHN0ZXBzLk9ic29sZXRlUGF0Y2hlcyh0b29sLCBvcHRp b25zKS5ydW4oc3RhdGUpCiAgICAgICAgICAgICAgICAgaGF2ZV9vYnNvbGV0ZWRfcGF0Y2hlcy5h ZGQoYnVnX2lkKQogCi0gICAgICAgICAgICBkaWZmX2ZpbGUgPSBzZWxmLl9kaWZmX2ZpbGVfZm9y X2NvbW1pdCh0b29sLCBjb21taXRfaWQpCisgICAgICAgICAgICBkaWZmID0gdG9vbC5zY20oKS5j cmVhdGVfcGF0Y2hfZnJvbV9sb2NhbF9jb21taXQoY29tbWl0X2lkKQogICAgICAgICAgICAgZGVz Y3JpcHRpb24gPSBvcHRpb25zLmRlc2NyaXB0aW9uIG9yIGNvbW1pdF9tZXNzYWdlLmRlc2NyaXB0 aW9uKGxzdHJpcD1UcnVlLCBzdHJpcF91cmw9VHJ1ZSkKICAgICAgICAgICAgIGNvbW1lbnRfdGV4 dCA9IHNlbGYuX2NvbW1lbnRfdGV4dF9mb3JfY29tbWl0KG9wdGlvbnMsIGNvbW1pdF9tZXNzYWdl LCB0b29sLCBjb21taXRfaWQpCi0gICAgICAgICAgICB0b29sLmJ1Z3MuYWRkX3BhdGNoX3RvX2J1 ZyhidWdfaWQsIGRpZmZfZmlsZSwgZGVzY3JpcHRpb24sIGNvbW1lbnRfdGV4dCwgbWFya19mb3Jf cmV2aWV3PW9wdGlvbnMucmV2aWV3LCBtYXJrX2Zvcl9jb21taXRfcXVldWU9b3B0aW9ucy5yZXF1 ZXN0X2NvbW1pdCkKKyAgICAgICAgICAgIHRvb2wuYnVncy5hZGRfcGF0Y2hfdG9fYnVnKGJ1Z19p ZCwgZGlmZiwgZGVzY3JpcHRpb24sIGNvbW1lbnRfdGV4dCwgbWFya19mb3JfcmV2aWV3PW9wdGlv bnMucmV2aWV3LCBtYXJrX2Zvcl9jb21taXRfcXVldWU9b3B0aW9ucy5yZXF1ZXN0X2NvbW1pdCkK IAogCiAjIEZJWE1FOiBUaGlzIGNvbW1hbmQgbmVlZHMgdG8gYmUgYnJvdWdodCBpbnRvIHRoZSBt b2Rlcm4gYWdlIHdpdGggc3RlcHMgYW5kIENvbW1pdEluZm8uCkBAIC00MDQsOCArMzk5LDcgQEAg Y2xhc3MgQ3JlYXRlQnVnKEFic3RyYWN0RGVjbGFyYXRpdmVDb21tYW5kKToKICAgICAgICAgICAg IGNvbW1lbnRfdGV4dCArPSB0b29sLnNjbSgpLmZpbGVzX2NoYW5nZWRfc3VtbWFyeV9mb3JfY29t bWl0KGNvbW1pdF9pZCkKIAogICAgICAgICBkaWZmID0gdG9vbC5zY20oKS5jcmVhdGVfcGF0Y2hf ZnJvbV9sb2NhbF9jb21taXQoY29tbWl0X2lkKQotICAgICAgICBkaWZmX2ZpbGUgPSBTdHJpbmdJ Ty5TdHJpbmdJTyhkaWZmKSAjIGNyZWF0ZV9idWcgZXhwZWN0cyBhIGZpbGUtbGlrZSBvYmplY3QK LSAgICAgICAgYnVnX2lkID0gdG9vbC5idWdzLmNyZWF0ZV9idWcoYnVnX3RpdGxlLCBjb21tZW50 X3RleHQsIG9wdGlvbnMuY29tcG9uZW50LCBkaWZmX2ZpbGUsICJQYXRjaCIsIGNjPW9wdGlvbnMu Y2MsIG1hcmtfZm9yX3Jldmlldz1vcHRpb25zLnJldmlldywgbWFya19mb3JfY29tbWl0X3F1ZXVl PW9wdGlvbnMucmVxdWVzdF9jb21taXQpCisgICAgICAgIGJ1Z19pZCA9IHRvb2wuYnVncy5jcmVh dGVfYnVnKGJ1Z190aXRsZSwgY29tbWVudF90ZXh0LCBvcHRpb25zLmNvbXBvbmVudCwgZGlmZiwg IlBhdGNoIiwgY2M9b3B0aW9ucy5jYywgbWFya19mb3JfcmV2aWV3PW9wdGlvbnMucmV2aWV3LCBt YXJrX2Zvcl9jb21taXRfcXVldWU9b3B0aW9ucy5yZXF1ZXN0X2NvbW1pdCkKIAogICAgICAgICBp ZiBidWdfaWQgYW5kIGxlbihjb21taXRfaWRzKSA+IDE6CiAgICAgICAgICAgICBvcHRpb25zLmJ1 Z19pZCA9IGJ1Z19pZApAQCAtNDI0LDggKzQxOCw3IEBAIGNsYXNzIENyZWF0ZUJ1ZyhBYnN0cmFj dERlY2xhcmF0aXZlQ29tbWFuZCk6CiAgICAgICAgICAgICBjb21tZW50X3RleHQgPSBjb21taXRf bWVzc2FnZS5ib2R5KGxzdHJpcD1UcnVlKQogCiAgICAgICAgIGRpZmYgPSB0b29sLnNjbSgpLmNy ZWF0ZV9wYXRjaCgpCi0gICAgICAgIGRpZmZfZmlsZSA9IFN0cmluZ0lPLlN0cmluZ0lPKGRpZmYp ICMgY3JlYXRlX2J1ZyBleHBlY3RzIGEgZmlsZS1saWtlIG9iamVjdAotICAgICAgICBidWdfaWQg PSB0b29sLmJ1Z3MuY3JlYXRlX2J1ZyhidWdfdGl0bGUsIGNvbW1lbnRfdGV4dCwgb3B0aW9ucy5j b21wb25lbnQsIGRpZmZfZmlsZSwgIlBhdGNoIiwgY2M9b3B0aW9ucy5jYywgbWFya19mb3JfcmV2 aWV3PW9wdGlvbnMucmV2aWV3LCBtYXJrX2Zvcl9jb21taXRfcXVldWU9b3B0aW9ucy5yZXF1ZXN0 X2NvbW1pdCkKKyAgICAgICAgYnVnX2lkID0gdG9vbC5idWdzLmNyZWF0ZV9idWcoYnVnX3RpdGxl LCBjb21tZW50X3RleHQsIG9wdGlvbnMuY29tcG9uZW50LCBkaWZmLCAiUGF0Y2giLCBjYz1vcHRp b25zLmNjLCBtYXJrX2Zvcl9yZXZpZXc9b3B0aW9ucy5yZXZpZXcsIG1hcmtfZm9yX2NvbW1pdF9x dWV1ZT1vcHRpb25zLnJlcXVlc3RfY29tbWl0KQogCiAgICAgZGVmIHByb21wdF9mb3JfYnVnX3Rp dGxlX2FuZF9jb21tZW50KHNlbGYpOgogICAgICAgICBidWdfdGl0bGUgPSBVc2VyLnByb21wdCgi QnVnIHRpdGxlOiAiKQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS90 b29sL21vY2t0b29sLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL21vY2t0 b29sLnB5CmluZGV4IGM1NmM1M2UuLjdkMzE0ZDEgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1Nj cmlwdHMvd2Via2l0cHkvdG9vbC9tb2NrdG9vbC5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRz L3dlYmtpdHB5L3Rvb2wvbW9ja3Rvb2wucHkKQEAgLTI2MCw3ICsyNjAsNyBAQCBjbGFzcyBNb2Nr QnVnemlsbGEoTW9jayk6CiAgICAgICAgICAgICAgICAgICAgYnVnX3RpdGxlLAogICAgICAgICAg ICAgICAgICAgIGJ1Z19kZXNjcmlwdGlvbiwKICAgICAgICAgICAgICAgICAgICBjb21wb25lbnQ9 Tm9uZSwKLSAgICAgICAgICAgICAgICAgICBwYXRjaF9maWxlX29iamVjdD1Ob25lLAorICAgICAg ICAgICAgICAgICAgIGRpZmY9Tm9uZSwKICAgICAgICAgICAgICAgICAgICBwYXRjaF9kZXNjcmlw dGlvbj1Ob25lLAogICAgICAgICAgICAgICAgICAgIGNjPU5vbmUsCiAgICAgICAgICAgICAgICAg ICAgYmxvY2tlZD1Ob25lLApAQCAtMjk5LDcgKzI5OSw3IEBAIGNsYXNzIE1vY2tCdWd6aWxsYShN b2NrKToKIAogICAgIGRlZiBhZGRfcGF0Y2hfdG9fYnVnKHNlbGYsCiAgICAgICAgICAgICAgICAg ICAgICAgICAgYnVnX2lkLAotICAgICAgICAgICAgICAgICAgICAgICAgIHBhdGNoX2ZpbGVfb2Jq ZWN0LAorICAgICAgICAgICAgICAgICAgICAgICAgIGRpZmYsCiAgICAgICAgICAgICAgICAgICAg ICAgICAgZGVzY3JpcHRpb24sCiAgICAgICAgICAgICAgICAgICAgICAgICAgY29tbWVudF90ZXh0 PU5vbmUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgbWFya19mb3JfcmV2aWV3PUZhbHNlLApk aWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBzL2Fic3Ry YWN0c3RlcC5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9zdGVwcy9hYnN0 cmFjdHN0ZXAucHkKaW5kZXggMWFkMzQzZC4uMjE4N2ZjMCAxMDA2NDQKLS0tIGEvV2ViS2l0VG9v bHMvU2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBzL2Fic3RyYWN0c3RlcC5weQorKysgYi9XZWJL aXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvYWJzdHJhY3RzdGVwLnB5CkBAIC0z OSw3ICszOSw3IEBAIGNsYXNzIEFic3RyYWN0U3RlcChvYmplY3QpOgogICAgIGRlZiBfcnVuX3Nj cmlwdChzZWxmLCBzY3JpcHRfbmFtZSwgcXVpZXQ9RmFsc2UsIHBvcnQ9V2ViS2l0UG9ydCk6CiAg ICAgICAgIGxvZygiUnVubmluZyAlcyIgJSBzY3JpcHRfbmFtZSkKICAgICAgICAgIyBGSVhNRTog VGhpcyBzaG91bGQgdXNlIHNlbGYucG9ydCgpCi0gICAgICAgIHNlbGYuX3Rvb2wuZXhlY3V0aXZl LnJ1bl9hbmRfdGhyb3dfaWZfZmFpbChwb3J0LnNjcmlwdF9wYXRoKHNjcmlwdF9uYW1lKSwgcXVp ZXQpCisgICAgICAgIHNlbGYuX3Rvb2wuZXhlY3V0aXZlLnJ1bl9hbmRfdGhyb3dfaWZfZmFpbChb cG9ydC5zY3JpcHRfcGF0aChzY3JpcHRfbmFtZSldLCBxdWlldCkKIAogICAgICMgRklYTUU6IFRo ZSBwb3J0IHNob3VsZCBsaXZlIG9uIHRoZSB0b29sLgogICAgIGRlZiBwb3J0KHNlbGYpOgpkaWZm IC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBzL3Bvc3RkaWZm LnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBzL3Bvc3RkaWZmLnB5 CmluZGV4IDZhM2RlZTQuLjgwZGFjY2EgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMv d2Via2l0cHkvdG9vbC9zdGVwcy9wb3N0ZGlmZi5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRz L3dlYmtpdHB5L3Rvb2wvc3RlcHMvcG9zdGRpZmYucHkKQEAgLTI2LDggKzI2LDYgQEAKICMgKElO Q0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBP RiBUSEUgVVNFCiAjIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9T U0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCiAKLWltcG9ydCBTdHJpbmdJTwotCiBmcm9tIHdlYmtp dHB5LnRvb2wuc3RlcHMuYWJzdHJhY3RzdGVwIGltcG9ydCBBYnN0cmFjdFN0ZXAKIGZyb20gd2Vi a2l0cHkudG9vbC5zdGVwcy5vcHRpb25zIGltcG9ydCBPcHRpb25zCiAKQEAgLTQ0LDcgKzQyLDYg QEAgY2xhc3MgUG9zdERpZmYoQWJzdHJhY3RTdGVwKToKIAogICAgIGRlZiBydW4oc2VsZiwgc3Rh dGUpOgogICAgICAgICBkaWZmID0gc2VsZi5jYWNoZWRfbG9va3VwKHN0YXRlLCAiZGlmZiIpCi0g ICAgICAgIGRpZmZfZmlsZSA9IFN0cmluZ0lPLlN0cmluZ0lPKGRpZmYpICMgYWRkX3BhdGNoX3Rv X2J1ZyBleHBlY3RzIGEgZmlsZS1saWtlIG9iamVjdAogICAgICAgICBkZXNjcmlwdGlvbiA9IHNl bGYuX29wdGlvbnMuZGVzY3JpcHRpb24gb3IgIlBhdGNoIgogICAgICAgICBjb21tZW50X3RleHQg PSBOb25lCiAgICAgICAgIGNvZGVyZXZpZXdfaXNzdWUgPSBzdGF0ZS5nZXQoImNvZGVyZXZpZXdf aXNzdWUiKQpAQCAtNTIsNiArNDksNiBAQCBjbGFzcyBQb3N0RGlmZihBYnN0cmFjdFN0ZXApOgog ICAgICAgICAjIGJ1dCBpdCBtYWtlcyBkb2luZyB0aGUgcmlldHZlbGQgaW50ZWdyYXRpb24gYSBs b3QgZWFzaWVyLgogICAgICAgICBpZiBjb2RlcmV2aWV3X2lzc3VlOgogICAgICAgICAgICAgZGVz Y3JpcHRpb24gKz0gIi0lcyIgJSBzdGF0ZVsiY29kZXJldmlld19pc3N1ZSJdCi0gICAgICAgIHNl bGYuX3Rvb2wuYnVncy5hZGRfcGF0Y2hfdG9fYnVnKHN0YXRlWyJidWdfaWQiXSwgZGlmZl9maWxl LCBkZXNjcmlwdGlvbiwgY29tbWVudF90ZXh0PWNvbW1lbnRfdGV4dCwgbWFya19mb3JfcmV2aWV3 PXNlbGYuX29wdGlvbnMucmV2aWV3LCBtYXJrX2Zvcl9jb21taXRfcXVldWU9c2VsZi5fb3B0aW9u cy5yZXF1ZXN0X2NvbW1pdCkKKyAgICAgICAgc2VsZi5fdG9vbC5idWdzLmFkZF9wYXRjaF90b19i dWcoc3RhdGVbImJ1Z19pZCJdLCBkaWZmLCBkZXNjcmlwdGlvbiwgY29tbWVudF90ZXh0PWNvbW1l bnRfdGV4dCwgbWFya19mb3JfcmV2aWV3PXNlbGYuX29wdGlvbnMucmV2aWV3LCBtYXJrX2Zvcl9j b21taXRfcXVldWU9c2VsZi5fb3B0aW9ucy5yZXF1ZXN0X2NvbW1pdCkKICAgICAgICAgaWYgc2Vs Zi5fb3B0aW9ucy5vcGVuX2J1ZzoKICAgICAgICAgICAgIHNlbGYuX3Rvb2wudXNlci5vcGVuX3Vy bChzZWxmLl90b29sLmJ1Z3MuYnVnX3VybF9mb3JfYnVnX2lkKHN0YXRlWyJidWdfaWQiXSkpCmRp ZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvcG9zdGRp ZmZmb3Jjb21taXQucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMv cG9zdGRpZmZmb3Jjb21taXQucHkKaW5kZXggMDNiOWU3OC4uMTNiYzAwYyAxMDA2NDQKLS0tIGEv V2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBzL3Bvc3RkaWZmZm9yY29tbWl0 LnB5CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9zdGVwcy9wb3N0ZGlm ZmZvcmNvbW1pdC5weQpAQCAtMjYsOCArMjYsNiBAQAogIyAoSU5DTFVESU5HIE5FR0xJR0VOQ0Ug T1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKICMgT0YgVEhJ UyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERB TUFHRS4KIAotaW1wb3J0IFN0cmluZ0lPCi0KIGZyb20gd2Via2l0cHkudG9vbC5zdGVwcy5hYnN0 cmFjdHN0ZXAgaW1wb3J0IEFic3RyYWN0U3RlcAogCiAKQEAgLTM1LDcgKzMzLDcgQEAgY2xhc3Mg UG9zdERpZmZGb3JDb21taXQoQWJzdHJhY3RTdGVwKToKICAgICBkZWYgcnVuKHNlbGYsIHN0YXRl KToKICAgICAgICAgc2VsZi5fdG9vbC5idWdzLmFkZF9wYXRjaF90b19idWcoCiAgICAgICAgICAg ICBzdGF0ZVsiYnVnX2lkIl0sCi0gICAgICAgICAgICBTdHJpbmdJTy5TdHJpbmdJTyhzZWxmLmNh Y2hlZF9sb29rdXAoc3RhdGUsICJkaWZmIikpLAorICAgICAgICAgICAgc2VsZi5jYWNoZWRfbG9v a3VwKHN0YXRlLCAiZGlmZiIpLAogICAgICAgICAgICAgIlBhdGNoIGZvciBsYW5kaW5nIiwKICAg ICAgICAgICAgIG1hcmtfZm9yX3Jldmlldz1GYWxzZSwKICAgICAgICAgICAgIG1hcmtfZm9yX2xh bmRpbmc9VHJ1ZSkKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9v bC9zdGVwcy9wb3N0ZGlmZmZvcnJldmVydC5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0 cHkvdG9vbC9zdGVwcy9wb3N0ZGlmZmZvcnJldmVydC5weQppbmRleCAzYjlkYTA0Li5iZmE2MzFm IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvcG9z dGRpZmZmb3JyZXZlcnQucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29s L3N0ZXBzL3Bvc3RkaWZmZm9ycmV2ZXJ0LnB5CkBAIC0yNiw4ICsyNiw2IEBACiAjIChJTkNMVURJ TkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhF IFVTRQogIyBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklM SVRZIE9GIFNVQ0ggREFNQUdFLgogCi1pbXBvcnQgU3RyaW5nSU8KLQogZnJvbSB3ZWJraXRweS5j b21tb24ubmV0LmJ1Z3ppbGxhIGltcG9ydCBBdHRhY2htZW50CiBmcm9tIHdlYmtpdHB5LnRvb2wu c3RlcHMuYWJzdHJhY3RzdGVwIGltcG9ydCBBYnN0cmFjdFN0ZXAKIApAQCAtNDQsNyArNDIsNyBA QCBmb2xsb3dpbmcgY29tbWFuZDpcblxuXAogd2hlcmUgQVRUQUNITUVOVF9JRCBpcyB0aGUgSUQg b2YgdGhpcyBhdHRhY2htZW50LiIKICAgICAgICAgc2VsZi5fdG9vbC5idWdzLmFkZF9wYXRjaF90 b19idWcoCiAgICAgICAgICAgICBzdGF0ZVsiYnVnX2lkIl0sCi0gICAgICAgICAgICBTdHJpbmdJ Ty5TdHJpbmdJTyhzZWxmLmNhY2hlZF9sb29rdXAoc3RhdGUsICJkaWZmIikpLAorICAgICAgICAg ICAgc2VsZi5jYWNoZWRfbG9va3VwKHN0YXRlLCAiZGlmZiIpLAogICAgICAgICAgICAgIiVzJXMi ICUgKEF0dGFjaG1lbnQucm9sbG91dF9wcmVhbWJsZSwgc3RhdGVbInJldmlzaW9uIl0pLAogICAg ICAgICAgICAgY29tbWVudF90ZXh0PWNvbW1lbnRfdGV4dCwKICAgICAgICAgICAgIG1hcmtfZm9y X3Jldmlldz1GYWxzZSwKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkv dG9vbC9zdGVwcy9zdGVwc191bml0dGVzdC5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0 cHkvdG9vbC9zdGVwcy9zdGVwc191bml0dGVzdC5weQppbmRleCA0MGJlZTkwLi41YWJmYzZkIDEw MDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvc3RlcHNf dW5pdHRlc3QucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBz L3N0ZXBzX3VuaXR0ZXN0LnB5CkBAIC00OCw3ICs0OCw4IEBAIGNsYXNzIFN0ZXBzVGVzdCh1bml0 dGVzdC5UZXN0Q2FzZSk6CiAgICAgZGVmIHRlc3RfdXBkYXRlX3N0ZXAoc2VsZik6CiAgICAgICAg IG9wdGlvbnMgPSBNb2NrKCkKICAgICAgICAgb3B0aW9ucy51cGRhdGUgPSBUcnVlCi0gICAgICAg IHNlbGYuX3J1bl9zdGVwKFVwZGF0ZSwgb3B0aW9ucykKKyAgICAgICAgZXhwZWN0ZWRfc3RkZXJy ID0gIlVwZGF0aW5nIHdvcmtpbmcgZGlyZWN0b3J5XG4iCisgICAgICAgIE91dHB1dENhcHR1cmUo KS5hc3NlcnRfb3V0cHV0cyhzZWxmLCBzZWxmLl9ydW5fc3RlcCwgW1VwZGF0ZSwgb3B0aW9uc10s IGV4cGVjdGVkX3N0ZGVycj1leHBlY3RlZF9zdGRlcnIpCiAKICAgICBkZWYgdGVzdF9wcm9tcHRf Zm9yX2J1Z19vcl90aXRsZV9zdGVwKHNlbGYpOgogICAgICAgICB0b29sID0gTW9ja1Rvb2woKQo= 53937 2010-04-21 03:33:19 -0700 2010-04-21 15:47:13 -0700 Fixed to be way more awesome bug-37765-20100421033316.patch text/plain 90720 eric ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxv ZwppbmRleCAwMTdmMmU3Li45YzFkZjU5IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9DaGFuZ2VM b2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDUgKzEsMTM3IEBACiAyMDEwLTA0 LTIxICBFcmljIFNlaWRlbCAgPGVyaWNAd2Via2l0Lm9yZz4KIAorICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBSRUdSRVNTSU9OKDU3NTMxKTogdGhlIGNvbW1p dC1xdWV1ZSBzdGlsbCBoYXRlcyBUb3IgQXJuZSBWZXN0YsO4CisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zNzc2NQorCisgICAgICAgIEkgZml4ZWQgdGhl IHF1ZXVlIHRvIG5vdCBpZ25vcmUgVG9yIGFzIGEgcmV2aXdlciBpbiByNTc1MzEsCisgICAgICAg IGJ1dCBpbnN0ZWFkIGl0IHRocm93cyBhbiBleGNlcHRpb24gZXZlcnkgdGltZSBoaXMgbmFtZSBp cyBpbiBhIHBhdGNoLgorCisgICAgICAgIFRoaXMgZml4ZXMgb3VyIEV4ZWN1dGl2ZS5ydW5fY29t bWFuZCBjb2RlIHRvIHdvcmsgYXJvdW5kIGEgUG9wZW4KKyAgICAgICAgYnVnIGh0dHA6Ly9idWdz LnB5dGhvbi5vcmcvaXNzdWU1MjkwIHdoZXJlYnkgcHl0aG9uIHZlcnNpb25zIGJlZm9yZSAyLjYK KyAgICAgICAgZG8gbm90IGNvcnJlY3RseSBoYW5kbGUgdW5pY29kZSBvYmplY3RzIGFzIGlucHV0 IG9yIG91dHB1dCB0bworICAgICAgICBQb3Blbi5jb21tdW5pY2F0ZS4KKworICAgICAgICBGb2xs b3dpbmcgdGhlIGFkdmljZSBvZjoKKyAgICAgICAgaHR0cDovL2Zhcm1kZXYuY29tL3RhbGtzL3Vu aWNvZGUvCisgICAgICAgIEkgaGF2ZSBjaGFuZ2VkIGFsbCBvZiB3ZWJraXRweSB0byB1c2UgdW5p Y29kZSgpIG9iamVjdHMgYXMgc3RyaW5ncworICAgICAgICBpbnN0ZWFkIG9mIHN0ciBvYmplY3Rz ICh3aGljaCBpbiBQeXRob24gMyBhcmUgcmVuYW1lZCAiYnl0ZXMiKS4KKworICAgICAgICBTdHJp bmcgbGl0ZXJhbHMgd2VyZSBsZWZ0IGFzICJmb28iIGluc3RlYWQgb2YgY29udmVydGluZyB0byB1 ImZvbyIKKyAgICAgICAgYXMgdSJmb28iIGlzIG9ubHkgcmVxdWlyZWQgaWYgdGhlIHN0cmluZyBo YXMgYSBub24tYXNjaWkgY29kZSBwb2ludC4KKyAgICAgICAgUHl0aG9uIGlzIHNtYXJ0IGFib3V0 IGNvbXBhcmluZyBzdHIoKSBhbmQgdW5pY29kZSgpIHZhbHVlcyBhbmQgd2lsbAorICAgICAgICBs b2cgYW4gZXJyb3IgdG8gdGhlIGNvbnNvbGUgaWYgdGhlIGNvbXBhcmlzb24gaXMgZXZlciBpbnZh bGlkLgorCisgICAgICAgIEV4ZWN1dGl2ZS5ydW4qIG5vdyBjb3JyZWN0bHkgYWNjZXB0IGFuZCBy ZXR1cm4gdW5pY29kZSgpIG9iamVjdHMuCisgICAgICAgIEkgYXR0ZW1wdGVkIHRvIGZpeCBhbGwg dGhlIHBsYWNlcyB0aGF0IHdlIGNhbGwgLndyaXRlKCkgdG8gbWFrZSBzdXJlIHdlCisgICAgICAg IGVuY29kZSBhbnkgdW5pY29kZSgpIG9iamVjdHMgaW50byB1dGYtOC4KKworICAgICAgICBJIHJl bW92ZWQgc2V2ZXJhbCB1c2VzIG9mIFN0cmluZ0lPLiAgU3RyaW5nSU8gc2hvdWxkIGdlbmVyYWxs eSBhbHdheXMgYmUKKyAgICAgICAgcGFzc2VkIGEgdW5pY29kZSgpIHZhbHVlLgorCisgICAgICAg IExpa2V3aXNlIEkgcmVwbGFjZWQgbW9zdCBjYWxscyB0byBvcGVuKCkgd2l0aCBjb2RlY3Mub3Bl bigpLgorICAgICAgICBjb2RlY3Mub3BlbigpIG1hdGNoZXMgUHl0aG9uIDMgb3BlbiBzZW1hbnRp Y3MgaW4gcmVxdWlyaW5nIGFuIGVuY29kaW5nCisgICAgICAgIHBhcmFtZXRlci4gIEZpbGVzIG9w ZW5lZCB3aXRoIGNvZGVjcy5vcGVuKCkgd2l0aCBhIHVuaWNvZGUtY29tcGF0aWJsZQorICAgICAg ICBlbmNvZGluZyB3aWxsIHZlbmQgdW5pY29kZSgpIG9iamVjdHMgZnJvbSB0aGVpciByZWFkKCkg Y2FsbHMsIGxpa2UgaG93CisgICAgICAgIFN0cmluZ0lPIGNyZWF0ZWQgd2l0aCBhIHVuaWNvZGUo KSBvYmplY3Qgd2lsbCBkby4KKworICAgICAgICBJIGFsc28gZGVwbG95ZWQgIndpdGgiIHN0YXRl bWVudHMgd2lkZXIgKG5vdyB0aGF0IHRoZSBwcm9qZWN0IGhhcworICAgICAgICBzZXR0bGVkIG9u IFB5dGhvbiAyLjUpIHRvIGNsb3NlIGEgYnVuY2ggb2YgZmlsZSBkZXNjcmlwdG9yIGxlYWtzLgor CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvYXBpX3VuaXR0ZXN0 LnB5OgorICAgICAgICAgLSBSZWFkL3dyaXRlIHV0Zi04IGZpbGVzIGluc3RlYWQgb2YgYXNjaWku CisgICAgICAgICAtIFVwZGF0ZSB0aGUgdGVzdHMgdG8gdXNlIHRlc3QgZm9yIHByb3BlciB1bmlj b2RlKCkgaGFuZGxpbmcuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tv dXQvY2hhbmdlbG9nLnB5OgorICAgICAgICAgLSBEb2N1bWVudCB0aGF0IHBhcnNlX2xhdGVzdF9l bnRyeV9mcm9tX2ZpbGUgZXhwZWN0cworICAgICAgICAgICBmaWxlLWxpa2Ugb2JqZWN0cyB3aGlj aCByZXR1cm4gdW5pY29kZSBzdHJpbmdzLgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvY29t bW9uL2NoZWNrb3V0L2NoYW5nZWxvZ191bml0dGVzdC5weToKKyAgICAgICAgIC0gVXNlIHVuaWNv ZGUoKSBzdHJpbmdzIGluc3RlYWQgb2Ygc3RyKCkgYnl0ZSBhcnJheXMuCisgICAgICAgICAtIERl cGxveSAid2l0aCIgdG8gY2xvc2UgZmlsZSBkZXNjcmlwdG9yIGxlYWtzLgorICAgICAgICAqIFNj cmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L2NvbW1pdGluZm8ucHk6CisgICAgICAgICAt IFJlbW92ZSB1bm5lZWRlZCBpbXBvcnQuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9jb21t b24vY2hlY2tvdXQvc2NtLnB5OgorICAgICAgICAgLSBSZW1vdmUgdXNlIG9mIHN0cigpLgorICAg ICAgICAqIFNjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3NjbV91bml0dGVzdC5weToK KyAgICAgICAgIC0gUmVhZC93cml0ZSB1dGYtOCBmaWxlcyBhbmQgdXNlIHVuaWNvZGUoKSBzdHJp bmdzIGluIHRlc3RpbmcuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9jb21tb24vY29uZmln L2NvbW1pdHRlcnMucHk6CisgICAgICAgICAtIFVzZSBcdSBpbnN0ZWFkIG9mIFx4IHRvIG1ha2Ug c2xpZ2h0bHkgY2xlYXJlciB3aGF0IHdlJ3JlIGRvaW5nLgorICAgICAgICAqIFNjcmlwdHMvd2Vi a2l0cHkvY29tbW9uL25ldC9idWd6aWxsYS5weToKKyAgICAgICAgIC0gQWRkIGEgbmV3IF9zdHJp bmdfY29udGVudHMoKSBtZXRob2QgYW5kIGV4cGxhaW4gd2h5CisgICAgICAgICAgICB3ZSBoYXZl IHRvIGNhbGwgdW5pY29kZSgpIG9uIHRoZSByZXN1bHQgb2Ygc291cC5zdHJpbmcKKyAgICAgICAg ICAgIGFuZCB3aHkgaXQncyBzYWZlIHRvIGRvIHNvIHcvbyBuZWVkaW5nIHRvIHBhc3MgYSBjb2Rl YyBuYW1lLgorICAgICAgICAgIC0gUmVtb3ZlIHRoZSAodW51c2VkKSBzdXBwb3J0IGZvciBwYXNz aW5nIGEgZmlsZSBvYmplY3QgdG8gYWRkX3BhdGNoX3RvX2J1ZygpLgorICAgICAgICAqIFNjcmlw dHMvd2Via2l0cHkvY29tbW9uL25ldC9idWlsZGJvdC5weToKKyAgICAgICAgIC0gVXNlIHVuaWNv ZGUoKSBpbnN0ZWFkIG9mIHN0cigpIHdoZW4gbmVlZGluZyB0byBjb2F4IGEKKyAgICAgICAgICAg IE5hdmlnYWJsZVN0cmluZyBvYmplY3QgaW50byBhIHVuaWNvZGUoKSBvYmplY3QuCisgICAgICAg ICogU2NyaXB0cy93ZWJraXRweS9jb21tb24vbmV0L2J1aWxkYm90X3VuaXR0ZXN0LnB5OgorICAg ICAgICAgLSBBZGQgYSB0ZXN0IHdoaWNoIGNvbnRhaW5zIGEgdW5pY29kZSBidWlsZGVyIG5hbWUu CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9jb21tb24vbmV0L3N0YXR1c3NlcnZlci5weToK KyAgICAgICAgIC0gUmVtb3ZlIHVzZSBvZiBzdHIoKQorICAgICAgICAqIFNjcmlwdHMvd2Via2l0 cHkvY29tbW9uL3ByZXR0eXBhdGNoLnB5OgorICAgICAgICAgLSBXcml0ZSBvdXQgdGhlIHBhdGNo IGZpbGUgYXMgdXRmLTguCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9jb21tb24vc3lzdGVt L2F1dG9pbnN0YWxsLnB5OgorICAgICAgICAgLSBXcml0ZSBvdXQgZmlsZXMgd2l0aCBhIGV4cGxp Y2l0IGVuY29kaW5ncy4KKyAgICAgICAgIC0gRGVwbG95ICJ3aXRoIiB0byBjbG9zZSBmaWxlIGRl c2NyaXB0b3IgbGVha3MuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9jb21tb24vc3lzdGVt L2RlcHJlY2F0ZWRfbG9nZ2luZy5weToKKyAgICAgICAgIC0gV3JpdGUgb3V0IGxvZyBmaWxlcyBh cyB1dGYtOC4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9zeXN0ZW0vZXhlY3V0 aXZlLnB5OgorICAgICAgICAgLSBNYWtlIHJ1biogcHJvcGVybHkgdGFrZSBhbmQgcmV0dXJuIHVu aWNvZGUoKSBvYmplY3RzLgorICAgICAgICAgLSBDbGVhbmVkIHVwIGlucHV0IGhhbmRsaW5nIGlu IHJ1bl9jb21tYW5kIGEgbGl0dGxlIGJ5IGFkZGluZworICAgICAgICAgICBhIF9jb21wdXRlX2lu cHV0KCkgbWV0aG9kIHdoaWNoIGNhbiByZXR1cm4gZWFybHkgaW5zdGVhZCBvZiBoYXZpbmcKKyAg ICAgICAgICAgc3VjaCBhIGxvbmcvY2x1dHRlcmVkIGlmLWJsb2NrLgorICAgICAgICAqIFNjcmlw dHMvd2Via2l0cHkvY29tbW9uL3N5c3RlbS9leGVjdXRpdmVfdW5pdHRlc3QucHk6CisgICAgICAg ICAtIEFkZGVkIGEgdW5pdCB0ZXN0IHRvIG1ha2Ugc3VyZSB3ZSBkb24ndCBicmVhayBUb3IgYWdh aW4hCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvbGF5b3V0X3BhY2th Z2UvZHVtcF9yZW5kZXJfdHJlZV90aHJlYWQucHk6CisgICAgICAgICAtIFdyaXRlIG91dCB0aGUg dGVzdCBsaXN0IGFzIHV0Zi04LgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rl c3RzL2xheW91dF9wYWNrYWdlL2pzb25fcmVzdWx0c19nZW5lcmF0b3IucHk6CisgICAgICAgICAt IFdyaXRlIG91dCBqc29uIGZpbGVzIGFzIHV0Zi04LgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0 cHkvbGF5b3V0X3Rlc3RzL3BvcnQvYXBhY2hlX2h0dHBfc2VydmVyLnB5OgorICAgICAgICAgLSBE ZXBsb3kgIndpdGgiIHRvIGNsb3NlIGZpbGUgZGVzY3JpcHRvciBsZWFrcy4KKyAgICAgICAgKiBT Y3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtLnB5OiBBZGQgRXhlY3V0 aXZlLnB5IEZJWE1FLgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3Bv cnQvY2hyb21pdW1fbGludXgucHk6IGRpdHRvLgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkv bGF5b3V0X3Rlc3RzL3BvcnQvY2hyb21pdW1fbWFjLnB5OiBkaXR0by4KKyAgICAgICAgKiBTY3Jp cHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2d0ay5weTogZGl0dG8uCisgICAgICAgICog U2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9tYWMucHk6IGRpdHRvLgorICAgICAg ICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvbWFjX3VuaXR0ZXN0LnB5Ogor ICAgICAgICAgLSBNYWtlIHRoZSBza2lwcGVkIGZpbGUgcGFyc2luZyB0ZXN0IHVuaWNvZGUuCisg ICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9xdC5weTogQWRkIEV4 ZWN1dGl2ZS5weSBGSVhNRS4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0 cy9wb3J0L3NlcnZlcl9wcm9jZXNzLnB5OiBkaXR0by4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy9wb3J0L3dlYmtpdC5weToKKyAgICAgICAgIC0gRGVwbG95ICJ3aXRo IiB0byBjbG9zZSBmaWxlIGRlc2NyaXB0b3IgbGVha3MuCisgICAgICAgICogU2NyaXB0cy93ZWJr aXRweS9sYXlvdXRfdGVzdHMvcG9ydC93ZWJzb2NrZXRfc2VydmVyLnB5OgorICAgICAgICAgLSBN YWtlIGV4cGxpY2l0IHRoZSBlbmNvZGluZ3Mgb2YgbG9nIGZpbGVzIGFuZCBwaWQgZmlsZXMuCisg ICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcmViYXNlbGluZV9jaHJvbWl1 bV93ZWJraXRfdGVzdHMucHk6CisgICAgICAgICAtIE1ha2UgZW5jb2RpbmdzIGV4cGxpY2l0IGFu ZCBkZXBsb3kgIndpdGgiLgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3Rz L3J1bl93ZWJraXRfdGVzdHMucHk6IGRpdHRvLgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkv bGF5b3V0X3Rlc3RzL3Rlc3RfdHlwZXMvaW1hZ2VfZGlmZi5weTogZGl0dG8uCisgICAgICAgICog U2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvdGVzdF90eXBlcy90ZXN0X3R5cGVfYmFzZS5w eTogZGl0dG8uCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvdGVzdF90 eXBlcy90ZXh0X2RpZmYucHk6IGRpdHRvLgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvc3R5 bGUvZmlsZXJlYWRlcl91bml0dGVzdC5weTogZGl0dG8uCisgICAgICAgICogU2NyaXB0cy93ZWJr aXRweS90aGlyZHBhcnR5L19faW5pdF9fLnB5OiBkaXR0by4KKyAgICAgICAgKiBTY3JpcHRzL3dl YmtpdHB5L3Rvb2wvY29tbWFuZHMvZWFybHl3YXJuaW5nc3lzdGVtLnB5OgorICAgICAgICAgLSBS ZW1vdmVkIGV4dHJhIGltcG9ydC4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29t bWFuZHMvcXVldWVzLnB5OgorICAgICAgICAgLSBObyBuZWVkIHRvIG1hcCBhcmdzIHRvIHN0cmlu Z3Mgbm93IHRoYXQgcnVuX2NvbW1hbmQgZG9lcy4KKyAgICAgICAgIC0gVXBkYXRlIHRlc3QgcmVz dWx0cyB0byBtYXRjaCBhcmdzIGNoYW5nZXMuCisgICAgICAgICAtIERvY3VtZW50IG91ciBnbG9i YWwgYXJndW1lbnQgaGFja3MuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS90b29sL2NvbW1h bmRzL3VwbG9hZC5weToKKyAgICAgICAgIC0gUGFzcyB0aGUgZGlmZiBkaXJlY3RseSB0byBhZGRf cGF0Y2hfdG9fYnVnIGluc3RlYWQgb2YgY3JlYXRpbmcgYSBTdHJpbmdJTyBmaWxlIHdyYXBwZXIu CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS90b29sL21vY2t0b29sLnB5OgorICAgICAgICAg LSBSZW5hbWUgYWRkX3BhdGNoX3RvX2J1ZyBhcmd1bWVudCB0byBtYXRjaCBidWd6aWxsYS5weQor ICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvdG9vbC9zdGVwcy9hYnN0cmFjdHN0ZXAucHk6Cisg ICAgICAgICAtIEV4ZWN1dGl2ZS5ydW5fKiBub3cgcmVxdWlyZSBsaXN0cyBpbnN0ZWFkIG9mIHN0 cmluZ3MuCisgICAgICAgICAgIFRoZSBsYWNrIG9mIHRoaXMgY2hhbmdlIHdhcyB3aGF0IGJyb2tl IHdlYmtpdC1wYXRjaAorICAgICAgICAgICBmb3Igc3ZuIHVzZXJzIHRoZSBmaXJzdCB0aW1lIHRo aXMgd2FzIGxhbmRlZC4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvcG9z dGRpZmYucHk6CisgICAgICAgICAtIFBhc3MgdGhlIGRpZmYgZGlyZWN0bHkgdG8gYWRkX3BhdGNo X3RvX2J1ZyBpbnN0ZWFkIG9mIGNyZWF0aW5nIGEgU3RyaW5nSU8gZmlsZSB3cmFwcGVyLgorICAg ICAgICAqIFNjcmlwdHMvd2Via2l0cHkvdG9vbC9zdGVwcy9wb3N0ZGlmZmZvcmNvbW1pdC5weTog ZGl0dG8KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvcG9zdGRpZmZmb3Jy ZXZlcnQucHk6IGRpdHRvCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBzL3N0 ZXBzX3VuaXR0ZXN0LnB5OgorICAgICAgICAgLSBGaXhlZCBzcHVyaW91cyBsb2dnaW5nIHNlZW4g d2hlbiBydW5uaW5nIHRlc3Qtd2Via2l0cHkKKworMjAxMC0wNC0yMSAgRXJpYyBTZWlkZWwgIDxl cmljQHdlYmtpdC5vcmc+CisKICAgICAgICAgVW5yZXZpZXdlZCwgdGVzdCBmaXggb25seS4KIAog ICAgICAgICBuZXctcnVuLXdlYmtpdC10ZXN0czogaW1wbGVtZW50IGEgLS1sb2cgdHJhY2UgbWVz c2FnZSB0byBiZSBhYmxlIHRvIGRpc3BsYXkgZGV0YWlsZWQgb3V0cHV0IG9mIGFuIGluZGl2aWR1 YWwgdGVzdCBydW4KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29t bW9uL2NoZWNrb3V0L2FwaV91bml0dGVzdC5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0 cHkvY29tbW9uL2NoZWNrb3V0L2FwaV91bml0dGVzdC5weQppbmRleCBlOTljYWVlLi41ZWIxNDY5 IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291 dC9hcGlfdW5pdHRlc3QucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21t b24vY2hlY2tvdXQvYXBpX3VuaXR0ZXN0LnB5CkBAIC0yNiw2ICsyNiw5IEBACiAjIChJTkNMVURJ TkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhF IFVTRQogIyBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklM SVRZIE9GIFNVQ0ggREFNQUdFLgogCitmcm9tIF9fZnV0dXJlX18gaW1wb3J0IHdpdGhfc3RhdGVt ZW50CisKK2ltcG9ydCBjb2RlY3MKIGltcG9ydCBvcwogaW1wb3J0IHNodXRpbAogaW1wb3J0IHRl bXBmaWxlCkBAIC0zNywxNCArNDAsMTQgQEAgZnJvbSB3ZWJraXRweS5jb21tb24uY2hlY2tvdXQu c2NtIGltcG9ydCBkZXRlY3Rfc2NtX3N5c3RlbSwgQ29tbWl0TWVzc2FnZQogZnJvbSB3ZWJraXRw eS5jb21tb24uc3lzdGVtLm91dHB1dGNhcHR1cmUgaW1wb3J0IE91dHB1dENhcHR1cmUKIGZyb20g d2Via2l0cHkudGhpcmRwYXJ0eS5tb2NrIGltcG9ydCBNb2NrCiAKKwogIyBGSVhNRTogQ29waWVk IGZyb20gc2NtX3VuaXR0ZXN0LnB5Ci1kZWYgd3JpdGVfaW50b19maWxlX2F0X3BhdGgoZmlsZV9w YXRoLCBjb250ZW50cyk6Ci0gICAgbmV3X2ZpbGUgPSBvcGVuKGZpbGVfcGF0aCwgJ3cnKQotICAg IG5ld19maWxlLndyaXRlKGNvbnRlbnRzKQotICAgIG5ld19maWxlLmNsb3NlKCkKK2RlZiB3cml0 ZV9pbnRvX2ZpbGVfYXRfcGF0aChmaWxlX3BhdGgsIGNvbnRlbnRzLCBlbmNvZGluZz0idXRmLTgi KToKKyAgICB3aXRoIGNvZGVjcy5vcGVuKGZpbGVfcGF0aCwgInciLCBlbmNvZGluZykgYXMgZmls ZToKKyAgICAgICAgZmlsZS53cml0ZShjb250ZW50cykKIAogCi1fY2hhbmdlbG9nMWVudHJ5MSA9 ICIiIjIwMTAtMDMtMjUgIEVyaWMgU2VpZGVsICA8ZXJpY0B3ZWJraXQub3JnPgorX2NoYW5nZWxv ZzFlbnRyeTEgPSB1IiIiMjAxMC0wMy0yNSAgVG9yIEFybmUgVmVzdGJcdTAwZjggIDx2ZXN0Ym9A d2Via2l0Lm9yZz4KIAogICAgICAgICBVbnJldmlld2VkIGJ1aWxkIGZpeCB0byB1bi1icmVhayB3 ZWJraXQtcGF0Y2ggbGFuZC4KIApAQCAtNTMsNyArNTYsNyBAQCBfY2hhbmdlbG9nMWVudHJ5MSA9 ICIiIjIwMTAtMDMtMjUgIEVyaWMgU2VpZGVsICA8ZXJpY0B3ZWJraXQub3JnPgogCiAgICAgICAg ICogU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvYXBpLnB5OiBpbXBvcnQgc2NtLkNv bW1pdE1lc3NhZ2UKICIiIgotX2NoYW5nZWxvZzFlbnRyeTIgPSAiIiIyMDEwLTAzLTI1ICBBZGFt IEJhcnRoICA8YWJhcnRoQHdlYmtpdC5vcmc+CitfY2hhbmdlbG9nMWVudHJ5MiA9IHUiIiIyMDEw LTAzLTI1ICBBZGFtIEJhcnRoICA8YWJhcnRoQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3 ZWQgYnkgRXJpYyBTZWlkZWwuCiAKQEAgLTYyLDggKzY1LDggQEAgX2NoYW5nZWxvZzFlbnRyeTIg PSAiIiIyMDEwLTAzLTI1ICBBZGFtIEJhcnRoICA8YWJhcnRoQHdlYmtpdC5vcmc+CiAKICAgICAg ICAgKiBTY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9hcGkucHk6CiAiIiIKLV9jaGFu Z2Vsb2cxID0gIlxuIi5qb2luKFtfY2hhbmdlbG9nMWVudHJ5MSwgX2NoYW5nZWxvZzFlbnRyeTJd KQotX2NoYW5nZWxvZzIgPSAiIiIyMDEwLTAzLTI1ICBFcmljIFNlaWRlbCAgPGVyaWNAd2Via2l0 Lm9yZz4KK19jaGFuZ2Vsb2cxID0gdSJcbiIuam9pbihbX2NoYW5nZWxvZzFlbnRyeTEsIF9jaGFu Z2Vsb2cxZW50cnkyXSkKK19jaGFuZ2Vsb2cyID0gdSIiIjIwMTAtMDMtMjUgIFRvciBBcm5lIFZl c3RiXHUwMGY4ICA8dmVzdGJvQHdlYmtpdC5vcmc+CiAKICAgICAgICAgVW5yZXZpZXdlZCBidWls ZCBmaXggdG8gdW4tYnJlYWsgd2Via2l0LXBhdGNoIGxhbmQuCiAKQEAgLTc5LDcgKzgyLDcgQEAg X2NoYW5nZWxvZzIgPSAiIiIyMDEwLTAzLTI1ICBFcmljIFNlaWRlbCAgPGVyaWNAd2Via2l0Lm9y Zz4KICIiIgogCiBjbGFzcyBDb21taXRNZXNzYWdlRm9yVGhpc0NvbW1pdFRlc3QodW5pdHRlc3Qu VGVzdENhc2UpOgotICAgIGV4cGVjdGVkX2NvbW1pdF9tZXNzYWdlID0gIiIiMjAxMC0wMy0yNSAg RXJpYyBTZWlkZWwgIDxlcmljQHdlYmtpdC5vcmc+CisgICAgZXhwZWN0ZWRfY29tbWl0X21lc3Nh Z2UgPSB1IiIiMjAxMC0wMy0yNSAgVG9yIEFybmUgVmVzdGJcdTAwZjggIDx2ZXN0Ym9Ad2Via2l0 Lm9yZz4KIAogICAgICAgICBVbnJldmlld2VkIGJ1aWxkIGZpeCB0byB1bi1icmVhayB3ZWJraXQt cGF0Y2ggbGFuZC4KIApAQCAtODcsNyArOTAsNyBAQCBjbGFzcyBDb21taXRNZXNzYWdlRm9yVGhp c0NvbW1pdFRlc3QodW5pdHRlc3QuVGVzdENhc2UpOgogICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzY2MjkKIAogICAgICAgICAqIFNjcmlwdHMvd2Via2l0 cHkvY29tbW9uL2NoZWNrb3V0L2FwaS5weTogaW1wb3J0IHNjbS5Db21taXRNZXNzYWdlCi0yMDEw LTAzLTI1ICBFcmljIFNlaWRlbCAgPGVyaWNAd2Via2l0Lm9yZz4KKzIwMTAtMDMtMjUgIFRvciBB cm5lIFZlc3RiXHUwMGY4ICA8dmVzdGJvQHdlYmtpdC5vcmc+CiAKICAgICAgICAgVW5yZXZpZXdl ZCBidWlsZCBmaXggdG8gdW4tYnJlYWsgd2Via2l0LXBhdGNoIGxhbmQuCiAKQEAgLTEzNyw4ICsx NDAsOCBAQCBjbGFzcyBDaGVja291dFRlc3QodW5pdHRlc3QuVGVzdENhc2UpOgogICAgICAgICBj aGVja291dC5jaGFuZ2Vsb2dfZW50cmllc19mb3JfcmV2aXNpb24gPSBsYW1iZGEgcmV2aXNpb246 IFtDaGFuZ2VMb2dFbnRyeShfY2hhbmdlbG9nMWVudHJ5MSldCiAgICAgICAgIGNvbW1pdGluZm8g PSBjaGVja291dC5jb21taXRfaW5mb19mb3JfcmV2aXNpb24oNCkKICAgICAgICAgc2VsZi5hc3Nl cnRFcXVhbChjb21taXRpbmZvLmJ1Z19pZCgpLCAzNjYyOSkKLSAgICAgICAgc2VsZi5hc3NlcnRF cXVhbChjb21taXRpbmZvLmF1dGhvcl9uYW1lKCksICJFcmljIFNlaWRlbCIpCi0gICAgICAgIHNl bGYuYXNzZXJ0RXF1YWwoY29tbWl0aW5mby5hdXRob3JfZW1haWwoKSwgImVyaWNAd2Via2l0Lm9y ZyIpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoY29tbWl0aW5mby5hdXRob3JfbmFtZSgpLCB1 IlRvciBBcm5lIFZlc3RiXHUwMGY4IikKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChjb21taXRp bmZvLmF1dGhvcl9lbWFpbCgpLCAidmVzdGJvQHdlYmtpdC5vcmciKQogICAgICAgICBzZWxmLmFz c2VydEVxdWFsKGNvbW1pdGluZm8ucmV2aWV3ZXJfdGV4dCgpLCBOb25lKQogICAgICAgICBzZWxm LmFzc2VydEVxdWFsKGNvbW1pdGluZm8ucmV2aWV3ZXIoKSwgTm9uZSkKICAgICAgICAgc2VsZi5h c3NlcnRFcXVhbChjb21taXRpbmZvLmNvbW1pdHRlcl9lbWFpbCgpLCAiY29tbWl0dGVyQGV4YW1w bGUuY29tIikKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9u L2NoZWNrb3V0L2NoYW5nZWxvZy5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29t bW9uL2NoZWNrb3V0L2NoYW5nZWxvZy5weQppbmRleCBlOTM4OTZmLi42MjIwZmJkIDEwMDY0NAot LS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9jaGFuZ2Vs b2cucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQv Y2hhbmdlbG9nLnB5CkBAIC05OSwxMCArOTksMTQgQEAgY2xhc3MgQ2hhbmdlTG9nKG9iamVjdCk6 CiAKICAgICBAc3RhdGljbWV0aG9kCiAgICAgZGVmIHBhcnNlX2xhdGVzdF9lbnRyeV9mcm9tX2Zp bGUoY2hhbmdlbG9nX2ZpbGUpOgorICAgICAgICAiIiJjaGFuZ2Vsb2dfZmlsZSBtdXN0IGJlIGEg ZmlsZS1saWtlIG9iamVjdCB3aGljaCByZXR1cm5zCisgICAgICAgIHVuaWNvZGUgc3RyaW5ncy4g IFVzZSBjb2RlY3Mub3BlbiBvciBTdHJpbmdJTyh1bmljb2RlKCkpCisgICAgICAgIHRvIHBhc3Mg ZmlsZSBvYmplY3RzIHRvIHRoaXMgY2xhc3MuIiIiCiAgICAgICAgIGRhdGVfbGluZV9yZWdleHAg PSByZS5jb21waWxlKENoYW5nZUxvZ0VudHJ5LmRhdGVfbGluZV9yZWdleHApCiAgICAgICAgIGVu dHJ5X2xpbmVzID0gW10KICAgICAgICAgIyBUaGUgZmlyc3QgbGluZSBzaG91bGQgYmUgYSBkYXRl IGxpbmUuCiAgICAgICAgIGZpcnN0X2xpbmUgPSBjaGFuZ2Vsb2dfZmlsZS5yZWFkbGluZSgpCisg ICAgICAgIGFzc2VydChpc2luc3RhbmNlKGZpcnN0X2xpbmUsIHVuaWNvZGUpKQogICAgICAgICBp ZiBub3QgZGF0ZV9saW5lX3JlZ2V4cC5tYXRjaChmaXJzdF9saW5lKToKICAgICAgICAgICAgIHJl dHVybiBOb25lCiAgICAgICAgIGVudHJ5X2xpbmVzLmFwcGVuZChmaXJzdF9saW5lKQpkaWZmIC0t Z2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvY2hhbmdl bG9nX3VuaXR0ZXN0LnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hl Y2tvdXQvY2hhbmdlbG9nX3VuaXR0ZXN0LnB5CmluZGV4IDkyMTBjOWMuLjg2NDQyOGEgMTAwNjQ0 Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L2NoYW5n ZWxvZ191bml0dGVzdC5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1v bi9jaGVja291dC9jaGFuZ2Vsb2dfdW5pdHRlc3QucHkKQEAgLTI2LDkgKzI2LDEyIEBACiAjIChJ TkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQg T0YgVEhFIFVTRQogIyBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBP U1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgogCi1pbXBvcnQgdW5pdHRlc3QKK2Zyb20gX19mdXR1 cmVfXyBpbXBvcnQgd2l0aF9zdGF0ZW1lbnQKKworaW1wb3J0IGNvZGVjcwogaW1wb3J0IG9zCiBp bXBvcnQgdGVtcGZpbGUKK2ltcG9ydCB1bml0dGVzdAogCiBmcm9tIFN0cmluZ0lPIGltcG9ydCBT dHJpbmdJTwogCkBAIC01Miw3ICs1NSw3IEBAIGNsYXNzIENoYW5nZUxvZ3NUZXN0KHVuaXR0ZXN0 LlRlc3RDYXNlKToKICcnJwogCiAgICAgIyBNb3JlIGV4YW1wbGUgdGV4dCB0aGFuIHdlIG5lZWQu ICBFdmVudHVhbGx5IHdlIG5lZWQgdG8gc3VwcG9ydCBwYXJzaW5nIHRoaXMgYWxsIGFuZCB3cml0 ZSB0ZXN0cyBmb3IgdGhlIHBhcnNpbmcuCi0gICAgX2V4YW1wbGVfY2hhbmdlbG9nID0gJycnMjAw OS0wOC0xNyAgRGF2aWQgS2lsemVyICA8ZGRraWx6ZXJAYXBwbGUuY29tPgorICAgIF9leGFtcGxl X2NoYW5nZWxvZyA9IHUiIiIyMDA5LTA4LTE3ICBUb3IgQXJuZSBWZXN0Ylx4ZjggIDx2ZXN0Ym9A d2Via2l0Lm9yZz4KIAogICAgICAgICA8aHR0cDovL3dlYmtpdC5vcmcvYi8yODM5Mz4gY2hlY2st d2Via2l0LXN0eWxlOiBhZGQgY2hlY2sgZm9yIHVzZSBvZiBzdGQ6Om1heCgpL3N0ZDo6bWluKCkg aW5zdGVhZCBvZiBNQVgoKS9NSU4oKQogCkBAIC04NCwxMCArODcsMTAgQEAgY2xhc3MgQ2hhbmdl TG9nc1Rlc3QodW5pdHRlc3QuVGVzdENhc2UpOgogICAgICAgICBzbyB3ZSBjYW4ndCBhc3NlcnQg aGVyZS4KIAogPT0gUm9sbGVkIG92ZXIgdG8gQ2hhbmdlTG9nLTIwMDktMDYtMTYgPT0KLScnJwor IiIiCiAKICAgICBkZWYgdGVzdF9sYXRlc3RfZW50cnlfcGFyc2Uoc2VsZik6Ci0gICAgICAgIGNo YW5nZWxvZ19jb250ZW50cyA9ICIlc1xuJXMiICUgKHNlbGYuX2V4YW1wbGVfZW50cnksIHNlbGYu X2V4YW1wbGVfY2hhbmdlbG9nKQorICAgICAgICBjaGFuZ2Vsb2dfY29udGVudHMgPSB1IiVzXG4l cyIgJSAoc2VsZi5fZXhhbXBsZV9lbnRyeSwgc2VsZi5fZXhhbXBsZV9jaGFuZ2Vsb2cpCiAgICAg ICAgIGNoYW5nZWxvZ19maWxlID0gU3RyaW5nSU8oY2hhbmdlbG9nX2NvbnRlbnRzKQogICAgICAg ICBsYXRlc3RfZW50cnkgPSBDaGFuZ2VMb2cucGFyc2VfbGF0ZXN0X2VudHJ5X2Zyb21fZmlsZShj aGFuZ2Vsb2dfZmlsZSkKICAgICAgICAgc2VsZi5hc3NlcnRFcXVhbHMobGF0ZXN0X2VudHJ5LmNv bnRlbnRzKCksIHNlbGYuX2V4YW1wbGVfZW50cnkpCkBAIC05NywxOSArMTAwLDE3IEBAIGNsYXNz IENoYW5nZUxvZ3NUZXN0KHVuaXR0ZXN0LlRlc3RDYXNlKToKICAgICAgICAgc2VsZi5hc3NlcnRU cnVlKGxhdGVzdF9lbnRyeS5yZXZpZXdlcigpKSAgIyBNYWtlIHN1cmUgdGhhdCBvdXIgVVRGOC1i YXNlZCBsb29rdXAgb2YgVG9yIHdvcmtzLgogCiAgICAgQHN0YXRpY21ldGhvZAotICAgIGRlZiBf d3JpdGVfdG1wX2ZpbGVfd2l0aF9jb250ZW50cyhjb250ZW50cyk6CisgICAgZGVmIF93cml0ZV90 bXBfZmlsZV93aXRoX2NvbnRlbnRzKGJ5dGVfYXJyYXkpOgorICAgICAgICBhc3NlcnQoaXNpbnN0 YW5jZShieXRlX2FycmF5LCBzdHIpKQogICAgICAgICAoZmlsZV9kZXNjcmlwdG9yLCBmaWxlX3Bh dGgpID0gdGVtcGZpbGUubWtzdGVtcCgpICMgTmFtZWRUZW1wb3JhcnlGaWxlIGFsd2F5cyBkZWxl dGVzIHRoZSBmaWxlIG9uIGNsb3NlIGluIHB5dGhvbiA8IDIuNgotICAgICAgICBmaWxlID0gb3Mu ZmRvcGVuKGZpbGVfZGVzY3JpcHRvciwgJ3cnKQotICAgICAgICBmaWxlLndyaXRlKGNvbnRlbnRz KQotICAgICAgICBmaWxlLmNsb3NlKCkKKyAgICAgICAgd2l0aCBvcy5mZG9wZW4oZmlsZV9kZXNj cmlwdG9yLCAidyIpIGFzIGZpbGU6CisgICAgICAgICAgICBmaWxlLndyaXRlKGJ5dGVfYXJyYXkp CiAgICAgICAgIHJldHVybiBmaWxlX3BhdGgKIAogICAgIEBzdGF0aWNtZXRob2QKLSAgICBkZWYg X3JlYWRfZmlsZV9jb250ZW50cyhmaWxlX3BhdGgpOgotICAgICAgICBmaWxlID0gb3BlbihmaWxl X3BhdGgpCi0gICAgICAgIGNvbnRlbnRzID0gZmlsZS5yZWFkKCkKLSAgICAgICAgZmlsZS5jbG9z ZSgpCi0gICAgICAgIHJldHVybiBjb250ZW50cworICAgIGRlZiBfcmVhZF9maWxlX2NvbnRlbnRz KGZpbGVfcGF0aCwgZW5jb2RpbmcpOgorICAgICAgICB3aXRoIGNvZGVjcy5vcGVuKGZpbGVfcGF0 aCwgInIiLCBlbmNvZGluZykgYXMgZmlsZToKKyAgICAgICAgICAgIHJldHVybiBmaWxlLnJlYWQo KQogCiAgICAgX25ld19lbnRyeV9ib2lsZXJwbGF0ZSA9ICcnJzIwMDktMDgtMTkgIEVyaWMgU2Vp ZGVsICA8ZXJpY0B3ZWJraXQub3JnPgogCkBAIC0xMjEsMTEgKzEyMiwxMSBAQCBjbGFzcyBDaGFu Z2VMb2dzVGVzdCh1bml0dGVzdC5UZXN0Q2FzZSk6CiAnJycKIAogICAgIGRlZiB0ZXN0X3NldF9y ZXZpZXdlcihzZWxmKToKLSAgICAgICAgY2hhbmdlbG9nX2NvbnRlbnRzID0gIiVzXG4lcyIgJSAo c2VsZi5fbmV3X2VudHJ5X2JvaWxlcnBsYXRlLCBzZWxmLl9leGFtcGxlX2NoYW5nZWxvZykKLSAg ICAgICAgY2hhbmdlbG9nX3BhdGggPSBzZWxmLl93cml0ZV90bXBfZmlsZV93aXRoX2NvbnRlbnRz KGNoYW5nZWxvZ19jb250ZW50cykKKyAgICAgICAgY2hhbmdlbG9nX2NvbnRlbnRzID0gdSIlc1xu JXMiICUgKHNlbGYuX25ld19lbnRyeV9ib2lsZXJwbGF0ZSwgc2VsZi5fZXhhbXBsZV9jaGFuZ2Vs b2cpCisgICAgICAgIGNoYW5nZWxvZ19wYXRoID0gc2VsZi5fd3JpdGVfdG1wX2ZpbGVfd2l0aF9j b250ZW50cyhjaGFuZ2Vsb2dfY29udGVudHMuZW5jb2RlKCJ1dGYtOCIpKQogICAgICAgICByZXZp ZXdlcl9uYW1lID0gJ1Rlc3QgUmV2aWV3ZXInCiAgICAgICAgIENoYW5nZUxvZyhjaGFuZ2Vsb2df cGF0aCkuc2V0X3Jldmlld2VyKHJldmlld2VyX25hbWUpCi0gICAgICAgIGFjdHVhbF9jb250ZW50 cyA9IHNlbGYuX3JlYWRfZmlsZV9jb250ZW50cyhjaGFuZ2Vsb2dfcGF0aCkKKyAgICAgICAgYWN0 dWFsX2NvbnRlbnRzID0gc2VsZi5fcmVhZF9maWxlX2NvbnRlbnRzKGNoYW5nZWxvZ19wYXRoLCAi dXRmLTgiKQogICAgICAgICBleHBlY3RlZF9jb250ZW50cyA9IGNoYW5nZWxvZ19jb250ZW50cy5y ZXBsYWNlKCdOT0JPRFkgKE9PUFMhKScsIHJldmlld2VyX25hbWUpCiAgICAgICAgIG9zLnJlbW92 ZShjaGFuZ2Vsb2dfcGF0aCkKICAgICAgICAgc2VsZi5hc3NlcnRFcXVhbHMoYWN0dWFsX2NvbnRl bnRzLCBleHBlY3RlZF9jb250ZW50cykKQEAgLTE2OSw4ICsxNzAsOCBAQCBjbGFzcyBDaGFuZ2VM b2dzVGVzdCh1bml0dGVzdC5UZXN0Q2FzZSk6CiAnJycKIAogICAgIGRlZiBfYXNzZXJ0X3VwZGF0 ZV9mb3JfcmV2ZXJ0X291dHB1dChzZWxmLCBhcmdzLCBleHBlY3RlZF9lbnRyeSk6Ci0gICAgICAg IGNoYW5nZWxvZ19jb250ZW50cyA9ICIlc1xuJXMiICUgKHNlbGYuX25ld19lbnRyeV9ib2lsZXJw bGF0ZSwgc2VsZi5fZXhhbXBsZV9jaGFuZ2Vsb2cpCi0gICAgICAgIGNoYW5nZWxvZ19wYXRoID0g c2VsZi5fd3JpdGVfdG1wX2ZpbGVfd2l0aF9jb250ZW50cyhjaGFuZ2Vsb2dfY29udGVudHMpCisg ICAgICAgIGNoYW5nZWxvZ19jb250ZW50cyA9IHUiJXNcbiVzIiAlIChzZWxmLl9uZXdfZW50cnlf Ym9pbGVycGxhdGUsIHNlbGYuX2V4YW1wbGVfY2hhbmdlbG9nKQorICAgICAgICBjaGFuZ2Vsb2df cGF0aCA9IHNlbGYuX3dyaXRlX3RtcF9maWxlX3dpdGhfY29udGVudHMoY2hhbmdlbG9nX2NvbnRl bnRzLmVuY29kZSgidXRmLTgiKSkKICAgICAgICAgY2hhbmdlbG9nID0gQ2hhbmdlTG9nKGNoYW5n ZWxvZ19wYXRoKQogICAgICAgICBjaGFuZ2Vsb2cudXBkYXRlX2Zvcl9yZXZlcnQoKmFyZ3MpCiAg ICAgICAgIGFjdHVhbF9lbnRyeSA9IGNoYW5nZWxvZy5sYXRlc3RfZW50cnkoKQpkaWZmIC0tZ2l0 IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvY29tbWl0aW5m by5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L2NvbW1p dGluZm8ucHkKaW5kZXggN2MzMzE1Zi4uNDQ4ZDUzMCAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMv U2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvY29tbWl0aW5mby5weQorKysgYi9XZWJL aXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9jb21taXRpbmZvLnB5CkBA IC0yOCw4ICsyOCw2IEBACiAjCiAjIFdlYktpdCdzIHB5dGhvbiBtb2R1bGUgZm9yIGhvbGRpbmcg aW5mb3JtYXRpb24gb24gYSBjb21taXQKIAotaW1wb3J0IFN0cmluZ0lPCi0KIGZyb20gd2Via2l0 cHkuY29tbW9uLmNoZWNrb3V0LmNoYW5nZWxvZyBpbXBvcnQgdmlld19zb3VyY2VfdXJsCiBmcm9t IHdlYmtpdHB5LmNvbW1vbi5jb25maWcuY29tbWl0dGVycyBpbXBvcnQgQ29tbWl0dGVyTGlzdAog CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291 dC9zY20ucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9z Y20ucHkKaW5kZXggMjcwNGYwNy4uODcwN2YyZSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2Ny aXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtLnB5CisrKyBiL1dlYktpdFRvb2xzL1Nj cmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3NjbS5weQpAQCAtMTQ1LDcgKzE0NSw3IEBA IGNsYXNzIFNDTToKICAgICAgICAgcmV0dXJuIGZpbGVuYW1lcwogCiAgICAgZGVmIHN0cmlwX3Jf ZnJvbV9zdm5fcmV2aXNpb24oc2VsZiwgc3ZuX3JldmlzaW9uKToKLSAgICAgICAgbWF0Y2ggPSBy ZS5tYXRjaCgiXnIoP1A8c3ZuX3JldmlzaW9uPlxkKykiLCBzdm5fcmV2aXNpb24pCisgICAgICAg IG1hdGNoID0gcmUubWF0Y2goIl5yKD9QPHN2bl9yZXZpc2lvbj5cZCspIiwgdW5pY29kZShzdm5f cmV2aXNpb24pKQogICAgICAgICBpZiAobWF0Y2gpOgogICAgICAgICAgICAgcmV0dXJuIG1hdGNo Lmdyb3VwKCdzdm5fcmV2aXNpb24nKQogICAgICAgICByZXR1cm4gc3ZuX3JldmlzaW9uCkBAIC0z NDQsNyArMzQ0LDcgQEAgY2xhc3MgU1ZOKFNDTSk6CiAKICAgICBkZWYgY2hhbmdlZF9maWxlc19m b3JfcmV2aXNpb24oc2VsZiwgcmV2aXNpb24pOgogICAgICAgICAjIEFzIGZhciBhcyBJIGNhbiB0 ZWxsIHN2biBkaWZmIC0tc3VtbWFyaXplIG91dHB1dCBsb29rcyBqdXN0IGxpa2Ugc3ZuIHN0YXR1 cyBvdXRwdXQuCi0gICAgICAgIHN0YXR1c19jb21tYW5kID0gWyJzdm4iLCAiZGlmZiIsICItLXN1 bW1hcml6ZSIsICItYyIsIHN0cihyZXZpc2lvbildCisgICAgICAgIHN0YXR1c19jb21tYW5kID0g WyJzdm4iLCAiZGlmZiIsICItLXN1bW1hcml6ZSIsICItYyIsIHJldmlzaW9uXQogICAgICAgICBy ZXR1cm4gc2VsZi5ydW5fc3RhdHVzX2FuZF9leHRyYWN0X2ZpbGVuYW1lcyhzdGF0dXNfY29tbWFu ZCwgc2VsZi5fc3RhdHVzX3JlZ2V4cCgiQUNETVIiKSkKIAogICAgIGRlZiBjb25mbGljdGVkX2Zp bGVzKHNlbGYpOgpAQCAtMzYxLDE4ICszNjEsMTggQEAgY2xhc3MgU1ZOKFNDTSk6CiAgICAgICAg IHJldHVybiAic3ZuIgogCiAgICAgZGVmIGNyZWF0ZV9wYXRjaChzZWxmKToKLSAgICAgICAgcmV0 dXJuIHJ1bl9jb21tYW5kKHNlbGYuc2NyaXB0X3BhdGgoInN2bi1jcmVhdGUtcGF0Y2giKSwgY3dk PXNlbGYuY2hlY2tvdXRfcm9vdCwgcmV0dXJuX3N0ZGVycj1GYWxzZSkKKyAgICAgICAgcmV0dXJu IHJ1bl9jb21tYW5kKFtzZWxmLnNjcmlwdF9wYXRoKCJzdm4tY3JlYXRlLXBhdGNoIildLCBjd2Q9 c2VsZi5jaGVja291dF9yb290LCByZXR1cm5fc3RkZXJyPUZhbHNlKQogCiAgICAgZGVmIGNvbW1p dHRlcl9lbWFpbF9mb3JfcmV2aXNpb24oc2VsZiwgcmV2aXNpb24pOgotICAgICAgICByZXR1cm4g cnVuX2NvbW1hbmQoWyJzdm4iLCAicHJvcGdldCIsICJzdm46YXV0aG9yIiwgIi0tcmV2cHJvcCIs ICItciIsIHN0cihyZXZpc2lvbildKS5yc3RyaXAoKQorICAgICAgICByZXR1cm4gcnVuX2NvbW1h bmQoWyJzdm4iLCAicHJvcGdldCIsICJzdm46YXV0aG9yIiwgIi0tcmV2cHJvcCIsICItciIsIHJl dmlzaW9uXSkucnN0cmlwKCkKIAogICAgIGRlZiBjb250ZW50c19hdF9yZXZpc2lvbihzZWxmLCBw YXRoLCByZXZpc2lvbik6CiAgICAgICAgIHJlbW90ZV9wYXRoID0gIiVzLyVzIiAlIChzZWxmLl9y ZXBvc2l0b3J5X3VybCgpLCBwYXRoKQotICAgICAgICByZXR1cm4gcnVuX2NvbW1hbmQoWyJzdm4i LCAiY2F0IiwgIi1yIiwgc3RyKHJldmlzaW9uKSwgcmVtb3RlX3BhdGhdKQorICAgICAgICByZXR1 cm4gcnVuX2NvbW1hbmQoWyJzdm4iLCAiY2F0IiwgIi1yIiwgcmV2aXNpb24sIHJlbW90ZV9wYXRo XSkKIAogICAgIGRlZiBkaWZmX2Zvcl9yZXZpc2lvbihzZWxmLCByZXZpc2lvbik6CiAgICAgICAg ICMgRklYTUU6IFRoaXMgc2hvdWxkIHByb2JhYmx5IHVzZSBjd2Q9c2VsZi5jaGVja291dF9yb290 Ci0gICAgICAgIHJldHVybiBydW5fY29tbWFuZChbJ3N2bicsICdkaWZmJywgJy1jJywgc3RyKHJl dmlzaW9uKV0pCisgICAgICAgIHJldHVybiBydW5fY29tbWFuZChbJ3N2bicsICdkaWZmJywgJy1j JywgcmV2aXNpb25dKQogCiAgICAgZGVmIF9yZXBvc2l0b3J5X3VybChzZWxmKToKICAgICAgICAg cmV0dXJuIHNlbGYudmFsdWVfZnJvbV9zdm5faW5mbyhzZWxmLmNoZWNrb3V0X3Jvb3QsICdVUkwn KQpAQCAtNDA1LDcgKzQwNSw3IEBAIGNsYXNzIFNWTihTQ00pOgogICAgICAgICByZXR1cm4gcnVu X2NvbW1hbmQoc3ZuX2NvbW1pdF9hcmdzLCBlcnJvcl9oYW5kbGVyPWNvbW1pdF9lcnJvcl9oYW5k bGVyKQogCiAgICAgZGVmIHN2bl9jb21taXRfbG9nKHNlbGYsIHN2bl9yZXZpc2lvbik6Ci0gICAg ICAgIHN2bl9yZXZpc2lvbiA9IHNlbGYuc3RyaXBfcl9mcm9tX3N2bl9yZXZpc2lvbihzdHIoc3Zu X3JldmlzaW9uKSkKKyAgICAgICAgc3ZuX3JldmlzaW9uID0gc2VsZi5zdHJpcF9yX2Zyb21fc3Zu X3JldmlzaW9uKHN2bl9yZXZpc2lvbikKICAgICAgICAgcmV0dXJuIHJ1bl9jb21tYW5kKFsnc3Zu JywgJ2xvZycsICctLW5vbi1pbnRlcmFjdGl2ZScsICctLXJldmlzaW9uJywgc3ZuX3JldmlzaW9u XSk7CiAKICAgICBkZWYgbGFzdF9zdm5fY29tbWl0X2xvZyhzZWxmKToKZGlmZiAtLWdpdCBhL1dl YktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3NjbV91bml0dGVzdC5w eSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3NjbV91bml0 dGVzdC5weQppbmRleCBjMGE2NGQ0Li4wZWQzMTk5IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9T Y3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9zY21fdW5pdHRlc3QucHkKKysrIGIvV2Vi S2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtX3VuaXR0ZXN0LnB5 CkBAIC0yNyw3ICsyNywxMCBAQAogIyAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNF KSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKICMgT0YgVEhJUyBTT0ZUV0FSRSwg RVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KIAorZnJv bSBfX2Z1dHVyZV9fIGltcG9ydCB3aXRoX3N0YXRlbWVudAorCiBpbXBvcnQgYmFzZTY0CitpbXBv cnQgY29kZWNzCiBpbXBvcnQgZ2V0cGFzcwogaW1wb3J0IG9zCiBpbXBvcnQgb3MucGF0aApAQCAt NTYsMTYgKzU5LDE2IEBAIGRlZiBydW5fc2lsZW50KGFyZ3MsIGN3ZD1Ob25lKToKICAgICBpZiBl eGl0X2NvZGU6CiAgICAgICAgIHJhaXNlIFNjcmlwdEVycm9yKCdGYWlsZWQgdG8gcnVuICIlcyIg IGV4aXRfY29kZTogJWQgIGN3ZDogJXMnICUgKGFyZ3MsIGV4aXRfY29kZSwgY3dkKSkKIAotZGVm IHdyaXRlX2ludG9fZmlsZV9hdF9wYXRoKGZpbGVfcGF0aCwgY29udGVudHMpOgotICAgIGZpbGUg PSBvcGVuKGZpbGVfcGF0aCwgJ3cnKQotICAgIGZpbGUud3JpdGUoY29udGVudHMpCi0gICAgZmls ZS5jbG9zZSgpCiAKLWRlZiByZWFkX2Zyb21fcGF0aChmaWxlX3BhdGgpOgotICAgIGZpbGUgPSBv cGVuKGZpbGVfcGF0aCwgJ3InKQotICAgIGNvbnRlbnRzID0gZmlsZS5yZWFkKCkKLSAgICBmaWxl LmNsb3NlKCkKLSAgICByZXR1cm4gY29udGVudHMKK2RlZiB3cml0ZV9pbnRvX2ZpbGVfYXRfcGF0 aChmaWxlX3BhdGgsIGNvbnRlbnRzLCBlbmNvZGluZz0idXRmLTgiKToKKyAgICB3aXRoIGNvZGVj cy5vcGVuKGZpbGVfcGF0aCwgInciLCBlbmNvZGluZykgYXMgZmlsZToKKyAgICAgICAgZmlsZS53 cml0ZShjb250ZW50cykKKworCitkZWYgcmVhZF9mcm9tX3BhdGgoZmlsZV9wYXRoLCBlbmNvZGlu Zz0idXRmLTgiKToKKyAgICB3aXRoIGNvZGVjcy5vcGVuKGZpbGVfcGF0aCwgInIiLCBlbmNvZGlu ZykgYXMgZmlsZToKKyAgICAgICAgcmV0dXJuIGZpbGUucmVhZCgpCisKIAogIyBFeGlzdHMgdG8g c2hhcmUgc3ZuIHJlcG9zaXRvcnkgY3JlYXRpb24gY29kZSBiZXR3ZWVuIHRoZSBnaXQgYW5kIHN2 biB0ZXN0cwogY2xhc3MgU1ZOVGVzdFJlcG9zaXRvcnk6CkBAIC0zMDgsNyArMzExLDcgQEAgSGNt Vj9kMDAwMDEKIAogIiIiCiAgICAgICAgIHNlbGYuY2hlY2tvdXQuYXBwbHlfcGF0Y2goc2VsZi5f Y3JlYXRlX3BhdGNoKGdpdF9iaW5hcnlfYWRkaXRpb24pKQotICAgICAgICBhZGRlZCA9IHJlYWRf ZnJvbV9wYXRoKCdmaXp6YnV6ejcuZ2lmJykKKyAgICAgICAgYWRkZWQgPSByZWFkX2Zyb21fcGF0 aCgnZml6emJ1eno3LmdpZicsIGVuY29kaW5nPU5vbmUpCiAgICAgICAgIHNlbGYuYXNzZXJ0RXF1 YWwoNTEyLCBsZW4oYWRkZWQpKQogICAgICAgICBzZWxmLmFzc2VydFRydWUoYWRkZWQuc3RhcnRz d2l0aCgnR0lGODlhJykpCiAgICAgICAgIHNlbGYuYXNzZXJ0VHJ1ZSgnZml6emJ1eno3LmdpZicg aW4gc2VsZi5zY20uY2hhbmdlZF9maWxlcygpKQpAQCAtMzM2LDcgKzMzOSw3IEBAIHB0VWwtWkc8 JWF+I0x3a0lXdiZxIUtTQ0g3dFE4Y0pEaXcrfEdWP01OKVJqWTUwUlRiLXh2VCZICiAKICIiIgog ICAgICAgICBzZWxmLmNoZWNrb3V0LmFwcGx5X3BhdGNoKHNlbGYuX2NyZWF0ZV9wYXRjaChnaXRf YmluYXJ5X21vZGlmaWNhdGlvbikpCi0gICAgICAgIG1vZGlmaWVkID0gcmVhZF9mcm9tX3BhdGgo J2ZpenpidXp6Ny5naWYnKQorICAgICAgICBtb2RpZmllZCA9IHJlYWRfZnJvbV9wYXRoKCdmaXp6 YnV6ejcuZ2lmJywgZW5jb2Rpbmc9Tm9uZSkKICAgICAgICAgc2VsZi5hc3NlcnRFcXVhbCgnZm9v YmFyXG4nLCBtb2RpZmllZCkKICAgICAgICAgc2VsZi5hc3NlcnRUcnVlKCdmaXp6YnV6ejcuZ2lm JyBpbiBzZWxmLnNjbS5jaGFuZ2VkX2ZpbGVzKCkpCiAKQEAgLTUxOCw3ICs1MjEsNyBAQCBRMWRU QngwQUFBQjQyaXRnNEdsZ1lKakd3TUREeU9ETXhNRHczNEdCZ1FFQUpQUURKQT09CiAgICAgICAg IHNlbGYuX3NldHVwX3dlYmtpdHRvb2xzX3NjcmlwdHNfc3ltbGluayhzZWxmLnNjbSkKICAgICAg ICAgcGF0Y2hfZmlsZSA9IHNlbGYuX2NyZWF0ZV9wYXRjaChwYXRjaF9jb250ZW50cykKICAgICAg ICAgc2VsZi5jaGVja291dC5hcHBseV9wYXRjaChwYXRjaF9maWxlKQotICAgICAgICBhY3R1YWxf Y29udGVudHMgPSByZWFkX2Zyb21fcGF0aCgidGVzdF9maWxlLnN3ZiIpCisgICAgICAgIGFjdHVh bF9jb250ZW50cyA9IHJlYWRfZnJvbV9wYXRoKCJ0ZXN0X2ZpbGUuc3dmIiwgZW5jb2Rpbmc9Tm9u ZSkKICAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChhY3R1YWxfY29udGVudHMsIGV4cGVjdGVkX2Nv bnRlbnRzKQogCiAgICAgZGVmIHRlc3RfYXBwbHlfc3ZuX3BhdGNoKHNlbGYpOgpAQCAtNzM5LDcg Kzc0Miw3IEBAIGNsYXNzIEdpdFRlc3QoU0NNVGVzdCk6CiAgICAgICAgIHRlc3RfZmlsZV9uYW1l ID0gJ2JpbmFyeV9maWxlJwogICAgICAgICB0ZXN0X2ZpbGVfcGF0aCA9IG9zLnBhdGguam9pbihz ZWxmLmdpdF9jaGVja291dF9wYXRoLCB0ZXN0X2ZpbGVfbmFtZSkKICAgICAgICAgZmlsZV9jb250 ZW50cyA9ICcnLmpvaW4obWFwKGNociwgcmFuZ2UoMjU2KSkpCi0gICAgICAgIHdyaXRlX2ludG9f ZmlsZV9hdF9wYXRoKHRlc3RfZmlsZV9wYXRoLCBmaWxlX2NvbnRlbnRzKQorICAgICAgICB3cml0 ZV9pbnRvX2ZpbGVfYXRfcGF0aCh0ZXN0X2ZpbGVfcGF0aCwgZmlsZV9jb250ZW50cywgZW5jb2Rp bmc9Tm9uZSkKICAgICAgICAgcnVuX2NvbW1hbmQoWydnaXQnLCAnYWRkJywgdGVzdF9maWxlX25h bWVdKQogICAgICAgICBwYXRjaCA9IHNjbS5jcmVhdGVfcGF0Y2goKQogICAgICAgICBzZWxmLmFz c2VydFRydWUocmUuc2VhcmNoKHInXG5saXRlcmFsIDBcbicsIHBhdGNoKSkKQEAgLTc0OSwxMCAr NzUyLDEwIEBAIGNsYXNzIEdpdFRlc3QoU0NNVGVzdCk6CiAgICAgICAgIHJ1bl9jb21tYW5kKFsn Z2l0JywgJ3JtJywgJy1mJywgdGVzdF9maWxlX25hbWVdKQogICAgICAgICBzZWxmLl9zZXR1cF93 ZWJraXR0b29sc19zY3JpcHRzX3N5bWxpbmsoc2NtKQogICAgICAgICBzZWxmLmNoZWNrb3V0LmFw cGx5X3BhdGNoKHNlbGYuX2NyZWF0ZV9wYXRjaChwYXRjaCkpCi0gICAgICAgIHNlbGYuYXNzZXJ0 RXF1YWwoZmlsZV9jb250ZW50cywgcmVhZF9mcm9tX3BhdGgodGVzdF9maWxlX3BhdGgpKQorICAg ICAgICBzZWxmLmFzc2VydEVxdWFsKGZpbGVfY29udGVudHMsIHJlYWRfZnJvbV9wYXRoKHRlc3Rf ZmlsZV9wYXRoLCBlbmNvZGluZz1Ob25lKSkKIAogICAgICAgICAjIENoZWNrIGlmIHdlIGNhbiBj cmVhdGUgYSBwYXRjaCBmcm9tIGEgbG9jYWwgY29tbWl0LgotICAgICAgICB3cml0ZV9pbnRvX2Zp bGVfYXRfcGF0aCh0ZXN0X2ZpbGVfcGF0aCwgZmlsZV9jb250ZW50cykKKyAgICAgICAgd3JpdGVf aW50b19maWxlX2F0X3BhdGgodGVzdF9maWxlX3BhdGgsIGZpbGVfY29udGVudHMsIGVuY29kaW5n PU5vbmUpCiAgICAgICAgIHJ1bl9jb21tYW5kKFsnZ2l0JywgJ2FkZCcsIHRlc3RfZmlsZV9uYW1l XSkKICAgICAgICAgcnVuX2NvbW1hbmQoWydnaXQnLCAnY29tbWl0JywgJy1tJywgJ2JpbmFyeSBk aWZmJ10pCiAgICAgICAgIHBhdGNoX2Zyb21fbG9jYWxfY29tbWl0ID0gc2NtLmNyZWF0ZV9wYXRj aF9mcm9tX2xvY2FsX2NvbW1pdCgnSEVBRCcpCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3Jp cHRzL3dlYmtpdHB5L2NvbW1vbi9jb25maWcvY29tbWl0dGVycy5weSBiL1dlYktpdFRvb2xzL1Nj cmlwdHMvd2Via2l0cHkvY29tbW9uL2NvbmZpZy9jb21taXR0ZXJzLnB5CmluZGV4IDQ5MzU0YzUu LjE5ZDU2MTggMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9u L2NvbmZpZy9jb21taXR0ZXJzLnB5CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkv Y29tbW9uL2NvbmZpZy9jb21taXR0ZXJzLnB5CkBAIC0yMzksNyArMjM5LDcgQEAgcmV2aWV3ZXJz X2xpc3QgPSBbCiAgICAgUmV2aWV3ZXIoIlN0ZXZlIEZhbGtlbmJ1cmciLCAic2ZhbGtlbkBhcHBs ZS5jb20iLCAic2ZhbGtlbiIpLAogICAgIFJldmlld2VyKCJUaW0gT21lcm5pY2siLCAidGltb0Bh cHBsZS5jb20iKSwKICAgICBSZXZpZXdlcigiVGltb3RoeSBIYXRjaGVyIiwgWyJ0aW1vdGh5QGhh dGNoZXIubmFtZSIsICJ0aW1vdGh5QGFwcGxlLmNvbSJdLCAieGVub24iKSwKLSAgICBSZXZpZXdl cih1J1RvciBBcm5lIFZlc3RiXHhmOCcsICJ2ZXN0Ym9Ad2Via2l0Lm9yZyIsICJ0b3Jhcm5lIiks CisgICAgUmV2aWV3ZXIodSJUb3IgQXJuZSBWZXN0Ylx1MDBmOCIsICJ2ZXN0Ym9Ad2Via2l0Lm9y ZyIsICJ0b3Jhcm5lIiksCiAgICAgUmV2aWV3ZXIoIlZpY2tpIE11cmxleSIsICJ2aWNraUBhcHBs ZS5jb20iKSwKICAgICBSZXZpZXdlcigiWGFuIExvcGV6IiwgWyJ4YW4ubG9wZXpAZ21haWwuY29t IiwgInhhbkBnbm9tZS5vcmciLCAieGFuQHdlYmtpdC5vcmciXSwgInhhbiIpLAogICAgIFJldmll d2VyKCJZdXJ5IFNlbWlraGF0c2t5IiwgInl1cnlzQGNocm9taXVtLm9yZyIsICJ5dXJ5cyIpLApk aWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vbmV0L2J1Z3pp bGxhLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vbmV0L2J1Z3ppbGxh LnB5CmluZGV4IDY5MjBkNjcuLjA0NzliZmYgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1Njcmlw dHMvd2Via2l0cHkvY29tbW9uL25ldC9idWd6aWxsYS5weQorKysgYi9XZWJLaXRUb29scy9TY3Jp cHRzL3dlYmtpdHB5L2NvbW1vbi9uZXQvYnVnemlsbGEucHkKQEAgLTMyLDYgKzMyLDcgQEAKIAog aW1wb3J0IG9zLnBhdGgKIGltcG9ydCByZQoraW1wb3J0IFN0cmluZ0lPCiBpbXBvcnQgc3VicHJv Y2VzcwogCiBmcm9tIGRhdGV0aW1lIGltcG9ydCBkYXRldGltZSAjIHVzZWQgaW4gdGltZXN0YW1w KCkKQEAgLTQyNyw3ICs0MjgsMTYgQEAgY2xhc3MgQnVnemlsbGEob2JqZWN0KToKICAgICAgICAg ICAgIGlmIGZsYWdbJ3N0YXR1cyddID09ICcrJzoKICAgICAgICAgICAgICAgICBhdHRhY2htZW50 W3Jlc3VsdF9rZXldID0gZmxhZ1snc2V0dGVyJ10KIAorICAgIGRlZiBfc3RyaW5nX2NvbnRlbnRz KHNlbGYsIHNvdXApOgorICAgICAgICAjIFdlYktpdCdzIGJ1Z3ppbGxhIGluc3RhbmNlIHVzZXMg VVRGLTguCisgICAgICAgICMgQmVhdXRpZnVsU291cCBhbHdheXMgcmV0dXJucyBVbmljb2RlIHN0 cmluZ3MsIGhvd2V2ZXIKKyAgICAgICAgIyB0aGUgLnN0cmluZyBtZXRob2QgcmV0dXJucyBhICh1 bmljb2RlKSBOYXZpZ2FibGVTdHJpbmcuCisgICAgICAgICMgTmF2aWdhYmxlU3RyaW5nIGNhbiBj b25mdXNlIG90aGVyIHBhcnRzIG9mIHRoZSBjb2RlLCBzbyB3ZQorICAgICAgICAjIGNvbnZlcnQg ZnJvbSBOYXZpZ2FibGVTdHJpbmcgdG8gYSByZWFsIHVuaWNvZGUoKSBvYmplY3QgdXNpbmcgdW5p Y29kZSgpLgorICAgICAgICByZXR1cm4gdW5pY29kZShzb3VwLnN0cmluZykKKwogICAgIGRlZiBf cGFyc2VfYXR0YWNobWVudF9lbGVtZW50KHNlbGYsIGVsZW1lbnQsIGJ1Z19pZCk6CisKICAgICAg ICAgYXR0YWNobWVudCA9IHt9CiAgICAgICAgIGF0dGFjaG1lbnRbJ2J1Z19pZCddID0gYnVnX2lk CiAgICAgICAgIGF0dGFjaG1lbnRbJ2lzX29ic29sZXRlJ10gPSAoZWxlbWVudC5oYXNfa2V5KCdp c29ic29sZXRlJykgYW5kIGVsZW1lbnRbJ2lzb2Jzb2xldGUnXSA9PSAiMSIpCkBAIC00MzUsOSAr NDQ1LDkgQEAgY2xhc3MgQnVnemlsbGEob2JqZWN0KToKICAgICAgICAgYXR0YWNobWVudFsnaWQn XSA9IGludChlbGVtZW50LmZpbmQoJ2F0dGFjaGlkJykuc3RyaW5nKQogICAgICAgICAjIEZJWE1F OiBObyBuZWVkIHRvIHBhcnNlIG91dCB0aGUgdXJsIGhlcmUuCiAgICAgICAgIGF0dGFjaG1lbnRb J3VybCddID0gc2VsZi5hdHRhY2htZW50X3VybF9mb3JfaWQoYXR0YWNobWVudFsnaWQnXSkKLSAg ICAgICAgYXR0YWNobWVudFsnbmFtZSddID0gdW5pY29kZShlbGVtZW50LmZpbmQoJ2Rlc2MnKS5z dHJpbmcpCi0gICAgICAgIGF0dGFjaG1lbnRbJ2F0dGFjaGVyX2VtYWlsJ10gPSBzdHIoZWxlbWVu dC5maW5kKCdhdHRhY2hlcicpLnN0cmluZykKLSAgICAgICAgYXR0YWNobWVudFsndHlwZSddID0g c3RyKGVsZW1lbnQuZmluZCgndHlwZScpLnN0cmluZykKKyAgICAgICAgYXR0YWNobWVudFsnbmFt ZSddID0gc2VsZi5fc3RyaW5nX2NvbnRlbnRzKGVsZW1lbnQuZmluZCgnZGVzYycpKQorICAgICAg ICBhdHRhY2htZW50WydhdHRhY2hlcl9lbWFpbCddID0gc2VsZi5fc3RyaW5nX2NvbnRlbnRzKGVs ZW1lbnQuZmluZCgnYXR0YWNoZXInKSkKKyAgICAgICAgYXR0YWNobWVudFsndHlwZSddID0gc2Vs Zi5fc3RyaW5nX2NvbnRlbnRzKGVsZW1lbnQuZmluZCgndHlwZScpKQogICAgICAgICBzZWxmLl9w YXJzZV9hdHRhY2htZW50X2ZsYWcoCiAgICAgICAgICAgICAgICAgZWxlbWVudCwgJ3Jldmlldycs IGF0dGFjaG1lbnQsICdyZXZpZXdlcl9lbWFpbCcpCiAgICAgICAgIHNlbGYuX3BhcnNlX2F0dGFj aG1lbnRfZmxhZygKQEAgLTQ0OCwxMCArNDU4LDEwIEBAIGNsYXNzIEJ1Z3ppbGxhKG9iamVjdCk6 CiAgICAgICAgIHNvdXAgPSBCZWF1dGlmdWxTb3VwKHBhZ2UpCiAgICAgICAgIGJ1ZyA9IHt9CiAg ICAgICAgIGJ1Z1siaWQiXSA9IGludChzb3VwLmZpbmQoImJ1Z19pZCIpLnN0cmluZykKLSAgICAg ICAgYnVnWyJ0aXRsZSJdID0gdW5pY29kZShzb3VwLmZpbmQoInNob3J0X2Rlc2MiKS5zdHJpbmcp Ci0gICAgICAgIGJ1Z1sicmVwb3J0ZXJfZW1haWwiXSA9IHN0cihzb3VwLmZpbmQoInJlcG9ydGVy Iikuc3RyaW5nKQotICAgICAgICBidWdbImFzc2lnbmVkX3RvX2VtYWlsIl0gPSBzdHIoc291cC5m aW5kKCJhc3NpZ25lZF90byIpLnN0cmluZykKLSAgICAgICAgYnVnWyJjY19lbWFpbHMiXSA9IFtz dHIoZWxlbWVudC5zdHJpbmcpCisgICAgICAgIGJ1Z1sidGl0bGUiXSA9IHNlbGYuX3N0cmluZ19j b250ZW50cyhzb3VwLmZpbmQoInNob3J0X2Rlc2MiKSkKKyAgICAgICAgYnVnWyJyZXBvcnRlcl9l bWFpbCJdID0gc2VsZi5fc3RyaW5nX2NvbnRlbnRzKHNvdXAuZmluZCgicmVwb3J0ZXIiKSkKKyAg ICAgICAgYnVnWyJhc3NpZ25lZF90b19lbWFpbCJdID0gc2VsZi5fc3RyaW5nX2NvbnRlbnRzKHNv dXAuZmluZCgiYXNzaWduZWRfdG8iKSkKKyAgICAgICAgYnVnWyJjY19lbWFpbHMiXSA9IFtzZWxm Ll9zdHJpbmdfY29udGVudHMoZWxlbWVudCkKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBm b3IgZWxlbWVudCBpbiBzb3VwLmZpbmRBbGwoJ2NjJyldCiAgICAgICAgIGJ1Z1siYXR0YWNobWVu dHMiXSA9IFtzZWxmLl9wYXJzZV9hdHRhY2htZW50X2VsZW1lbnQoZWxlbWVudCwgYnVnWyJpZCJd KSBmb3IgZWxlbWVudCBpbiBzb3VwLmZpbmRBbGwoJ2F0dGFjaG1lbnQnKV0KICAgICAgICAgcmV0 dXJuIGJ1ZwpAQCAtNTQ4LDcgKzU1OCw3IEBAIGNsYXNzIEJ1Z3ppbGxhKG9iamVjdCk6CiAKICAg ICBkZWYgX2ZpbGxfYXR0YWNobWVudF9mb3JtKHNlbGYsCiAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBkZXNjcmlwdGlvbiwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHBhdGNo X2ZpbGVfb2JqZWN0LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZGlmZiwKICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIGNvbW1lbnRfdGV4dD1Ob25lLAogICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgbWFya19mb3JfcmV2aWV3PUZhbHNlLAogICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgbWFya19mb3JfY29tbWl0X3F1ZXVlPUZhbHNlLApAQCAtNTY4LDYgKzU3 OCw5IEBAIGNsYXNzIEJ1Z3ppbGxhKG9iamVjdCk6CiAgICAgICAgICAgICBwYXRjaF9uYW1lID0g ImJ1Zy0lcy0lcy5wYXRjaCIgJSAoYnVnX2lkLCB0aW1lc3RhbXAoKSkKICAgICAgICAgZWxzZToK ICAgICAgICAgICAgIHBhdGNoX25hbWUgPSIlcy5wYXRjaCIgJSB0aW1lc3RhbXAoKQorCisgICAg ICAgICMgQ2xpZW50Rm9ybSBleHBlY3RzIGEgZmlsZS1saWtlIG9iamVjdAorICAgICAgICBwYXRj aF9maWxlX29iamVjdCA9IFN0cmluZ0lPLlN0cmluZ0lPKGRpZmYuZW5jb2RlKCJ1dGYtOCIpKQog ICAgICAgICBzZWxmLmJyb3dzZXIuYWRkX2ZpbGUocGF0Y2hfZmlsZV9vYmplY3QsCiAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAidGV4dC9wbGFpbiIsCiAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBwYXRjaF9uYW1lLApAQCAtNTc1LDcgKzU4OCw3IEBAIGNsYXNzIEJ1Z3ppbGxh KG9iamVjdCk6CiAKICAgICBkZWYgYWRkX3BhdGNoX3RvX2J1ZyhzZWxmLAogICAgICAgICAgICAg ICAgICAgICAgICAgIGJ1Z19pZCwKLSAgICAgICAgICAgICAgICAgICAgICAgICBwYXRjaF9maWxl X29iamVjdCwKKyAgICAgICAgICAgICAgICAgICAgICAgICBkaWZmLAogICAgICAgICAgICAgICAg ICAgICAgICAgIGRlc2NyaXB0aW9uLAogICAgICAgICAgICAgICAgICAgICAgICAgIGNvbW1lbnRf dGV4dD1Ob25lLAogICAgICAgICAgICAgICAgICAgICAgICAgIG1hcmtfZm9yX3Jldmlldz1GYWxz ZSwKQEAgLTU5NCw4ICs2MDcsOSBAQCBjbGFzcyBCdWd6aWxsYShvYmplY3QpOgogICAgICAgICBz ZWxmLmJyb3dzZXIub3BlbigiJXNhdHRhY2htZW50LmNnaT9hY3Rpb249ZW50ZXImYnVnaWQ9JXMi ICUgKAogICAgICAgICAgICAgICAgICAgICAgICAgICBzZWxmLmJ1Z19zZXJ2ZXJfdXJsLCBidWdf aWQpKQogICAgICAgICBzZWxmLmJyb3dzZXIuc2VsZWN0X2Zvcm0obmFtZT0iZW50cnlmb3JtIikK KwogICAgICAgICBzZWxmLl9maWxsX2F0dGFjaG1lbnRfZm9ybShkZXNjcmlwdGlvbiwKLSAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcGF0Y2hfZmlsZV9vYmplY3QsCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIGRpZmYsCiAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIG1hcmtfZm9yX3Jldmlldz1tYXJrX2Zvcl9yZXZpZXcsCiAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIG1hcmtfZm9yX2NvbW1pdF9xdWV1ZT1tYXJrX2Zvcl9j b21taXRfcXVldWUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1hcmtfZm9y X2xhbmRpbmc9bWFya19mb3JfbGFuZGluZywKQEAgLTYyOCw3ICs2NDIsNyBAQCBjbGFzcyBCdWd6 aWxsYShvYmplY3QpOgogICAgICAgICAgICAgICAgICAgIGJ1Z190aXRsZSwKICAgICAgICAgICAg ICAgICAgICBidWdfZGVzY3JpcHRpb24sCiAgICAgICAgICAgICAgICAgICAgY29tcG9uZW50PU5v bmUsCi0gICAgICAgICAgICAgICAgICAgcGF0Y2hfZmlsZV9vYmplY3Q9Tm9uZSwKKyAgICAgICAg ICAgICAgICAgICBkaWZmPU5vbmUsCiAgICAgICAgICAgICAgICAgICAgcGF0Y2hfZGVzY3JpcHRp b249Tm9uZSwKICAgICAgICAgICAgICAgICAgICBjYz1Ob25lLAogICAgICAgICAgICAgICAgICAg IGJsb2NrZWQ9Tm9uZSwKQEAgLTY1MywxNCArNjY3LDE0IEBAIGNsYXNzIEJ1Z3ppbGxhKG9iamVj dCk6CiAgICAgICAgIGlmIGNjOgogICAgICAgICAgICAgc2VsZi5icm93c2VyWyJjYyJdID0gY2MK ICAgICAgICAgaWYgYmxvY2tlZDoKLSAgICAgICAgICAgIHNlbGYuYnJvd3NlclsiYmxvY2tlZCJd ID0gc3RyKGJsb2NrZWQpCisgICAgICAgICAgICBzZWxmLmJyb3dzZXJbImJsb2NrZWQiXSA9IHVu aWNvZGUoYmxvY2tlZCkKICAgICAgICAgc2VsZi5icm93c2VyWyJzaG9ydF9kZXNjIl0gPSBidWdf dGl0bGUKICAgICAgICAgc2VsZi5icm93c2VyWyJjb21tZW50Il0gPSBidWdfZGVzY3JpcHRpb24K IAotICAgICAgICBpZiBwYXRjaF9maWxlX29iamVjdDoKKyAgICAgICAgaWYgZGlmZjoKICAgICAg ICAgICAgIHNlbGYuX2ZpbGxfYXR0YWNobWVudF9mb3JtKAogICAgICAgICAgICAgICAgICAgICBw YXRjaF9kZXNjcmlwdGlvbiwKLSAgICAgICAgICAgICAgICAgICAgcGF0Y2hfZmlsZV9vYmplY3Qs CisgICAgICAgICAgICAgICAgICAgIGRpZmYsCiAgICAgICAgICAgICAgICAgICAgIG1hcmtfZm9y X3Jldmlldz1tYXJrX2Zvcl9yZXZpZXcsCiAgICAgICAgICAgICAgICAgICAgIG1hcmtfZm9yX2Nv bW1pdF9xdWV1ZT1tYXJrX2Zvcl9jb21taXRfcXVldWUpCiAKZGlmZiAtLWdpdCBhL1dlYktpdFRv b2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL25ldC9idWlsZGJvdC5weSBiL1dlYktpdFRvb2xz L1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL25ldC9idWlsZGJvdC5weQppbmRleCA3NTNlOTA5Li5l NGU2MjczIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9u ZXQvYnVpbGRib3QucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24v bmV0L2J1aWxkYm90LnB5CkBAIC00NCw3ICs0NCw3IEBAIF9sb2cgPSBnZXRfbG9nZ2VyKF9fZmls ZV9fKQogCiBjbGFzcyBCdWlsZGVyKG9iamVjdCk6CiAgICAgZGVmIF9faW5pdF9fKHNlbGYsIG5h bWUsIGJ1aWxkYm90KToKLSAgICAgICAgc2VsZi5fbmFtZSA9IHVuaWNvZGUobmFtZSkKKyAgICAg ICAgc2VsZi5fbmFtZSA9IG5hbWUKICAgICAgICAgc2VsZi5fYnVpbGRib3QgPSBidWlsZGJvdAog ICAgICAgICBzZWxmLl9idWlsZHNfY2FjaGUgPSB7fQogICAgICAgICBzZWxmLl9yZXZpc2lvbl90 b19idWlsZF9udW1iZXIgPSBOb25lCkBAIC0yMjMsMTIgKzIyMywxMiBAQCBjbGFzcyBMYXlvdXRU ZXN0UmVzdWx0cyhvYmplY3QpOgogICAgICAgICBwYXJzZWRfcmVzdWx0cyA9IHt9CiAgICAgICAg IHRhYmxlcyA9IEJlYXV0aWZ1bFNvdXAocGFnZSkuZmluZEFsbCgidGFibGUiKQogICAgICAgICBm b3IgdGFibGUgaW4gdGFibGVzOgotICAgICAgICAgICAgdGFibGVfdGl0bGUgPSB0YWJsZS5maW5k UHJldmlvdXNTaWJsaW5nKCJwIikuc3RyaW5nCisgICAgICAgICAgICB0YWJsZV90aXRsZSA9IHVu aWNvZGUodGFibGUuZmluZFByZXZpb3VzU2libGluZygicCIpLnN0cmluZykKICAgICAgICAgICAg IGlmIHRhYmxlX3RpdGxlIG5vdCBpbiBjbHMuZXhwZWN0ZWRfa2V5czoKICAgICAgICAgICAgICAg ICAjIFRoaXMgRXhjZXB0aW9uIHNob3VsZCBvbmx5IGV2ZXIgYmUgaGl0IGlmIHJ1bi13ZWJraXQt dGVzdHMgY2hhbmdlcyBpdHMgcmVzdWx0cy5odG1sIGZvcm1hdC4KLSAgICAgICAgICAgICAgICBy YWlzZSBFeGNlcHRpb24oIlVuaGFuZGxlZCB0aXRsZTogJXMiICUgc3RyKHRhYmxlX3RpdGxlKSkK KyAgICAgICAgICAgICAgICByYWlzZSBFeGNlcHRpb24oIlVuaGFuZGxlZCB0aXRsZTogJXMiICUg dGFibGVfdGl0bGUpCiAgICAgICAgICAgICAjIFdlIG1pZ2h0IHdhbnQgdG8gdHJhbnNsYXRlIHRh YmxlIHRpdGxlcyBpbnRvIGlkZW50aWZpZXJzIGJlZm9yZSBzdG9yaW5nLgotICAgICAgICAgICAg cGFyc2VkX3Jlc3VsdHNbdGFibGVfdGl0bGVdID0gW3Jvdy5maW5kKCJhIikuc3RyaW5nIGZvciBy b3cgaW4gdGFibGUuZmluZEFsbCgidHIiKV0KKyAgICAgICAgICAgIHBhcnNlZF9yZXN1bHRzW3Rh YmxlX3RpdGxlXSA9IFt1bmljb2RlKHJvdy5maW5kKCJhIikuc3RyaW5nKSBmb3Igcm93IGluIHRh YmxlLmZpbmRBbGwoInRyIildCiAKICAgICAgICAgcmV0dXJuIHBhcnNlZF9yZXN1bHRzCiAKQEAg LTM2MSw3ICszNjEsNyBAQCBjbGFzcyBCdWlsZEJvdChvYmplY3QpOgogCiAgICAgICAgICMgRmly c3QgY2VsbCBpcyB0aGUgbmFtZQogICAgICAgICBuYW1lX2xpbmsgPSBzdGF0dXNfY2VsbHNbMF0u ZmluZCgnYScpCi0gICAgICAgIGJ1aWxkZXJbIm5hbWUiXSA9IG5hbWVfbGluay5zdHJpbmcKKyAg ICAgICAgYnVpbGRlclsibmFtZSJdID0gdW5pY29kZShuYW1lX2xpbmsuc3RyaW5nKQogCiAgICAg ICAgIHNlbGYuX3BhcnNlX2xhc3RfYnVpbGRfY2VsbChidWlsZGVyLCBzdGF0dXNfY2VsbHNbMV0p CiAgICAgICAgIHNlbGYuX3BhcnNlX2N1cnJlbnRfYnVpbGRfY2VsbChidWlsZGVyLCBzdGF0dXNf Y2VsbHNbMl0pCkBAIC00MTAsMTMgKzQxMCwxMyBAQCBjbGFzcyBCdWlsZEJvdChvYmplY3QpOgog ICAgICAgICByZXR1cm4gdXJsbGliMi51cmxvcGVuKGJ1aWxkX3N0YXR1c191cmwpCiAKICAgICBk ZWYgX3BhcnNlX3R3aXN0ZWRfZmlsZV9yb3coc2VsZiwgZmlsZV9yb3cpOgotICAgICAgICBzdHJp bmdfb3JfZW1wdHkgPSBsYW1iZGEgc3RyaW5nOiBzdHIoc3RyaW5nKSBpZiBzdHJpbmcgZWxzZSAi IgorICAgICAgICBzdHJpbmdfb3JfZW1wdHkgPSBsYW1iZGEgc291cDogdW5pY29kZShzb3VwLnN0 cmluZykgaWYgc291cC5zdHJpbmcgZWxzZSB1IiIKICAgICAgICAgZmlsZV9jZWxscyA9IGZpbGVf cm93LmZpbmRBbGwoJ3RkJykKICAgICAgICAgcmV0dXJuIHsKLSAgICAgICAgICAgICJmaWxlbmFt ZSIgOiBzdHJpbmdfb3JfZW1wdHkoZmlsZV9jZWxsc1swXS5maW5kKCJhIikuc3RyaW5nKSwKLSAg ICAgICAgICAgICJzaXplIiA6IHN0cmluZ19vcl9lbXB0eShmaWxlX2NlbGxzWzFdLnN0cmluZyks Ci0gICAgICAgICAgICAidHlwZSIgOiBzdHJpbmdfb3JfZW1wdHkoZmlsZV9jZWxsc1syXS5zdHJp bmcpLAotICAgICAgICAgICAgImVuY29kaW5nIiA6IHN0cmluZ19vcl9lbXB0eShmaWxlX2NlbGxz WzNdLnN0cmluZyksCisgICAgICAgICAgICAiZmlsZW5hbWUiOiBzdHJpbmdfb3JfZW1wdHkoZmls ZV9jZWxsc1swXS5maW5kKCJhIikpLAorICAgICAgICAgICAgInNpemUiOiBzdHJpbmdfb3JfZW1w dHkoZmlsZV9jZWxsc1sxXSksCisgICAgICAgICAgICAidHlwZSI6IHN0cmluZ19vcl9lbXB0eShm aWxlX2NlbGxzWzJdKSwKKyAgICAgICAgICAgICJlbmNvZGluZyI6IHN0cmluZ19vcl9lbXB0eShm aWxlX2NlbGxzWzNdKSwKICAgICAgICAgfQogCiAgICAgZGVmIF9wYXJzZV90d2lzdGVkX2RpcmVj dG9yeV9saXN0aW5nKHNlbGYsIHBhZ2UpOgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0 cy93ZWJraXRweS9jb21tb24vbmV0L2J1aWxkYm90X3VuaXR0ZXN0LnB5IGIvV2ViS2l0VG9vbHMv U2NyaXB0cy93ZWJraXRweS9jb21tb24vbmV0L2J1aWxkYm90X3VuaXR0ZXN0LnB5CmluZGV4IGY3 NjVmNmUuLjY3YzQ2ZWQgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkv Y29tbW9uL25ldC9idWlsZGJvdF91bml0dGVzdC5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRz L3dlYmtpdHB5L2NvbW1vbi9uZXQvYnVpbGRib3RfdW5pdHRlc3QucHkKQEAgLTUxLDcgKzUxLDcg QEAgY2xhc3MgQnVpbGRlclRlc3QodW5pdHRlc3QuVGVzdENhc2UpOgogCiAgICAgZGVmIHNldFVw KHNlbGYpOgogICAgICAgICBzZWxmLmJ1aWxkYm90ID0gQnVpbGRCb3QoKQotICAgICAgICBzZWxm LmJ1aWxkZXIgPSBCdWlsZGVyKCJUZXN0IEJ1aWxkZXIiLCBzZWxmLmJ1aWxkYm90KQorICAgICAg ICBzZWxmLmJ1aWxkZXIgPSBCdWlsZGVyKHUiVGVzdCBCdWlsZGVyIFx1MjY2MSIsIHNlbGYuYnVp bGRib3QpCiAgICAgICAgIHNlbGYuX2luc3RhbGxfZmV0Y2hfYnVpbGQobGFtYmRhIGJ1aWxkX251 bWJlcjogWyJ0ZXN0MSIsICJ0ZXN0MiJdKQogCiAgICAgZGVmIHRlc3RfZmluZF9mYWlsdXJlX3Ry YW5zaXRpb24oc2VsZik6CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5 L2NvbW1vbi9uZXQvc3RhdHVzc2VydmVyLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRw eS9jb21tb24vbmV0L3N0YXR1c3NlcnZlci5weQppbmRleCBlODk4N2E5Li5kOWI1MmEyIDEwMDY0 NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9uZXQvc3RhdHVzc2Vy dmVyLnB5CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL25ldC9zdGF0 dXNzZXJ2ZXIucHkKQEAgLTUyLDkgKzUyLDkgQEAgY2xhc3MgU3RhdHVzU2VydmVyOgogICAgICAg ICBpZiBub3QgcGF0Y2g6CiAgICAgICAgICAgICByZXR1cm4KICAgICAgICAgaWYgcGF0Y2guYnVn X2lkKCk6Ci0gICAgICAgICAgICBzZWxmLmJyb3dzZXJbImJ1Z19pZCJdID0gc3RyKHBhdGNoLmJ1 Z19pZCgpKQorICAgICAgICAgICAgc2VsZi5icm93c2VyWyJidWdfaWQiXSA9IHVuaWNvZGUocGF0 Y2guYnVnX2lkKCkpCiAgICAgICAgIGlmIHBhdGNoLmlkKCk6Ci0gICAgICAgICAgICBzZWxmLmJy b3dzZXJbInBhdGNoX2lkIl0gPSBzdHIocGF0Y2guaWQoKSkKKyAgICAgICAgICAgIHNlbGYuYnJv d3NlclsicGF0Y2hfaWQiXSA9IHVuaWNvZGUocGF0Y2guaWQoKSkKIAogICAgIGRlZiBfYWRkX3Jl c3VsdHNfZmlsZShzZWxmLCByZXN1bHRzX2ZpbGUpOgogICAgICAgICBpZiBub3QgcmVzdWx0c19m aWxlOgpAQCAtNzksNyArNzksNyBAQCBjbGFzcyBTdGF0dXNTZXJ2ZXI6CiAgICAgICAgIHVwZGF0 ZV9zdm5fcmV2aXNpb25fdXJsID0gIiVzL3VwZGF0ZS1zdm4tcmV2aXNpb24iICUgc2VsZi51cmwK ICAgICAgICAgc2VsZi5icm93c2VyLm9wZW4odXBkYXRlX3N2bl9yZXZpc2lvbl91cmwpCiAgICAg ICAgIHNlbGYuYnJvd3Nlci5zZWxlY3RfZm9ybShuYW1lPSJ1cGRhdGVfc3ZuX3JldmlzaW9uIikK LSAgICAgICAgc2VsZi5icm93c2VyWyJudW1iZXIiXSA9IHN0cihzdm5fcmV2aXNpb25fbnVtYmVy KQorICAgICAgICBzZWxmLmJyb3dzZXJbIm51bWJlciJdID0gdW5pY29kZShzdm5fcmV2aXNpb25f bnVtYmVyKQogICAgICAgICBzZWxmLmJyb3dzZXJbImJyb2tlbl9ib3QiXSA9IGJyb2tlbl9ib3QK ICAgICAgICAgcmV0dXJuIHNlbGYuYnJvd3Nlci5zdWJtaXQoKS5yZWFkKCkKIApkaWZmIC0tZ2l0 IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vcHJldHR5cGF0Y2gucHkgYi9X ZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9wcmV0dHlwYXRjaC5weQppbmRleCA4 MTU3ZjljLi5lN2M4NzZhIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5 L2NvbW1vbi9wcmV0dHlwYXRjaC5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5 L2NvbW1vbi9wcmV0dHlwYXRjaC5weQpAQCAtMzgsNyArMzgsNyBAQCBjbGFzcyBQcmV0dHlQYXRj aChvYmplY3QpOgogICAgIGRlZiBwcmV0dHlfZGlmZl9maWxlKHNlbGYsIGRpZmYpOgogICAgICAg ICBwcmV0dHlfZGlmZiA9IHNlbGYucHJldHR5X2RpZmYoZGlmZikKICAgICAgICAgZGlmZl9maWxl ID0gdGVtcGZpbGUuTmFtZWRUZW1wb3JhcnlGaWxlKHN1ZmZpeD0iLmh0bWwiKQotICAgICAgICBk aWZmX2ZpbGUud3JpdGUocHJldHR5X2RpZmYpCisgICAgICAgIGRpZmZfZmlsZS53cml0ZShwcmV0 dHlfZGlmZi5lbmNvZGUoInV0Zi04IikpCiAgICAgICAgIGRpZmZfZmlsZS5mbHVzaCgpCiAgICAg ICAgIHJldHVybiBkaWZmX2ZpbGUKIApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93 ZWJraXRweS9jb21tb24vc3lzdGVtL2F1dG9pbnN0YWxsLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0 cy93ZWJraXRweS9jb21tb24vc3lzdGVtL2F1dG9pbnN0YWxsLnB5CmluZGV4IDMyZmQyY2YuLmQ1 NjYwYWMgMTAwNzU1Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL3N5 c3RlbS9hdXRvaW5zdGFsbC5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2Nv bW1vbi9zeXN0ZW0vYXV0b2luc3RhbGwucHkKQEAgLTMwLDYgKzMwLDEwIEBACiAKICIiIlN1cHBv cnQgZm9yIGF1dG9tYXRpY2FsbHkgZG93bmxvYWRpbmcgUHl0aG9uIHBhY2thZ2VzIGZyb20gYW4g VVJMLiIiIgogCisKK2Zyb20gX19mdXR1cmVfXyBpbXBvcnQgd2l0aF9zdGF0ZW1lbnQKKworaW1w b3J0IGNvZGVjcwogaW1wb3J0IGxvZ2dpbmcKIGltcG9ydCBuZXcKIGltcG9ydCBvcwpAQCAtMTE0 LDcgKzExOCw3IEBAIGNsYXNzIEF1dG9JbnN0YWxsZXIob2JqZWN0KToKIAogICAgICAgICBvcy5t YWtlZGlycyhwYXRoKQogCi0gICAgZGVmIF93cml0ZV9maWxlKHNlbGYsIHBhdGgsIHRleHQpOgor ICAgIGRlZiBfd3JpdGVfZmlsZShzZWxmLCBwYXRoLCB0ZXh0LCBlbmNvZGluZyk6CiAgICAgICAg ICIiIkNyZWF0ZSBhIGZpbGUgYXQgdGhlIGdpdmVuIHBhdGggd2l0aCBnaXZlbiB0ZXh0LgogCiAg ICAgICAgIFRoaXMgbWV0aG9kIG92ZXJ3cml0ZXMgYW55IGV4aXN0aW5nIGZpbGUuCkBAIC0xMjIs MTEgKzEyNiw4IEBAIGNsYXNzIEF1dG9JbnN0YWxsZXIob2JqZWN0KToKICAgICAgICAgIiIiCiAg ICAgICAgIF9sb2cuZGVidWcoIkNyZWF0aW5nIGZpbGUuLi4iKQogICAgICAgICBfbG9nLmRlYnVn KCcgICAgIiVzIicgJSBwYXRoKQotICAgICAgICBmaWxlID0gb3BlbihwYXRoLCAidyIpCi0gICAg ICAgIHRyeToKKyAgICAgICAgd2l0aCBjb2RlY3Mub3BlbihwYXRoLCAidyIsIGVuY29kaW5nKSBh cyBmaWxlOgogICAgICAgICAgICAgZmlsZS53cml0ZSh0ZXh0KQotICAgICAgICBmaW5hbGx5Ogot ICAgICAgICAgICAgZmlsZS5jbG9zZSgpCiAKICAgICBkZWYgX3NldF91cF90YXJnZXRfZGlyKHNl bGYsIHRhcmdldF9kaXIsIGFwcGVuZF90b19zZWFyY2hfcGF0aCwKICAgICAgICAgICAgICAgICAg ICAgICAgICAgIG1ha2VfcGFja2FnZSk6CkBAIC0xNTQsNyArMTU1LDcgQEAgY2xhc3MgQXV0b0lu c3RhbGxlcihvYmplY3QpOgogICAgICAgICAgICAgaWYgbm90IG9zLnBhdGguZXhpc3RzKGluaXRf cGF0aCk6CiAgICAgICAgICAgICAgICAgdGV4dCA9ICgiIyBUaGlzIGZpbGUgaXMgcmVxdWlyZWQg Zm9yIFB5dGhvbiB0byBzZWFyY2ggdGhpcyAiCiAgICAgICAgICAgICAgICAgICAgICAgICAiZGly ZWN0b3J5IGZvciBtb2R1bGVzLlxuIikKLSAgICAgICAgICAgICAgICBzZWxmLl93cml0ZV9maWxl KGluaXRfcGF0aCwgdGV4dCkKKyAgICAgICAgICAgICAgICBzZWxmLl93cml0ZV9maWxlKGluaXRf cGF0aCwgdGV4dCwgImFzY2lpIikKIAogICAgIGRlZiBfY3JlYXRlX3NjcmF0Y2hfZGlyZWN0b3J5 X2lubmVyKHNlbGYsIHByZWZpeCk6CiAgICAgICAgICIiIkNyZWF0ZSBhIHNjcmF0Y2ggZGlyZWN0 b3J5IHdpdGhvdXQgZXhjZXB0aW9uIGhhbmRsaW5nLgpAQCAtMjE2LDExICsyMTcsOCBAQCBjbGFz cyBBdXRvSW5zdGFsbGVyKG9iamVjdCk6CiAgICAgICAgICAgICBfbG9nLmRlYnVnKCJObyBVUkwg ZmlsZSBmb3VuZC4iKQogICAgICAgICAgICAgcmV0dXJuIEZhbHNlCiAKLSAgICAgICAgZmlsZSA9 IG9wZW4odmVyc2lvbl9wYXRoLCAiciIpCi0gICAgICAgIHRyeToKKyAgICAgICAgd2l0aCBjb2Rl Y3Mub3Blbih2ZXJzaW9uX3BhdGgsICJyIiwgInV0Zi04IikgYXMgZmlsZToKICAgICAgICAgICAg IHZlcnNpb24gPSBmaWxlLnJlYWQoKQotICAgICAgICBmaW5hbGx5OgotICAgICAgICAgICAgZmls ZS5jbG9zZSgpCiAKICAgICAgICAgcmV0dXJuIHZlcnNpb24uc3RyaXAoKSA9PSB1cmwuc3RyaXAo KQogCkBAIC0yMzEsNyArMjI5LDcgQEAgY2xhc3MgQXV0b0luc3RhbGxlcihvYmplY3QpOgogICAg ICAgICBfbG9nLmRlYnVnKCcgICAgVVJMOiAiJXMiJyAlIHVybCkKICAgICAgICAgX2xvZy5kZWJ1 ZygnICAgICBUbzogIiVzIicgJSB2ZXJzaW9uX3BhdGgpCiAKLSAgICAgICAgc2VsZi5fd3JpdGVf ZmlsZSh2ZXJzaW9uX3BhdGgsIHVybCkKKyAgICAgICAgc2VsZi5fd3JpdGVfZmlsZSh2ZXJzaW9u X3BhdGgsIHVybCwgInV0Zi04IikKIAogICAgIGRlZiBfZXh0cmFjdF90YXJneihzZWxmLCBwYXRo LCBzY3JhdGNoX2Rpcik6CiAgICAgICAgICMgdGFyZmlsZS5leHRyYWN0YWxsKCkgZXh0cmFjdHMg dG8gYSBwYXRoIHdpdGhvdXQgdGhlCkBAIC0yODQsNiArMjgyLDggQEAgY2xhc3MgQXV0b0luc3Rh bGxlcihvYmplY3QpOgogICAgICAgICAgICAgIyBPdGhlcndpc2UsIGl0IGlzIGEgZmlsZS4KIAog ICAgICAgICAgICAgdHJ5OgorICAgICAgICAgICAgICAgICMgV2Ugb3BlbiB0aGlzIGZpbGUgdy9v IGVuY29kaW5nLCBhcyB3ZSdyZSByZWFkaW5nL3dyaXRpbmcKKyAgICAgICAgICAgICAgICAjIHRo ZSByYXcgYnl0ZS1zdHJlYW0gZnJvbSB0aGUgemlwIGZpbGUuCiAgICAgICAgICAgICAgICAgb3V0 ZmlsZSA9IG9wZW4ocGF0aCwgJ3diJykKICAgICAgICAgICAgIGV4Y2VwdCBJT0Vycm9yLCBlcnI6 CiAgICAgICAgICAgICAgICAgIyBOb3QgYWxsIHppcCBmaWxlcyBzZWVtIHRvIGxpc3QgdGhlIGRp cmVjdG9yaWVzIGV4cGxpY2l0bHksCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dl YmtpdHB5L2NvbW1vbi9zeXN0ZW0vZGVwcmVjYXRlZF9sb2dnaW5nLnB5IGIvV2ViS2l0VG9vbHMv U2NyaXB0cy93ZWJraXRweS9jb21tb24vc3lzdGVtL2RlcHJlY2F0ZWRfbG9nZ2luZy5weQppbmRl eCBiYTFjNWViLi45ZTZiNTI5IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtp dHB5L2NvbW1vbi9zeXN0ZW0vZGVwcmVjYXRlZF9sb2dnaW5nLnB5CisrKyBiL1dlYktpdFRvb2xz L1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL3N5c3RlbS9kZXByZWNhdGVkX2xvZ2dpbmcucHkKQEAg LTMwLDI0ICszMCwzMCBAQAogIyBXZWJLaXQncyBQeXRob24gbW9kdWxlIGZvciBsb2dnaW5nCiAj IFRoaXMgbW9kdWxlIGlzIG5vdyBkZXByZWNhdGVkIGluIGZhdm9yIG9mIHB5dGhvbidzIGJ1aWx0 LWluIGxvZ2dpbmcucHkuCiAKK2ltcG9ydCBjb2RlY3MKIGltcG9ydCBvcwogaW1wb3J0IHN5cwog CisKIGRlZiBsb2coc3RyaW5nKToKICAgICBwcmludCA+PiBzeXMuc3RkZXJyLCBzdHJpbmcKIAor CiBkZWYgZXJyb3Ioc3RyaW5nKToKICAgICBsb2coIkVSUk9SOiAlcyIgJSBzdHJpbmcpCiAgICAg ZXhpdCgxKQogCisKICMgU2ltcGxlIGNsYXNzIHRvIHNwbGl0IG91dHB1dCBiZXR3ZWVuIG11bHRp cGxlIGRlc3RpbmF0aW9ucwogY2xhc3MgdGVlOgogICAgIGRlZiBfX2luaXRfXyhzZWxmLCAqZmls ZXMpOgogICAgICAgICBzZWxmLmZpbGVzID0gZmlsZXMKIAotICAgIGRlZiB3cml0ZShzZWxmLCBz dHJpbmcpOgorICAgICMgQ2FsbGVycyBzaG91bGQgcGFzcyBhbiBhbHJlYWR5IGVuY29kZWQgc3Ry aW5nIGZvciB3cml0aW5nLgorICAgIGRlZiB3cml0ZShzZWxmLCBieXRlcyk6CiAgICAgICAgIGZv ciBmaWxlIGluIHNlbGYuZmlsZXM6Ci0gICAgICAgICAgICBmaWxlLndyaXRlKHN0cmluZykKKyAg ICAgICAgICAgIGZpbGUud3JpdGUoYnl0ZXMpCisKIAogY2xhc3MgT3V0cHV0VGVlOgogICAgIGRl ZiBfX2luaXRfXyhzZWxmKToKQEAgLTcxLDcgKzc3LDcgQEAgY2xhc3MgT3V0cHV0VGVlOgogICAg ICAgICAobG9nX2RpcmVjdG9yeSwgbG9nX25hbWUpID0gb3MucGF0aC5zcGxpdChsb2dfcGF0aCkK ICAgICAgICAgaWYgbG9nX2RpcmVjdG9yeSBhbmQgbm90IG9zLnBhdGguZXhpc3RzKGxvZ19kaXJl Y3RvcnkpOgogICAgICAgICAgICAgb3MubWFrZWRpcnMobG9nX2RpcmVjdG9yeSkKLSAgICAgICAg cmV0dXJuIG9wZW4obG9nX3BhdGgsICdhKycpCisgICAgICAgIHJldHVybiBjb2RlY3Mub3Blbihs b2dfcGF0aCwgImErIiwgInV0Zi04IikKIAogICAgIGRlZiBfdGVlX291dHB1dHNfdG9fZmlsZXMo c2VsZiwgZmlsZXMpOgogICAgICAgICBpZiBub3Qgc2VsZi5fb3JpZ2luYWxfc3Rkb3V0OgpkaWZm IC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vc3lzdGVtL2V4ZWN1 dGl2ZS5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL3N5c3RlbS9leGVj dXRpdmUucHkKaW5kZXggYjYxMjZlNC4uOTliY2YyNCAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMv U2NyaXB0cy93ZWJraXRweS9jb21tb24vc3lzdGVtL2V4ZWN1dGl2ZS5weQorKysgYi9XZWJLaXRU b29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9zeXN0ZW0vZXhlY3V0aXZlLnB5CkBAIC04OCw2 ICs4OCw3IEBAIGRlZiBydW5fY29tbWFuZCgqYXJncywgKiprd2FyZ3MpOgogY2xhc3MgRXhlY3V0 aXZlKG9iamVjdCk6CiAKICAgICBkZWYgX3J1bl9jb21tYW5kX3dpdGhfdGVlZF9vdXRwdXQoc2Vs ZiwgYXJncywgdGVlZF9vdXRwdXQpOgorICAgICAgICBhcmdzID0gbWFwKHVuaWNvZGUsIGFyZ3Mp ICAjIFBvcGVuIHdpbGwgdGhyb3cgYW4gZXhjZXB0aW9uIGlmIGFyZ3MgYXJlIG5vbi1zdHJpbmdz IChsaWtlIGludCgpKQogICAgICAgICBjaGlsZF9wcm9jZXNzID0gc3VicHJvY2Vzcy5Qb3Blbihh cmdzLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdGRvdXQ9c3Vi cHJvY2Vzcy5QSVBFLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBz dGRlcnI9c3VicHJvY2Vzcy5TVERPVVQpCkBAIC05OSwxNCArMTAwLDIxIEBAIGNsYXNzIEV4ZWN1 dGl2ZShvYmplY3QpOgogICAgICAgICAgICAgb3V0cHV0X2xpbmUgPSBjaGlsZF9wcm9jZXNzLnN0 ZG91dC5yZWFkbGluZSgpCiAgICAgICAgICAgICBpZiBvdXRwdXRfbGluZSA9PSAiIiBhbmQgY2hp bGRfcHJvY2Vzcy5wb2xsKCkgIT0gTm9uZToKICAgICAgICAgICAgICAgICByZXR1cm4gY2hpbGRf cHJvY2Vzcy5wb2xsKCkKKyAgICAgICAgICAgICMgV2UgYXNzdW1lIHRoYXQgdGhlIGNoaWxkIHBy b2Nlc3Mgd3JvdGUgdG8gdXMgaW4gdXRmLTgsCisgICAgICAgICAgICAjIHNvIG5vIHJlLWVuY29k aW5nIGlzIG5lY2Vzc2FyeSBiZWZvcmUgd3JpdGluZyBoZXJlLgogICAgICAgICAgICAgdGVlZF9v dXRwdXQud3JpdGUob3V0cHV0X2xpbmUpCiAKLSAgICBkZWYgcnVuX2FuZF90aHJvd19pZl9mYWls KHNlbGYsIGFyZ3MsIHF1aWV0PUZhbHNlKToKKyAgICAjIEZJWE1FOiBSZW1vdmUgdGhpcyBkZXBy ZWNhdGVkIG1ldGhvZCBhbmQgbW92ZSBjYWxsZXJzIHRvIHJ1bl9jb21tYW5kLgorICAgICMgRklY TUU6IFRoaXMgbWV0aG9kIGlzIGEgaGFjayB0byBhbGxvdyBydW5uaW5nIGNvbW1hbmQgd2hpY2gg Ym90aAorICAgICMgY2FwdHVyZSB0aGVpciBvdXRwdXQgYW5kIHByaW50IG91dCB0byBzdGRpbi4g IFVzZWZ1bCBmb3IgdGhpbmdzCisgICAgIyBsaWtlICJidWlsZC13ZWJraXQiIHdoZXJlIHdlIHdh bnQgdG8gZGlzcGxheSB0byB0aGUgdXNlciB0aGF0IHdlJ3JlIGJ1aWxkaW5nCisgICAgIyBidXQg c3RpbGwgaGF2ZSB0aGUgb3V0cHV0IHRvIHN0dWZmIGludG8gYSBsb2cgZmlsZS4KKyAgICBkZWYg cnVuX2FuZF90aHJvd19pZl9mYWlsKHNlbGYsIGFyZ3MsIHF1aWV0PUZhbHNlLCBkZWNvZGVfb3V0 cHV0PVRydWUpOgogICAgICAgICAjIENhY2hlIHRoZSBjaGlsZCdzIG91dHB1dCBsb2NhbGx5IHNv IGl0IGNhbiBiZSB1c2VkIGZvciBlcnJvciByZXBvcnRzLgogICAgICAgICBjaGlsZF9vdXRfZmls ZSA9IFN0cmluZ0lPLlN0cmluZ0lPKCkKICAgICAgICAgdGVlX3N0ZG91dCA9IHN5cy5zdGRvdXQK ICAgICAgICAgaWYgcXVpZXQ6Ci0gICAgICAgICAgICBkZXZfbnVsbCA9IG9wZW4ob3MuZGV2bnVs bCwgInciKQorICAgICAgICAgICAgZGV2X251bGwgPSBvcGVuKG9zLmRldm51bGwsICJ3IikgICMg RklYTUU6IERvZXMgdGhpcyBuZWVkIGFuIGVuY29kaW5nPwogICAgICAgICAgICAgdGVlX3N0ZG91 dCA9IGRldl9udWxsCiAgICAgICAgIGNoaWxkX3N0ZG91dCA9IHRlZShjaGlsZF9vdXRfZmlsZSwg dGVlX3N0ZG91dCkKICAgICAgICAgZXhpdF9jb2RlID0gc2VsZi5fcnVuX2NvbW1hbmRfd2l0aF90 ZWVkX291dHB1dChhcmdzLCBjaGlsZF9zdGRvdXQpCkBAIC0xMTYsNiArMTI0LDEwIEBAIGNsYXNz IEV4ZWN1dGl2ZShvYmplY3QpOgogICAgICAgICBjaGlsZF9vdXRwdXQgPSBjaGlsZF9vdXRfZmls ZS5nZXR2YWx1ZSgpCiAgICAgICAgIGNoaWxkX291dF9maWxlLmNsb3NlKCkKIAorICAgICAgICAj IFdlIGFzc3VtZSB0aGUgY2hpbGQgcHJvY2VzcyBvdXRwdXQgdXRmLTgKKyAgICAgICAgaWYgZGVj b2RlX291dHB1dDoKKyAgICAgICAgICAgIGNoaWxkX291dHB1dCA9IGNoaWxkX291dHB1dC5kZWNv ZGUoInV0Zi04IikKKwogICAgICAgICBpZiBleGl0X2NvZGU6CiAgICAgICAgICAgICByYWlzZSBT Y3JpcHRFcnJvcihzY3JpcHRfYXJncz1hcmdzLAogICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgZXhpdF9jb2RlPWV4aXRfY29kZSwKQEAgLTE0NSw3ICsxNTcsNyBAQCBjbGFzcyBFeGVjdXRp dmUob2JqZWN0KToKICAgICAgICAgICAgICMgb3Mua2lsbCBpc24ndCBhdmFpbGFibGUgb24gV2lu ZG93cy4gIEhvd2V2ZXIsIHdoZW4gSSB0cmllZCBpdAogICAgICAgICAgICAgIyB1c2luZyBDeWd3 aW4sIGl0IHdvcmtlZCBmaW5lLiAgV2Ugc2hvdWxkIGludmVzdGlnYXRlIHdoZXRoZXIKICAgICAg ICAgICAgICMgd2UgbmVlZCB0aGlzIHBsYXRmb3JtIHNwZWNpZmljIGNvZGUgaGVyZS4KLSAgICAg ICAgICAgIHN1YnByb2Nlc3MuY2FsbCgoJ3Rhc2traWxsLmV4ZScsICcvZicsICcvcGlkJywgc3Ry KHBpZCkpLAorICAgICAgICAgICAgc3VicHJvY2Vzcy5jYWxsKCgndGFza2tpbGwuZXhlJywgJy9m JywgJy9waWQnLCB1bmljb2RlKHBpZCkpLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN0 ZGluPW9wZW4ob3MuZGV2bnVsbCwgJ3InKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBz dGRvdXQ9c3VicHJvY2Vzcy5QSVBFLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN0ZGVy cj1zdWJwcm9jZXNzLlBJUEUpCkBAIC0xNjMsMzEgKzE3NSwzNCBAQCBjbGFzcyBFeGVjdXRpdmUo b2JqZWN0KToKICAgICBkZWYgaWdub3JlX2Vycm9yKGVycm9yKToKICAgICAgICAgcGFzcwogCi0g ICAgIyBGSVhNRTogVGhpcyBzaG91bGQgYmUgbWVyZ2VkIHdpdGggcnVuX2FuZF90aHJvd19pZl9m YWlsCi0KKyAgICBkZWYgX2NvbXB1dGVfc3RkaW4oc2VsZiwgaW5wdXQpOgorICAgICAgICAiIiJS ZXR1cm5zIChzdGRpbiwgc3RyaW5nX3RvX2NvbW11bmljYXRlKSIiIgorICAgICAgICBpZiBub3Qg aW5wdXQ6CisgICAgICAgICAgICByZXR1cm4gKE5vbmUsIE5vbmUpCisgICAgICAgIGlmIGhhc2F0 dHIoaW5wdXQsICJyZWFkIik6ICAjIENoZWNrIGlmIHRoZSBpbnB1dCBpcyBhIGZpbGUuCisgICAg ICAgICAgICByZXR1cm4gKGlucHV0LCBOb25lKSAgIyBBc3N1bWUgdGhlIGZpbGUgaXMgaW4gdGhl IHJpZ2h0IGVuY29kaW5nLgorCisgICAgICAgICMgUG9wZW4gaW4gUHl0aG9uIDIuNSBhbmQgYmVm b3JlIGRvZXMgbm90IGF1dG9tYXRpY2FsbHkgZW5jb2RlIHVuaWNvZGUgb2JqZWN0cy4KKyAgICAg ICAgIyBodHRwOi8vYnVncy5weXRob24ub3JnL2lzc3VlNTI5MAorICAgICAgICAjIFNlZSBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzc1MjgKKyAgICAgICAgIyBmb3Ig YW4gZXhhbXBsZSBvZiBhIHJlZ3Jlc2lvbiBjYXVzZWQgYnkgcGFzc2luZyBhIHVuaWNvZGUgc3Ry aW5nIGRpcmVjdGx5LgorICAgICAgICAjIEZJWE1FOiBXZSBtYXkgbmVlZCB0byBlbmNvZGUgZGlm ZmVyZW50bHkgb24gZGlmZmVyZW50IHBsYXRmb3Jtcy4KKyAgICAgICAgaWYgaXNpbnN0YW5jZShp bnB1dCwgdW5pY29kZSk6CisgICAgICAgICAgICBpbnB1dCA9IGlucHV0LmVuY29kZSgidXRmLTgi KQorICAgICAgICByZXR1cm4gKHN1YnByb2Nlc3MuUElQRSwgaW5wdXQpCisKKyAgICAjIEZJWE1F OiBydW5fYW5kX3Rocm93X2lmX2ZhaWwgc2hvdWxkIGJlIG1lcmdlZCBpbnRvIHRoaXMgbWV0aG9k LgogICAgIGRlZiBydW5fY29tbWFuZChzZWxmLAogICAgICAgICAgICAgICAgICAgICBhcmdzLAog ICAgICAgICAgICAgICAgICAgICBjd2Q9Tm9uZSwKICAgICAgICAgICAgICAgICAgICAgaW5wdXQ9 Tm9uZSwKICAgICAgICAgICAgICAgICAgICAgZXJyb3JfaGFuZGxlcj1Ob25lLAogICAgICAgICAg ICAgICAgICAgICByZXR1cm5fZXhpdF9jb2RlPUZhbHNlLAotICAgICAgICAgICAgICAgICAgICBy ZXR1cm5fc3RkZXJyPVRydWUpOgotICAgICAgICBpZiBoYXNhdHRyKGlucHV0LCAncmVhZCcpOiAj IENoZWNrIGlmIHRoZSBpbnB1dCBpcyBhIGZpbGUuCi0gICAgICAgICAgICBzdGRpbiA9IGlucHV0 Ci0gICAgICAgICAgICBzdHJpbmdfdG9fY29tbXVuaWNhdGUgPSBOb25lCi0gICAgICAgIGVsc2U6 Ci0gICAgICAgICAgICBzdGRpbiA9IE5vbmUKLSAgICAgICAgICAgIGlmIGlucHV0OgotICAgICAg ICAgICAgICAgIHN0ZGluID0gc3VicHJvY2Vzcy5QSVBFCi0gICAgICAgICAgICAjIHN0cmluZ190 b19jb21tdW5pY2F0ZSBzZWVtcyB0byBuZWVkIHRvIGJlIGEgc3RyIGZvciBwcm9wZXIKLSAgICAg ICAgICAgICMgY29tbXVuaWNhdGlvbiB3aXRoIHNoZWxsIGNvbW1hbmRzLgotICAgICAgICAgICAg IyBTZWUgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM3NTI4Ci0gICAg ICAgICAgICAjIEZvciBhbiBleGFtcGxlIG9mIGEgcmVncmVzaW9uIGNhdXNlZCBieSBwYXNzaW5n IGEgdW5pY29kZSBzdHJpbmcgdGhyb3VnaC4KLSAgICAgICAgICAgIHN0cmluZ190b19jb21tdW5p Y2F0ZSA9IHN0cihpbnB1dCkKLSAgICAgICAgaWYgcmV0dXJuX3N0ZGVycjoKLSAgICAgICAgICAg IHN0ZGVyciA9IHN1YnByb2Nlc3MuU1RET1VUCi0gICAgICAgIGVsc2U6Ci0gICAgICAgICAgICBz dGRlcnIgPSBOb25lCisgICAgICAgICAgICAgICAgICAgIHJldHVybl9zdGRlcnI9VHJ1ZSwKKyAg ICAgICAgICAgICAgICAgICAgZGVjb2RlX291dHB1dD1UcnVlKToKKyAgICAgICAgYXJncyA9IG1h cCh1bmljb2RlLCBhcmdzKSAgIyBQb3BlbiB3aWxsIHRocm93IGFuIGV4Y2VwdGlvbiBpZiBhcmdz IGFyZSBub24tc3RyaW5ncyAobGlrZSBpbnQoKSkKKyAgICAgICAgc3RkaW4sIHN0cmluZ190b19j b21tdW5pY2F0ZSA9IHNlbGYuX2NvbXB1dGVfc3RkaW4oaW5wdXQpCisgICAgICAgIHN0ZGVyciA9 IHN1YnByb2Nlc3MuU1RET1VUIGlmIHJldHVybl9zdGRlcnIgZWxzZSBOb25lCiAKICAgICAgICAg cHJvY2VzcyA9IHN1YnByb2Nlc3MuUG9wZW4oYXJncywKICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgc3RkaW49c3RkaW4sCkBAIC0xOTUsNiArMjEwLDkgQEAgY2xhc3MgRXhlY3V0 aXZlKG9iamVjdCk6CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN0ZGVycj1z dGRlcnIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGN3ZD1jd2QpCiAgICAg ICAgIG91dHB1dCA9IHByb2Nlc3MuY29tbXVuaWNhdGUoc3RyaW5nX3RvX2NvbW11bmljYXRlKVsw XQorICAgICAgICAjIHJ1bl9jb21tYW5kIGF1dG9tYXRpY2FsbHkgZGVjb2RlcyB0byB1bmljb2Rl KCkgdW5sZXNzIGV4cGxpY2l0bHkgdG9sZCBub3QgdG8uCisgICAgICAgIGlmIGRlY29kZV9vdXRw dXQ6CisgICAgICAgICAgICBvdXRwdXQgPSBvdXRwdXQuZGVjb2RlKCJ1dGYtOCIpCiAgICAgICAg IGV4aXRfY29kZSA9IHByb2Nlc3Mud2FpdCgpCiAKICAgICAgICAgaWYgcmV0dXJuX2V4aXRfY29k ZToKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL3N5c3Rl bS9leGVjdXRpdmVfdW5pdHRlc3QucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2Nv bW1vbi9zeXN0ZW0vZXhlY3V0aXZlX3VuaXR0ZXN0LnB5CmluZGV4IGFjMzgwZjguLjY0YzU1MmIg MTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL3N5c3RlbS9l eGVjdXRpdmVfdW5pdHRlc3QucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9j b21tb24vc3lzdGVtL2V4ZWN1dGl2ZV91bml0dGVzdC5weQpAQCAtMSw0ICsxLDQgQEAKLSMgQ29w eXJpZ2h0IChDKSAyMDA5IEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisjIENvcHly aWdodCAoQykgMjAxMCBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogIyBDb3B5cmln aHQgKEMpIDIwMDkgRGFuaWVsIEJhdGVzIChkYmF0ZXNAaW50dWRhdGEuY29tKS4gQWxsIHJpZ2h0 cyByZXNlcnZlZC4KICMKICMgUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJp bmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CkBAIC0zMSw2ICszMSw3IEBAIGltcG9ydCB1bml0 dGVzdAogCiBmcm9tIHdlYmtpdHB5LmNvbW1vbi5zeXN0ZW0uZXhlY3V0aXZlIGltcG9ydCBFeGVj dXRpdmUsIHJ1bl9jb21tYW5kCiAKKwogY2xhc3MgRXhlY3V0aXZlVGVzdCh1bml0dGVzdC5UZXN0 Q2FzZSk6CiAKICAgICBkZWYgdGVzdF9ydW5fY29tbWFuZF93aXRoX2JhZF9jb21tYW5kKHNlbGYp OgpAQCAtMzgsNSArMzksMjYgQEAgY2xhc3MgRXhlY3V0aXZlVGVzdCh1bml0dGVzdC5UZXN0Q2Fz ZSk6CiAgICAgICAgICAgICBydW5fY29tbWFuZChbImZvb19iYXJfY29tbWFuZF9ibGFoIl0sIGVy cm9yX2hhbmRsZXI9RXhlY3V0aXZlLmlnbm9yZV9lcnJvciwgcmV0dXJuX2V4aXRfY29kZT1UcnVl KQogICAgICAgICBzZWxmLmZhaWxVbmxlc3NSYWlzZXMoT1NFcnJvciwgcnVuX2JhZF9jb21tYW5k KQogCi1pZiBfX25hbWVfXyA9PSAnX19tYWluX18nOgotICAgIHVuaXR0ZXN0Lm1haW4oKQorICAg IGRlZiB0ZXN0X3J1bl9jb21tYW5kX3dpdGhfdW5pY29kZShzZWxmKToKKyAgICAgICAgIiIiVmFs aWRhdGUgdGhhdCBpdCBpcyBzYWZlIHRvIHBhc3MgdW5pY29kZSgpIG9iamVjdHMKKyAgICAgICAg dG8gRXhlY3V0aXZlLnJ1biogbWV0aG9kcywgYW5kIHRoZXkgd2lsbCByZXR1cm4gdW5pY29kZSgp CisgICAgICAgIG9iamVjdHMgYnkgZGVmYXVsdCB1bmxlc3MgZGVjb2RlX291dHB1dD1GYWxzZSIi IgorICAgICAgICBleGVjdXRpdmUgPSBFeGVjdXRpdmUoKQorICAgICAgICB1bmljb2RlX3RvciA9 IHUiV2ViS2l0IFx1MjY2MSBUb3IgQXJuZSBWZXN0Ylx1MDBGOCEiCisgICAgICAgIHV0ZjhfdG9y ID0gdW5pY29kZV90b3IuZW5jb2RlKCJ1dGYtOCIpCisKKyAgICAgICAgb3V0cHV0ID0gZXhlY3V0 aXZlLnJ1bl9jb21tYW5kKFsiY2F0Il0sIGlucHV0PXVuaWNvZGVfdG9yKQorICAgICAgICBzZWxm LmFzc2VydEVxdWFscyhvdXRwdXQsIHVuaWNvZGVfdG9yKQorCisgICAgICAgIG91dHB1dCA9IGV4 ZWN1dGl2ZS5ydW5fY29tbWFuZChbImVjaG8iLCAiLW4iLCB1bmljb2RlX3Rvcl0pCisgICAgICAg IHNlbGYuYXNzZXJ0RXF1YWxzKG91dHB1dCwgdW5pY29kZV90b3IpCisKKyAgICAgICAgb3V0cHV0 ID0gZXhlY3V0aXZlLnJ1bl9jb21tYW5kKFsiZWNobyIsICItbiIsIHVuaWNvZGVfdG9yXSwgZGVj b2RlX291dHB1dD1GYWxzZSkKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbHMob3V0cHV0LCB1dGY4 X3RvcikKKworICAgICAgICAjIEZJWE1FOiBXZSBzaG91bGQgb25seSBoYXZlIG9uZSBydW4qIG1l dGhvZCB0byB0ZXN0CisgICAgICAgIG91dHB1dCA9IGV4ZWN1dGl2ZS5ydW5fYW5kX3Rocm93X2lm X2ZhaWwoWyJlY2hvIiwgIi1uIiwgdW5pY29kZV90b3JdLCBxdWlldD1UcnVlKQorICAgICAgICBz ZWxmLmFzc2VydEVxdWFscyhvdXRwdXQsIHVuaWNvZGVfdG9yKQorCisgICAgICAgIG91dHB1dCA9 IGV4ZWN1dGl2ZS5ydW5fYW5kX3Rocm93X2lmX2ZhaWwoWyJlY2hvIiwgIi1uIiwgdW5pY29kZV90 b3JdLCBxdWlldD1UcnVlLCBkZWNvZGVfb3V0cHV0PUZhbHNlKQorICAgICAgICBzZWxmLmFzc2Vy dEVxdWFscyhvdXRwdXQsIHV0ZjhfdG9yKQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0 cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvbGF5b3V0X3BhY2thZ2UvZHVtcF9yZW5kZXJfdHJlZV90 aHJlYWQucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9sYXlv dXRfcGFja2FnZS9kdW1wX3JlbmRlcl90cmVlX3RocmVhZC5weQppbmRleCBlNjFkMTFmLi4xZTQx MmEzIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0 cy9sYXlvdXRfcGFja2FnZS9kdW1wX3JlbmRlcl90cmVlX3RocmVhZC5weQorKysgYi9XZWJLaXRU b29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9sYXlvdXRfcGFja2FnZS9kdW1wX3Jl bmRlcl90cmVlX3RocmVhZC5weQpAQCAtMzUsNiArMzUsOSBAQCB0aGUgb3V0cHV0LiAgV2hlbiB0 aGVyZSBhcmUgbm8gbW9yZSBVUkxzIHRvIHByb2Nlc3MgaW4gdGhlIHNoYXJlZCBxdWV1ZSwgdGhl CiB0aHJlYWQgZXhpdHMuCiAiIiIKIAorZnJvbSBfX2Z1dHVyZV9fIGltcG9ydCB3aXRoX3N0YXRl bWVudAorCitpbXBvcnQgY29kZWNzCiBpbXBvcnQgY29weQogaW1wb3J0IGxvZ2dpbmcKIGltcG9y dCBvcwpAQCAtODksNyArOTIsOCBAQCBkZWYgcHJvY2Vzc19vdXRwdXQocG9ydCwgdGVzdF9pbmZv LCB0ZXN0X3R5cGVzLCB0ZXN0X2FyZ3MsIGNvbmZpZ3VyYXRpb24sCiAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIHRlc3RfaW5mby5maWxlbmFtZSkpCiAgICAgICAgIGZpbGVuYW1lID0g b3MucGF0aC5zcGxpdGV4dChmaWxlbmFtZSlbMF0gKyAiLXN0YWNrLnR4dCIKICAgICAgICAgcG9y dC5tYXliZV9tYWtlX2RpcmVjdG9yeShvcy5wYXRoLnNwbGl0KGZpbGVuYW1lKVswXSkKLSAgICAg ICAgb3BlbihmaWxlbmFtZSwgIndiIikud3JpdGUoZXJyb3IpICAjIEZJWE1FOiBUaGlzIGxlYWtz IGEgZmlsZSBoYW5kbGUuCisgICAgICAgIHdpdGggY29kZWNzLm9wZW4oZmlsZW5hbWUsICJ3YiIs ICJ1dGYtOCIpIGFzIGZpbGU6CisgICAgICAgICAgICBmaWxlLndyaXRlKGVycm9yKQogICAgIGVs aWYgZXJyb3I6CiAgICAgICAgIF9sb2cuZGVidWcoIlByZXZpb3VzIHRlc3Qgb3V0cHV0IGV4dHJh IGxpbmVzIGFmdGVyIGR1bXA6XG4lcyIgJQogICAgICAgICAgICAgICAgICAgIGVycm9yKQpAQCAt MjkwLDcgKzI5NCw3IEBAIGNsYXNzIFRlc3RTaGVsbFRocmVhZCh0aHJlYWRpbmcuVGhyZWFkKToK ICAgICAgICAgIyBUaGlzIGlzIGNyZWF0ZWQgaW4gcnVuX3dlYmtpdF90ZXN0cy5weTpfUHJlcGFy ZUxpc3RzQW5kUHJpbnRPdXRwdXQuCiAgICAgICAgIHRlc3RzX3J1bl9maWxlbmFtZSA9IG9zLnBh dGguam9pbihzZWxmLl9vcHRpb25zLnJlc3VsdHNfZGlyZWN0b3J5LAogICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgInRlc3RzX3J1bi50eHQiKQotICAgICAgICB0ZXN0 c19ydW5fZmlsZSA9IG9wZW4odGVzdHNfcnVuX2ZpbGVuYW1lLCAiYSIpCisgICAgICAgIHRlc3Rz X3J1bl9maWxlID0gY29kZWNzLm9wZW4odGVzdHNfcnVuX2ZpbGVuYW1lLCAiYSIsICJ1dGYtOCIp CiAKICAgICAgICAgd2hpbGUgVHJ1ZToKICAgICAgICAgICAgIGlmIHNlbGYuX2NhbmNlbGVkOgpk aWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvbGF5 b3V0X3BhY2thZ2UvanNvbl9yZXN1bHRzX2dlbmVyYXRvci5weSBiL1dlYktpdFRvb2xzL1Njcmlw dHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9wYWNrYWdlL2pzb25fcmVzdWx0c19nZW5l cmF0b3IucHkKaW5kZXggNjI2MzU0MC4uYTMwODZkOSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMv U2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvbGF5b3V0X3BhY2thZ2UvanNvbl9yZXN1bHRz X2dlbmVyYXRvci5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90 ZXN0cy9sYXlvdXRfcGFja2FnZS9qc29uX3Jlc3VsdHNfZ2VuZXJhdG9yLnB5CkBAIC0yNyw2ICsy Nyw5IEBACiAjIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4g QU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQogIyBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklT RUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgogCitmcm9tIF9fZnV0dXJlX18g aW1wb3J0IHdpdGhfc3RhdGVtZW50CisKK2ltcG9ydCBjb2RlY3MKIGltcG9ydCBsb2dnaW5nCiBp bXBvcnQgb3MKIGltcG9ydCBzdWJwcm9jZXNzCkBAIC0xMTgsNyArMTIxLDcgQEAgY2xhc3MgSlNP TlJlc3VsdHNHZW5lcmF0b3Iob2JqZWN0KToKICAgICAgICAgIiIiR2VuZXJhdGVzIHRoZSBKU09O IG91dHB1dCBmaWxlLiIiIgogICAgICAgICBqc29uID0gc2VsZi5fZ2V0X2pzb24oKQogICAgICAg ICBpZiBqc29uOgotICAgICAgICAgICAgcmVzdWx0c19maWxlID0gb3BlbihzZWxmLl9yZXN1bHRz X2ZpbGVfcGF0aCwgInciKQorICAgICAgICAgICAgcmVzdWx0c19maWxlID0gY29kZWNzLm9wZW4o c2VsZi5fcmVzdWx0c19maWxlX3BhdGgsICJ3IiwgInV0Zi04IikKICAgICAgICAgICAgIHJlc3Vs dHNfZmlsZS53cml0ZShqc29uKQogICAgICAgICAgICAgcmVzdWx0c19maWxlLmNsb3NlKCkKIApA QCAtMTUxLDggKzE1NCw4IEBAIGNsYXNzIEpTT05SZXN1bHRzR2VuZXJhdG9yKG9iamVjdCk6CiAg ICAgICAgIGVycm9yID0gTm9uZQogCiAgICAgICAgIGlmIG9zLnBhdGguZXhpc3RzKHNlbGYuX3Jl c3VsdHNfZmlsZV9wYXRoKToKLSAgICAgICAgICAgIG9sZF9yZXN1bHRzX2ZpbGUgPSBvcGVuKHNl bGYuX3Jlc3VsdHNfZmlsZV9wYXRoLCAiciIpCi0gICAgICAgICAgICBvbGRfcmVzdWx0cyA9IG9s ZF9yZXN1bHRzX2ZpbGUucmVhZCgpCisgICAgICAgICAgICB3aXRoIGNvZGVjcy5vcGVuKHNlbGYu X3Jlc3VsdHNfZmlsZV9wYXRoLCAiciIsICJ1dGYtOCIpIGFzIGZpbGU6CisgICAgICAgICAgICAg ICAgb2xkX3Jlc3VsdHMgPSBmaWxlLnJlYWQoKQogICAgICAgICBlbGlmIHNlbGYuX2J1aWxkZXJf YmFzZV91cmw6CiAgICAgICAgICAgICAjIENoZWNrIGlmIHdlIGhhdmUgdGhlIGFyY2hpdmVkIEpT T04gZmlsZSBvbiB0aGUgYnVpbGRib3Qgc2VydmVyLgogICAgICAgICAgICAgcmVzdWx0c19maWxl X3VybCA9IChzZWxmLl9idWlsZGVyX2Jhc2VfdXJsICsKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xz L1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvYXBhY2hlX2h0dHBfc2VydmVyLnB5 IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9hcGFjaGVf aHR0cF9zZXJ2ZXIucHkKaW5kZXggMWRkNWI5My4uNGM3OGY3NyAxMDA2NDQKLS0tIGEvV2ViS2l0 VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9hcGFjaGVfaHR0cF9zZXJ2 ZXIucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9y dC9hcGFjaGVfaHR0cF9zZXJ2ZXIucHkKQEAgLTI5LDYgKzI5LDEwIEBACiAKICIiIkEgY2xhc3Mg dG8gc3RhcnQvc3RvcCB0aGUgYXBhY2hlIGh0dHAgc2VydmVyIHVzZWQgYnkgbGF5b3V0IHRlc3Rz LiIiIgogCisKK2Zyb20gX19mdXR1cmVfXyBpbXBvcnQgd2l0aF9zdGF0ZW1lbnQKKworaW1wb3J0 IGNvZGVjcwogaW1wb3J0IGxvZ2dpbmcKIGltcG9ydCBvcHRwYXJzZQogaW1wb3J0IG9zCkBAIC0x NTEsNyArMTU1LDkgQEAgY2xhc3MgTGF5b3V0VGVzdEFwYWNoZUh0dHBkKGh0dHBfc2VydmVyX2Jh c2UuSHR0cFNlcnZlckJhc2UpOgogICAgICAgICAiIiIKICAgICAgICAgaHR0cGRfY29uZmlnID0g c2VsZi5fcG9ydF9vYmouX3BhdGhfdG9fYXBhY2hlX2NvbmZpZ19maWxlKCkKICAgICAgICAgaHR0 cGRfY29uZmlnX2NvcHkgPSBvcy5wYXRoLmpvaW4ob3V0cHV0X2RpciwgImh0dHBkLmNvbmYiKQot ICAgICAgICBodHRwZF9jb25mID0gb3BlbihodHRwZF9jb25maWcpLnJlYWQoKQorICAgICAgICAj IGh0dHBkLmNvbmYgaXMgYWx3YXlzIHV0Zi04IGFjY29yZGluZyB0byBodHRwOi8vYXJjaGl2ZS5h cGFjaGUub3JnL2duYXRzLzEwMTI1CisgICAgICAgIHdpdGggY29kZWNzLm9wZW4oaHR0cGRfY29u ZmlnLCAiciIsICJ1dGYtOCIpIGFzIGh0dHBkX2NvbmZpZ19maWxlOgorICAgICAgICAgICAgaHR0 cGRfY29uZiA9IGh0dHBkX2NvbmZpZ19maWxlLnJlYWQoKQogICAgICAgICBpZiBzZWxmLl9pc19j eWd3aW4oKToKICAgICAgICAgICAgICMgVGhpcyBpcyBhIGdyb3NzIGhhY2ssIGJ1dCBpdCBsZXRz IHVzIHVzZSB0aGUgdXBzdHJlYW0gLmNvbmYgZmlsZQogICAgICAgICAgICAgIyBhbmQgb3VyIGNo ZWNrZWQgaW4gY3lnd2luLiBUaGlzIHRlbGxzIHRoZSBzZXJ2ZXIgdGhlIHJvb3QKQEAgLTE2NCw5 ICsxNzAsOCBAQCBjbGFzcyBMYXlvdXRUZXN0QXBhY2hlSHR0cGQoaHR0cF9zZXJ2ZXJfYmFzZS5I dHRwU2VydmVyQmFzZSk6CiAgICAgICAgICAgICBodHRwZF9jb25mID0gaHR0cGRfY29uZi5yZXBs YWNlKCdTZXJ2ZXJSb290ICIvdXNyIicsCiAgICAgICAgICAgICAgICAgJ1NlcnZlclJvb3QgIiVz IicgJSBzZWxmLl9nZXRfY3lnd2luX3BhdGgoY3lndXNyKSkKIAotICAgICAgICBmID0gb3Blbiho dHRwZF9jb25maWdfY29weSwgJ3diJykKLSAgICAgICAgZi53cml0ZShodHRwZF9jb25mKQotICAg ICAgICBmLmNsb3NlKCkKKyAgICAgICAgd2l0aCBjb2RlY3Mub3BlbihodHRwZF9jb25maWdfY29w eSwgInciLCAidXRmLTgiKSBhcyBmaWxlOgorICAgICAgICAgICAgZmlsZS53cml0ZShodHRwZF9j b25mKQogCiAgICAgICAgIGlmIHNlbGYuX2lzX2N5Z3dpbigpOgogICAgICAgICAgICAgcmV0dXJu IHNlbGYuX2dldF9jeWd3aW5fcGF0aChodHRwZF9jb25maWdfY29weSkKZGlmZiAtLWdpdCBhL1dl YktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hyb21pdW0ucHkg Yi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVt LnB5CmluZGV4IGU4OTgzOWMuLjI0ODU3YzQgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1Njcmlw dHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hyb21pdW0ucHkKKysrIGIvV2ViS2l0VG9v bHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1bS5weQpAQCAtMzgw LDcgKzM4MCw4IEBAIGNsYXNzIENocm9taXVtRHJpdmVyKGJhc2UuRHJpdmVyKToKICAgICAgICAg ICAgICAgICBpZiBzZWxmLl9wcm9jLnBvbGwoKSBpcyBOb25lOgogICAgICAgICAgICAgICAgICAg ICBfbG9nLndhcm5pbmcoJ3N0b3BwaW5nIHRlc3QgZHJpdmVyIHRpbWVkIG91dCwgJwogICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgJ2tpbGxpbmcgaXQnKQotICAgICAgICAgICAgICAg ICAgICBudWxsID0gb3Blbihvcy5kZXZudWxsLCAidyIpCisgICAgICAgICAgICAgICAgICAgICMg RklYTUU6IFRoaXMgc2hvdWxkIHVzZSBFeGVjdXRpdmUuCisgICAgICAgICAgICAgICAgICAgIG51 bGwgPSBvcGVuKG9zLmRldm51bGwsICJ3IikgICMgRG9lcyB0aGlzIG5lZWQgYW4gZW5jb2Rpbmc/ CiAgICAgICAgICAgICAgICAgICAgIHN1YnByb2Nlc3MuUG9wZW4oWyJraWxsIiwgIi05IiwKICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdHIoc2VsZi5fcHJvYy5waWQpXSwg c3RkZXJyPW51bGwpCiAgICAgICAgICAgICAgICAgICAgIG51bGwuY2xvc2UoKQpkaWZmIC0tZ2l0 IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1 bV9saW51eC5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3Bv cnQvY2hyb21pdW1fbGludXgucHkKaW5kZXggOWE1OTVmMi4uMTUwM2EwMyAxMDA2NDQKLS0tIGEv V2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1bV9s aW51eC5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9w b3J0L2Nocm9taXVtX2xpbnV4LnB5CkBAIC0xMjYsNiArMTI2LDcgQEAgY2xhc3MgQ2hyb21pdW1M aW51eFBvcnQoY2hyb21pdW0uQ2hyb21pdW1Qb3J0KToKIAogCiAgICAgZGVmIF9raWxsX2FsbF9w cm9jZXNzKHNlbGYsIHByb2Nlc3NfbmFtZSk6CisgICAgICAgICMgRklYTUU6IFRoaXMgc2hvdWxk IHVzZSBFeGVjdXRpdmUuCiAgICAgICAgIG51bGwgPSBvcGVuKG9zLmRldm51bGwpCiAgICAgICAg IHN1YnByb2Nlc3MuY2FsbChbJ2tpbGxhbGwnLCAnLVRFUk0nLCAnLXUnLCBvcy5nZXRlbnYoJ1VT RVInKSwKICAgICAgICAgICAgICAgICAgICAgICAgIHByb2Nlc3NfbmFtZV0sIHN0ZGVycj1udWxs KQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMv cG9ydC9jaHJvbWl1bV9tYWMucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91 dF90ZXN0cy9wb3J0L2Nocm9taXVtX21hYy5weQppbmRleCBkNWUxNzU3Li4wYmYzOGI1IDEwMDY0 NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2No cm9taXVtX21hYy5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90 ZXN0cy9wb3J0L2Nocm9taXVtX21hYy5weQpAQCAtOTksNiArOTksNyBAQCBjbGFzcyBDaHJvbWl1 bU1hY1BvcnQoY2hyb21pdW0uQ2hyb21pdW1Qb3J0KToKICAgICAgICAgcmV0dXJuIHNlbGYucGF0 aF9mcm9tX2Nocm9taXVtX2Jhc2UoJ3hjb2RlYnVpbGQnLCAqY29tcHMpCiAKICAgICBkZWYgX2No ZWNrX3dkaWZmX2luc3RhbGwoc2VsZik6CisgICAgICAgICMgRklYTUU6IFRoaXMgc2hvdWxkIHVz ZSBFeGVjdXRpdmUuCiAgICAgICAgIGYgPSBvcGVuKG9zLmRldm51bGwsICd3JykKICAgICAgICAg cmNvZGUgPSAwCiAgICAgICAgIHRyeToKQEAgLTExNiw2ICsxMTcsNyBAQCBjbGFzcyBDaHJvbWl1 bU1hY1BvcnQoY2hyb21pdW0uQ2hyb21pdW1Qb3J0KToKIAogICAgIGRlZiBfa2lsbF9hbGxfcHJv Y2VzcyhzZWxmLCBwcm9jZXNzX25hbWUpOgogICAgICAgICAiIiJLaWxsIGFueSBwcm9jZXNzZXMg cnVubmluZyB1bmRlciB0aGlzIG5hbWUuIiIiCisgICAgICAgICMgRklYTUU6IFRoaXMgc2hvdWxk IHVzZSBFeGVjdXRpdmUuCiAgICAgICAgICMgT24gTWFjIE9TIFggMTAuNiwga2lsbGFsbCBoYXMg YSBuZXcgY29uc3RyYWludDogLVNJR05BTE5BTUUgb3IKICAgICAgICAgIyAtU0lHTkFMTlVNQkVS IG11c3QgY29tZSBmaXJzdC4gIEV4YW1wbGUgcHJvYmxlbToKICAgICAgICAgIyAgICQga2lsbGFs bCAtdSAkVVNFUiAtVEVSTSBsaWdodHRwZApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0 cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9ndGsucHkgYi9XZWJLaXRUb29scy9TY3JpcHRz L3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2d0ay5weQppbmRleCBkZTVlMjhhLi4yNzY5Y2M2 IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9w b3J0L2d0ay5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0 cy9wb3J0L2d0ay5weQpAQCAtNjIsNiArNjIsNyBAQCBjbGFzcyBHdGtQb3J0KFdlYktpdFBvcnQp OgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICdhcGFjaGUyLWRlYmlhbi1odHRwZC5jb25m JykKIAogICAgIGRlZiBfa2lsbF9hbGxfcHJvY2VzcyhzZWxmLCBwcm9jZXNzX25hbWUpOgorICAg ICAgICAjIEZJWE1FOiBUaGlzIHNob3VsZCB1c2UgRXhlY3V0aXZlLgogICAgICAgICBudWxsID0g b3Blbihvcy5kZXZudWxsKQogICAgICAgICBzdWJwcm9jZXNzLmNhbGwoWydraWxsYWxsJywgJy1U RVJNJywgJy11Jywgb3MuZ2V0ZW52KCdVU0VSJyksCiAgICAgICAgICAgICAgICAgICAgICAgICBw cm9jZXNzX25hbWVdLCBzdGRlcnI9bnVsbCkKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1Njcmlw dHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvbWFjLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0 cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9tYWMucHkKaW5kZXggY2Y0ZGFhOC4uNzlkZTY5 YiAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMv cG9ydC9tYWMucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVz dHMvcG9ydC9tYWMucHkKQEAgLTEzMyw2ICsxMzMsNyBAQCBjbGFzcyBNYWNQb3J0KFdlYktpdFBv cnQpOgogCiAgICAgIyBGSVhNRTogVGhpcyBkb2Vzbid0IGhhdmUgYW55dGhpbmcgdG8gZG8gd2l0 aCBXZWJLaXQuCiAgICAgZGVmIF9raWxsX2FsbF9wcm9jZXNzKHNlbGYsIHByb2Nlc3NfbmFtZSk6 CisgICAgICAgICMgRklYTUU6IFRoaXMgc2hvdWxkIHVzZSBFeGVjdXRpdmUuCiAgICAgICAgICMg T24gTWFjIE9TIFggMTAuNiwga2lsbGFsbCBoYXMgYSBuZXcgY29uc3RyYWludDogLVNJR05BTE5B TUUgb3IKICAgICAgICAgIyAtU0lHTkFMTlVNQkVSIG11c3QgY29tZSBmaXJzdC4gIEV4YW1wbGUg cHJvYmxlbToKICAgICAgICAgIyAgICQga2lsbGFsbCAtdSAkVVNFUiAtVEVSTSBsaWdodHRwZApk aWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9y dC9tYWNfdW5pdHRlc3QucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90 ZXN0cy9wb3J0L21hY191bml0dGVzdC5weQppbmRleCBlNDdhNGE0Li5hZTdkNDBjIDEwMDY0NAot LS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L21hY191 bml0dGVzdC5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0 cy9wb3J0L21hY191bml0dGVzdC5weQpAQCAtNDAsNyArNDAsNyBAQCBjbGFzcyBNYWNUZXN0KHVu aXR0ZXN0LlRlc3RDYXNlKToKICAgICAgICAgcmVsYXRpdmVfcGF0aHMgPSBbcGF0aFtsZW4ocG9y dC5wYXRoX2Zyb21fd2Via2l0X2Jhc2UoKSk6XSBmb3IgcGF0aCBpbiBza2lwcGVkX3BhdGhzXQog ICAgICAgICBzZWxmLmFzc2VydEVxdWFsKHJlbGF0aXZlX3BhdGhzLCBbJ0xheW91dFRlc3RzL3Bs YXRmb3JtL21hYy1sZW9wYXJkL1NraXBwZWQnLCAnTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFjL1Nr aXBwZWQnXSkKIAotICAgIGV4YW1wbGVfc2tpcHBlZF9maWxlID0gIiIiCisgICAgZXhhbXBsZV9z a2lwcGVkX2ZpbGUgPSB1IiIiCiAjIDxyZGFyOi8vcHJvYmxlbS81NjQ3OTUyPiBmYXN0L2V2ZW50 cy9tb3VzZW91dC1vbi13aW5kb3cuaHRtbCBuZWVkcyBtYWMgRFJUIHRvIGlzc3VlIG1vdXNlIG91 dCBldmVudHMKIGZhc3QvZXZlbnRzL21vdXNlb3V0LW9uLXdpbmRvdy5odG1sCiAKZGlmZiAtLWdp dCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvcXQucHkg Yi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3F0LnB5Cmlu ZGV4IDg5YTM1ZTguLjE4ZDg4YjkgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvcXQucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93 ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9xdC5weQpAQCAtNjIsNiArNjIsNyBAQCBjbGFzcyBR dFBvcnQoV2ViS2l0UG9ydCk6CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJ2FwYWNoZTIt ZGViaWFuLWh0dHBkLmNvbmYnKQogCiAgICAgZGVmIF9raWxsX2FsbF9wcm9jZXNzKHNlbGYsIHBy b2Nlc3NfbmFtZSk6CisgICAgICAgICMgRklYTUU6IFRoaXMgc2hvdWxkIHVzZSBFeGVjdXRpdmUu CiAgICAgICAgIG51bGwgPSBvcGVuKG9zLmRldm51bGwpCiAgICAgICAgIHN1YnByb2Nlc3MuY2Fs bChbJ2tpbGxhbGwnLCAnLVRFUk0nLCAnLXUnLCBvcy5nZXRlbnYoJ1VTRVInKSwKICAgICAgICAg ICAgICAgICAgICAgICAgIHByb2Nlc3NfbmFtZV0sIHN0ZGVycj1udWxsKQpkaWZmIC0tZ2l0IGEv V2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9zZXJ2ZXJfcHJv Y2Vzcy5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQv c2VydmVyX3Byb2Nlc3MucHkKaW5kZXggZjFjNmQ3My4uNzA1NzNhOSAxMDA2NDQKLS0tIGEvV2Vi S2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9zZXJ2ZXJfcHJvY2Vz cy5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0 L3NlcnZlcl9wcm9jZXNzLnB5CkBAIC0yMTUsNiArMjE1LDcgQEAgY2xhc3MgU2VydmVyUHJvY2Vz czoKICAgICAgICAgICAgIGlmIHNlbGYuX3Byb2MucG9sbCgpIGlzIE5vbmU6CiAgICAgICAgICAg ICAgICAgX2xvZy53YXJuaW5nKCdzdG9wcGluZyAlcyB0aW1lZCBvdXQsIGtpbGxpbmcgaXQnICUK ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc2VsZi5fbmFtZSkKKyAgICAgICAgICAgICAg ICAjIEZJWE1FOiBUaGlzIHNob3VsZCB1c2UgRXhlY3V0aXZlLgogICAgICAgICAgICAgICAgIG51 bGwgPSBvcGVuKG9zLmRldm51bGwsICJ3IikKICAgICAgICAgICAgICAgICBzdWJwcm9jZXNzLlBv cGVuKFsia2lsbCIsICItOSIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3Ry KHNlbGYuX3Byb2MucGlkKV0sIHN0ZGVycj1udWxsKQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMv U2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93ZWJraXQucHkgYi9XZWJLaXRUb29s cy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3dlYmtpdC5weQppbmRleCBjZjYx NDU1Li5iZmQ1Yjg3IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xh eW91dF90ZXN0cy9wb3J0L3dlYmtpdC5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy9wb3J0L3dlYmtpdC5weQpAQCAtMjksNiArMjksMTAgQEAKIAogIiIi V2ViS2l0IGltcGxlbWVudGF0aW9ucyBvZiB0aGUgUG9ydCBpbnRlcmZhY2UuIiIiCiAKKworZnJv bSBfX2Z1dHVyZV9fIGltcG9ydCB3aXRoX3N0YXRlbWVudAorCitpbXBvcnQgY29kZWNzCiBpbXBv cnQgbG9nZ2luZwogaW1wb3J0IG9zCiBpbXBvcnQgcGRiCkBAIC0xMzMsOSArMTM3LDExIEBAIGNs YXNzIFdlYktpdFBvcnQoYmFzZS5Qb3J0KToKICAgICAgICAgc3AgPSBzZXJ2ZXJfcHJvY2Vzcy5T ZXJ2ZXJQcm9jZXNzKHNlbGYsICdJbWFnZURpZmYnLCBjb21tYW5kKQogCiAgICAgICAgIGFjdHVh bF9sZW5ndGggPSBvcy5zdGF0KGFjdHVhbF9maWxlbmFtZSkuc3Rfc2l6ZQotICAgICAgICBhY3R1 YWxfZmlsZSA9IG9wZW4oYWN0dWFsX2ZpbGVuYW1lKS5yZWFkKCkKKyAgICAgICAgd2l0aCBvcGVu KGFjdHVhbF9maWxlbmFtZSkgYXMgZmlsZToKKyAgICAgICAgICAgIGFjdHVhbF9maWxlID0gZmls ZS5yZWFkKCkKICAgICAgICAgZXhwZWN0ZWRfbGVuZ3RoID0gb3Muc3RhdChleHBlY3RlZF9maWxl bmFtZSkuc3Rfc2l6ZQotICAgICAgICBleHBlY3RlZF9maWxlID0gb3BlbihleHBlY3RlZF9maWxl bmFtZSkucmVhZCgpCisgICAgICAgIHdpdGggb3BlbihleHBlY3RlZF9maWxlbmFtZSkgYXMgZmls ZToKKyAgICAgICAgICAgIGV4cGVjdGVkX2ZpbGUgPSBmaWxlLnJlYWQoKQogICAgICAgICBzcC53 cml0ZSgnQ29udGVudC1MZW5ndGg6ICVkXG4lc0NvbnRlbnQtTGVuZ3RoOiAlZFxuJXMnICUKICAg ICAgICAgICAgICAgICAgKGFjdHVhbF9sZW5ndGgsIGFjdHVhbF9maWxlLCBleHBlY3RlZF9sZW5n dGgsIGV4cGVjdGVkX2ZpbGUpKQogCkBAIC0xNjQsNyArMTcwLDggQEAgY2xhc3MgV2ViS2l0UG9y dChiYXNlLlBvcnQpOgogICAgICAgICAgICAgaWYgbS5ncm91cCgyKSA9PSAncGFzc2VkJzoKICAg ICAgICAgICAgICAgICByZXN1bHQgPSBGYWxzZQogICAgICAgICBlbGlmIG91dHB1dCBhbmQgZGlm Zl9maWxlbmFtZToKLSAgICAgICAgICAgIG9wZW4oZGlmZl9maWxlbmFtZSwgJ3cnKS53cml0ZShv dXRwdXQpICAjIEZJWE1FOiBUaGlzIGxlYWtzIGEgZmlsZSBoYW5kbGUuCisgICAgICAgICAgICB3 aXRoIG9wZW4oZGlmZl9maWxlbmFtZSwgJ3cnKSBhcyBmaWxlOgorICAgICAgICAgICAgICAgIGZp bGUud3JpdGUob3V0cHV0KQogICAgICAgICBlbGlmIHNwLnRpbWVkX291dDoKICAgICAgICAgICAg IF9sb2cuZXJyb3IoIkltYWdlRGlmZiB0aW1lZCBvdXQgb24gJXMiICUgZXhwZWN0ZWRfZmlsZW5h bWUpCiAgICAgICAgIGVsaWYgc3AuY3Jhc2hlZDoKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1Nj cmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Vic29ja2V0X3NlcnZlci5weSBiL1dl YktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Vic29ja2V0X3Nl cnZlci5weQppbmRleCBhOWJhMTYwLi5hOWVhYjVlIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9T Y3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3dlYnNvY2tldF9zZXJ2ZXIucHkKKysr IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93ZWJzb2Nr ZXRfc2VydmVyLnB5CkBAIC0zMCw2ICszMCw5IEBACiAiIiJBIGNsYXNzIHRvIGhlbHAgc3RhcnQv c3RvcCB0aGUgUHlXZWJTb2NrZXQgc2VydmVyIHVzZWQgYnkgbGF5b3V0IHRlc3RzLiIiIgogCiAK K2Zyb20gX19mdXR1cmVfXyBpbXBvcnQgd2l0aF9zdGF0ZW1lbnQKKworaW1wb3J0IGNvZGVjcwog aW1wb3J0IGxvZ2dpbmcKIGltcG9ydCBvcHRwYXJzZQogaW1wb3J0IG9zCkBAIC0xNTEsNyArMTU0 LDcgQEAgY2xhc3MgUHlXZWJTb2NrZXQoaHR0cF9zZXJ2ZXIuTGlnaHR0cGQpOgogICAgICAgICBl cnJvcl9sb2cgPSBvcy5wYXRoLmpvaW4oc2VsZi5fb3V0cHV0X2RpciwgbG9nX2ZpbGVfbmFtZSAr ICItZXJyLnR4dCIpCiAKICAgICAgICAgb3V0cHV0X2xvZyA9IG9zLnBhdGguam9pbihzZWxmLl9v dXRwdXRfZGlyLCBsb2dfZmlsZV9uYW1lICsgIi1vdXQudHh0IikKLSAgICAgICAgc2VsZi5fd3Nv dXQgPSBvcGVuKG91dHB1dF9sb2csICJ3IikKKyAgICAgICAgc2VsZi5fd3NvdXQgPSBjb2RlY3Mu b3BlbihvdXRwdXRfbG9nLCAidyIsICJ1dGYtOCIpCiAKICAgICAgICAgcHl0aG9uX2ludGVycCA9 IHN5cy5leGVjdXRhYmxlCiAgICAgICAgIHB5d2Vic29ja2V0X2Jhc2UgPSBvcy5wYXRoLmpvaW4o CkBAIC0yMTYsNyArMjE5LDcgQEAgY2xhc3MgUHlXZWJTb2NrZXQoaHR0cF9zZXJ2ZXIuTGlnaHR0 cGQpOgogICAgICAgICAgICAgdXJsID0gJ2h0dHAnCiAgICAgICAgIHVybCA9IHVybCArICc6Ly8x MjcuMC4wLjE6JWQvJyAlIHNlbGYuX3BvcnQKICAgICAgICAgaWYgbm90IHVybF9pc19hbGl2ZSh1 cmwpOgotICAgICAgICAgICAgZnAgPSBvcGVuKG91dHB1dF9sb2cpCisgICAgICAgICAgICBmcCA9 IGNvZGVjcy5vcGVuKG91dHB1dF9sb2csICJ1dGYtOCIpCiAgICAgICAgICAgICB0cnk6CiAgICAg ICAgICAgICAgICAgZm9yIGxpbmUgaW4gZnA6CiAgICAgICAgICAgICAgICAgICAgIF9sb2cuZXJy b3IobGluZSkKQEAgLTIzMSw5ICsyMzQsOCBAQCBjbGFzcyBQeVdlYlNvY2tldChodHRwX3NlcnZl ci5MaWdodHRwZCk6CiAgICAgICAgICAgICByYWlzZSBQeVdlYlNvY2tldE5vdFN0YXJ0ZWQoCiAg ICAgICAgICAgICAgICAgJ0ZhaWxlZCB0byBzdGFydCAlcyBzZXJ2ZXIuJyAlIHNlbGYuX3NlcnZl cl9uYW1lKQogICAgICAgICBpZiBzZWxmLl9waWRmaWxlOgotICAgICAgICAgICAgZiA9IG9wZW4o c2VsZi5fcGlkZmlsZSwgJ3cnKQotICAgICAgICAgICAgZi53cml0ZSgiJWQiICUgc2VsZi5fcHJv Y2Vzcy5waWQpCi0gICAgICAgICAgICBmLmNsb3NlKCkKKyAgICAgICAgICAgIHdpdGggY29kZWNz Lm9wZW4oc2VsZi5fcGlkZmlsZSwgInciLCAiYXNjaWkiKSBhcyBmaWxlOgorICAgICAgICAgICAg ICAgIGZpbGUud3JpdGUoIiVkIiAlIHNlbGYuX3Byb2Nlc3MucGlkKQogCiAgICAgZGVmIHN0b3Ao c2VsZiwgZm9yY2U9RmFsc2UpOgogICAgICAgICBpZiBub3QgZm9yY2UgYW5kIG5vdCBzZWxmLmlz X3J1bm5pbmcoKToKQEAgLTI0Myw5ICsyNDUsOCBAQCBjbGFzcyBQeVdlYlNvY2tldChodHRwX3Nl cnZlci5MaWdodHRwZCk6CiAgICAgICAgIGlmIHNlbGYuX3Byb2Nlc3M6CiAgICAgICAgICAgICBw aWQgPSBzZWxmLl9wcm9jZXNzLnBpZAogICAgICAgICBlbGlmIHNlbGYuX3BpZGZpbGU6Ci0gICAg ICAgICAgICBmID0gb3BlbihzZWxmLl9waWRmaWxlKQotICAgICAgICAgICAgcGlkID0gaW50KGYu cmVhZCgpLnN0cmlwKCkpCi0gICAgICAgICAgICBmLmNsb3NlKCkKKyAgICAgICAgICAgIHdpdGgg Y29kZWNzLm9wZW4oc2VsZi5fcGlkZmlsZSwgInIiLCAiYXNjaWkiKSBhcyBmaWxlOgorICAgICAg ICAgICAgICAgIHBpZCA9IGludChmLnJlYWQoKS5zdHJpcCgpKQogCiAgICAgICAgIGlmIG5vdCBw aWQ6CiAgICAgICAgICAgICByYWlzZSBQeVdlYlNvY2tldE5vdEZvdW5kKApkaWZmIC0tZ2l0IGEv V2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcmViYXNlbGluZV9jaHJv bWl1bV93ZWJraXRfdGVzdHMucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91 dF90ZXN0cy9yZWJhc2VsaW5lX2Nocm9taXVtX3dlYmtpdF90ZXN0cy5weQppbmRleCBiOTcyMTU0 Li4xNjMzNTRiIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91 dF90ZXN0cy9yZWJhc2VsaW5lX2Nocm9taXVtX3dlYmtpdF90ZXN0cy5weQorKysgYi9XZWJLaXRU b29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9yZWJhc2VsaW5lX2Nocm9taXVtX3dl YmtpdF90ZXN0cy5weQpAQCAtNDEsNiArNDEsOSBAQCBUaGUgc2NyaXB0IGRvZXMgdGhlIGZvbGxv d2luZyBmb3IgZWFjaCBwbGF0Zm9ybSBzcGVjaWZpZWQ6CiBBdCB0aGUgZW5kLCB0aGUgc2NyaXB0 IGdlbmVyYXRlcyBhIGh0bWwgdGhhdCBjb21wYXJlcyBvbGQgYW5kIG5ldyBiYXNlbGluZXMuCiAi IiIKIAorZnJvbSBfX2Z1dHVyZV9fIGltcG9ydCB3aXRoX3N0YXRlbWVudAorCitpbXBvcnQgY29k ZWNzCiBpbXBvcnQgY29weQogaW1wb3J0IGxvZ2dpbmcKIGltcG9ydCBvcHRwYXJzZQpAQCAtNTk4 LDkgKzYwMSwxMCBAQCBjbGFzcyBSZWJhc2VsaW5lcihvYmplY3QpOgogICAgICAgICAgICAgICAg ICAgICBvcy5yZW1vdmUoYmFja3VwX2ZpbGUpCiAgICAgICAgICAgICAgICAgX2xvZy5pbmZvKCdT YXZpbmcgb3JpZ2luYWwgZmlsZSB0byAiJXMiJywgYmFja3VwX2ZpbGUpCiAgICAgICAgICAgICAg ICAgb3MucmVuYW1lKHBhdGgsIGJhY2t1cF9maWxlKQotICAgICAgICAgICAgZiA9IG9wZW4ocGF0 aCwgInciKQotICAgICAgICAgICAgZi53cml0ZShuZXdfZXhwZWN0YXRpb25zKQotICAgICAgICAg ICAgZi5jbG9zZSgpCisgICAgICAgICAgICAjIEZJWE1FOiBXaGF0IGVuY29kaW5nIGFyZSB0aGVz ZSBmaWxlcz8KKyAgICAgICAgICAgICMgT3IgaXMgbmV3X2V4cGVjdGF0aW9ucyBhbHdheXMgYSBi eXRlIGFycmF5PworICAgICAgICAgICAgd2l0aCBvcGVuKHBhdGgsICJ3IikgYXMgZmlsZToKKyAg ICAgICAgICAgICAgICBmaWxlLndyaXRlKG5ld19leHBlY3RhdGlvbnMpCiAgICAgICAgIGVsc2U6 CiAgICAgICAgICAgICBfbG9nLmluZm8oJ05vIHRlc3Qgd2FzIHJlYmFzZWxpbmVkIHNvIG5vdGhp bmcgdG8gcmVtb3ZlLicpCiAKQEAgLTcxNSw5ICs3MTksMTAgQEAgY2xhc3MgUmViYXNlbGluZXIo b2JqZWN0KToKICAgICAgICAgYmFzZV9maWxlID0gZ2V0X3Jlc3VsdF9maWxlX2Z1bGxwYXRoKHNl bGYuX29wdGlvbnMuaHRtbF9kaXJlY3RvcnksCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBiYXNlbGluZV9maWxlbmFtZSwgc2VsZi5fcGxhdGZvcm0sCiAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAnb2xkJykKLSAgICAgICAg ZiA9IG9wZW4oYmFzZV9maWxlLCAnd2InKQotICAgICAgICBmLndyaXRlKG91dHB1dCkKLSAgICAg ICAgZi5jbG9zZSgpCisgICAgICAgICMgRklYTUU6IFRoaXMgYXNzdW1lcyBydW5fc2hlbGwgcmV0 dXJucyBhIGJ5dGUgYXJyYXkuCisgICAgICAgICMgV2Ugc2hvdWxkIGJlIHVzaW5nIGFuIGV4cGxp Y2l0IGVuY29kaW5nIGhlcmUuCisgICAgICAgIHdpdGggb3BlbihiYXNlX2ZpbGUsICJ3YiIpIGFz IGZpbGU6CisgICAgICAgICAgICBmaWxlLndyaXRlKG91dHB1dCkKICAgICAgICAgX2xvZy5pbmZv KCcgIEh0bWw6IGNyZWF0ZWQgb2xkIGJhc2VsaW5lIGZpbGU6ICIlcyIuJywKICAgICAgICAgICAg ICAgICAgIGJhc2VfZmlsZSkKIApAQCAtNzQ4LDkgKzc1Myw5IEBAIGNsYXNzIFJlYmFzZWxpbmVy KG9iamVjdCk6CiAgICAgICAgICAgICAgICAgZGlmZl9maWxlID0gZ2V0X3Jlc3VsdF9maWxlX2Z1 bGxwYXRoKAogICAgICAgICAgICAgICAgICAgICBzZWxmLl9vcHRpb25zLmh0bWxfZGlyZWN0b3J5 LCBiYXNlbGluZV9maWxlbmFtZSwKICAgICAgICAgICAgICAgICAgICAgc2VsZi5fcGxhdGZvcm0s ICdkaWZmJykKLSAgICAgICAgICAgICAgICBmID0gb3BlbihkaWZmX2ZpbGUsICd3YicpCi0gICAg ICAgICAgICAgICAgZi53cml0ZShvdXRwdXQpCi0gICAgICAgICAgICAgICAgZi5jbG9zZSgpCisg ICAgICAgICAgICAgICAgIyBGSVhNRTogVGhpcyBhc3N1bWVzIHJ1bl9zaGVsbCByZXR1cm5zIGEg Ynl0ZSBhcnJheSwgbm90IHVuaWNvZGUoKQorICAgICAgICAgICAgICAgIHdpdGggb3BlbihkaWZm X2ZpbGUsICd3YicpIGFzIGZpbGU6CisgICAgICAgICAgICAgICAgICAgIGZpbGUud3JpdGUob3V0 cHV0KQogICAgICAgICAgICAgICAgIF9sb2cuaW5mbygnICBIdG1sOiBjcmVhdGVkIGJhc2VsaW5l IGRpZmYgZmlsZTogIiVzIi4nLAogICAgICAgICAgICAgICAgICAgICAgICAgICBkaWZmX2ZpbGUp CiAKQEAgLTgzNSw5ICs4NDAsOCBAQCBjbGFzcyBIdG1sR2VuZXJhdG9yKG9iamVjdCk6CiAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJ2JvZHknOiBodG1sX2JvZHl9KQog ICAgICAgICBfbG9nLmRlYnVnKGh0bWwpCiAKLSAgICAgICAgZiA9IG9wZW4oc2VsZi5faHRtbF9m aWxlLCAndycpCi0gICAgICAgIGYud3JpdGUoaHRtbCkKLSAgICAgICAgZi5jbG9zZSgpCisgICAg ICAgIHdpdGggY29kZWNzLm9wZW4oc2VsZi5faHRtbF9maWxlLCAidyIsICJ1dGYtOCIpIGFzIGZp bGU6CisgICAgICAgICAgICBmaWxlLndyaXRlKGh0bWwpCiAKICAgICAgICAgX2xvZy5pbmZvKCdC YXNlbGluZSBjb21wYXJpc29uIGh0bWwgZ2VuZXJhdGVkIGF0ICIlcyInLAogICAgICAgICAgICAg ICAgICAgc2VsZi5faHRtbF9maWxlKQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93 ZWJraXRweS9sYXlvdXRfdGVzdHMvcnVuX3dlYmtpdF90ZXN0cy5weSBiL1dlYktpdFRvb2xzL1Nj cmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVzdHMucHkKaW5kZXggNzMx OTViMy4uNmUxZGE3NiAxMDA3NTUKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9s YXlvdXRfdGVzdHMvcnVuX3dlYmtpdF90ZXN0cy5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRz L3dlYmtpdHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzLnB5CkBAIC0zNjcsOSArMzY3 LDggQEAgY2xhc3MgVGVzdFJ1bm5lcjoKICAgICAgICAgICAgICAgICBmaWxlcy5leHRlbmQodGVz dF9maWxlc1swOmV4dHJhXSkKICAgICAgICAgICAgIHRlc3RzX3J1bl9maWxlbmFtZSA9IG9zLnBh dGguam9pbihzZWxmLl9vcHRpb25zLnJlc3VsdHNfZGlyZWN0b3J5LAogICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJ0ZXN0c19ydW4udHh0IikKLSAgICAgICAg ICAgIHRlc3RzX3J1bl9maWxlID0gb3Blbih0ZXN0c19ydW5fZmlsZW5hbWUsICJ3IikKLSAgICAg ICAgICAgIHRlc3RzX3J1bl9maWxlLndyaXRlKHRlc3RzX3J1bl9tc2cgKyAiXG4iKQotICAgICAg ICAgICAgdGVzdHNfcnVuX2ZpbGUuY2xvc2UoKQorICAgICAgICAgICAgd2l0aCBjb2RlY3Mub3Bl bih0ZXN0c19ydW5fZmlsZW5hbWUsICJ3IiwgInV0Zi04IikgYXMgZmlsZToKKyAgICAgICAgICAg ICAgICBmaWxlLndyaXRlKHRlc3RzX3J1bl9tc2cgKyAiXG4iKQogCiAgICAgICAgICAgICBsZW5f c2tpcF9jaHVuayA9IGludChsZW4oZmlsZXMpICogbGVuKHNraXBwZWQpIC8KICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIGZsb2F0KGxlbihzZWxmLl90ZXN0X2ZpbGVzKSkpCkBAIC05 NjYsMjIgKzk2NSwxOSBAQCBjbGFzcyBUZXN0UnVubmVyOgogICAgICAgICAgIGluZGl2aWR1YWxf dGVzdF90aW1pbmdzOiBsaXN0IG9mIHRlc3QgdGltZXMgKHVzZWQgYnkgdGhlIGZsYWtpbmVzcwog ICAgICAgICAgICAgZGFzaGJvYXJkKS4KICAgICAgICAgIiIiCi0gICAgICAgIF9sb2cuZGVidWco IldyaXRpbmcgSlNPTiBmaWxlcyBpbiAlcy4iICUKLSAgICAgICAgICAgICAgICAgICBzZWxmLl9v cHRpb25zLnJlc3VsdHNfZGlyZWN0b3J5KQotICAgICAgICB1bmV4cGVjdGVkX2ZpbGUgPSBvcGVu KG9zLnBhdGguam9pbihzZWxmLl9vcHRpb25zLnJlc3VsdHNfZGlyZWN0b3J5LAotICAgICAgICAg ICAgInVuZXhwZWN0ZWRfcmVzdWx0cy5qc29uIiksICJ3IikKLSAgICAgICAgdW5leHBlY3RlZF9m aWxlLndyaXRlKHNpbXBsZWpzb24uZHVtcHModW5leHBlY3RlZF9yZXN1bHRzLAotICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgc29ydF9rZXlzPVRydWUsIGluZGVudD0yKSkKLSAgICAgICAg dW5leHBlY3RlZF9maWxlLmNsb3NlKCkKKyAgICAgICAgcmVzdWx0c19kaXJlY3RvcnkgPSBzZWxm Ll9vcHRpb25zLnJlc3VsdHNfZGlyZWN0b3J5CisgICAgICAgIF9sb2cuZGVidWcoIldyaXRpbmcg SlNPTiBmaWxlcyBpbiAlcy4iICUgcmVzdWx0c19kaXJlY3RvcnkpCisgICAgICAgIHVuZXhwZWN0 ZWRfanNvbl9wYXRoID0gb3MucGF0aC5qb2luKHJlc3VsdHNfZGlyZWN0b3J5LCAidW5leHBlY3Rl ZF9yZXN1bHRzLmpzb24iKQorICAgICAgICB3aXRoIGNvZGVjcy5vcGVuKHVuZXhwZWN0ZWRfanNv bl9wYXRoLCAidyIsICJ1dGYtOCIpIGFzIGZpbGU6CisgICAgICAgICAgICBzaW1wbGVqc29uLmR1 bXAodW5leHBlY3RlZF9yZXN1bHRzLCBmaWxlLCBzb3J0X2tleXM9VHJ1ZSwgaW5kZW50PTIpCiAK ICAgICAgICAgIyBXcml0ZSBhIGpzb24gZmlsZSBvZiB0aGUgdGVzdF9leHBlY3RhdGlvbnMudHh0 IGZpbGUgZm9yIHRoZSBsYXlvdXQKICAgICAgICAgIyB0ZXN0cyBkYXNoYm9hcmQuCi0gICAgICAg IGV4cGVjdGF0aW9uc19maWxlID0gb3Blbihvcy5wYXRoLmpvaW4oc2VsZi5fb3B0aW9ucy5yZXN1 bHRzX2RpcmVjdG9yeSwKLSAgICAgICAgICAgICJleHBlY3RhdGlvbnMuanNvbiIpLCAidyIpCisg ICAgICAgIGV4cGVjdGF0aW9uc19wYXRoID0gb3MucGF0aC5qb2luKHJlc3VsdHNfZGlyZWN0b3J5 LCAiZXhwZWN0YXRpb25zLmpzb24iKQogICAgICAgICBleHBlY3RhdGlvbnNfanNvbiA9IFwKICAg ICAgICAgICAgIHNlbGYuX2V4cGVjdGF0aW9ucy5nZXRfZXhwZWN0YXRpb25zX2pzb25fZm9yX2Fs bF9wbGF0Zm9ybXMoKQotICAgICAgICBleHBlY3RhdGlvbnNfZmlsZS53cml0ZSgiQUREX0VYUEVD VEFUSU9OUygiICsgZXhwZWN0YXRpb25zX2pzb24gKyAiKTsiKQotICAgICAgICBleHBlY3RhdGlv bnNfZmlsZS5jbG9zZSgpCisgICAgICAgIHdpdGggY29kZWNzLm9wZW4oZXhwZWN0YXRpb25zX3Bh dGgsICJ3IiwgInV0Zi04IikgYXMgZmlsZToKKyAgICAgICAgICAgIGZpbGUud3JpdGUodSJBRERf RVhQRUNUQVRJT05TKCVzKTsiICUgZXhwZWN0YXRpb25zX2pzb24pCiAKICAgICAgICAganNvbl9s YXlvdXRfcmVzdWx0c19nZW5lcmF0b3IuSlNPTkxheW91dFJlc3VsdHNHZW5lcmF0b3IoCiAgICAg ICAgICAgICBzZWxmLl9wb3J0LCBzZWxmLl9vcHRpb25zLmJ1aWxkZXJfbmFtZSwgc2VsZi5fb3B0 aW9ucy5idWlsZF9uYW1lLApAQCAtMTM5Miw3ICsxMzg4LDkgQEAgY2xhc3MgVGVzdFJ1bm5lcjoK IAogICAgICAgICBvdXRfZmlsZW5hbWUgPSBvcy5wYXRoLmpvaW4oc2VsZi5fb3B0aW9ucy5yZXN1 bHRzX2RpcmVjdG9yeSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJyZXN1 bHRzLmh0bWwiKQotICAgICAgICBvdXRfZmlsZSA9IG9wZW4ob3V0X2ZpbGVuYW1lLCAndycpCisg ICAgICAgICMgRklYTUU6IFRoaXMgc2hvdWxkIGJlIHJlLXdyaXR0ZW4gdG8gcHJlcGFyZSB0aGUg c3RyaW5nIGZpcnN0CisgICAgICAgICMgc28gdGhhdCB0aGUgIm9wZW4iIGNhbGwgY2FuIGJlIHdy YXBwZWQgaW4gYSB3aXRoIHN0YXRlbWVudC4KKyAgICAgICAgb3V0X2ZpbGUgPSBjb2RlY3Mub3Bl bihvdXRfZmlsZW5hbWUsICJ3IiwgInV0Zi04IikKICAgICAgICAgIyBoZWFkZXIKICAgICAgICAg aWYgc2VsZi5fb3B0aW9ucy5mdWxsX3Jlc3VsdHNfaHRtbDoKICAgICAgICAgICAgIGgyID0gIlRl c3QgRmFpbHVyZXMiCkBAIC0xNDA1LDE3ICsxNDAzLDE4IEBAIGNsYXNzIFRlc3RSdW5uZXI6CiAg ICAgICAgIHRlc3RfZmlsZXMuc29ydCgpCiAgICAgICAgIGZvciB0ZXN0X2ZpbGUgaW4gdGVzdF9m aWxlczoKICAgICAgICAgICAgIHRlc3RfZmFpbHVyZXMgPSByZXN1bHRfc3VtbWFyeS5mYWlsdXJl cy5nZXQodGVzdF9maWxlLCBbXSkKLSAgICAgICAgICAgIG91dF9maWxlLndyaXRlKCI8cD48YSBo cmVmPSclcyc+JXM8L2E+PGJyIC8+XG4iCisgICAgICAgICAgICBvdXRfZmlsZS53cml0ZSh1Ijxw PjxhIGhyZWY9JyVzJz4lczwvYT48YnIgLz5cbiIKICAgICAgICAgICAgICAgICAgICAgICAgICAg ICUgKHNlbGYuX3BvcnQuZmlsZW5hbWVfdG9fdXJpKHRlc3RfZmlsZSksCiAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBzZWxmLl9wb3J0LnJlbGF0aXZlX3Rlc3RfZmlsZW5hbWUodGVzdF9m aWxlKSkpCiAgICAgICAgICAgICBmb3IgZmFpbHVyZSBpbiB0ZXN0X2ZhaWx1cmVzOgotICAgICAg ICAgICAgICAgIG91dF9maWxlLndyaXRlKCImbmJzcDsmbmJzcDslczxici8+IgorICAgICAgICAg ICAgICAgIG91dF9maWxlLndyaXRlKHUiJm5ic3A7Jm5ic3A7JXM8YnIvPiIKICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAlIGZhaWx1cmUucmVzdWx0X2h0bWxfb3V0cHV0KAogICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgc2VsZi5fcG9ydC5yZWxhdGl2ZV90ZXN0X2ZpbGVu YW1lKHRlc3RfZmlsZSkpKQogICAgICAgICAgICAgb3V0X2ZpbGUud3JpdGUoIjwvcD5cbiIpCiAK ICAgICAgICAgIyBmb290ZXIKICAgICAgICAgb3V0X2ZpbGUud3JpdGUoIjwvYm9keT48L2h0bWw+ XG4iKQorICAgICAgICBvdXRfZmlsZS5jbG9zZSgpCiAgICAgICAgIHJldHVybiBUcnVlCiAKICAg ICBkZWYgX3Nob3dfcmVzdWx0c19odG1sX2ZpbGUoc2VsZik6CkBAIC0xNDMyLDcgKzE0MzEsOCBA QCBkZWYgX2FkZF90b19kaWN0X29mX2xpc3RzKGRpY3QsIGtleSwgdmFsdWUpOgogZGVmIHJlYWRf dGVzdF9maWxlcyhmaWxlcyk6CiAgICAgdGVzdHMgPSBbXQogICAgIGZvciBmaWxlIGluIGZpbGVz OgotICAgICAgICBmb3IgbGluZSBpbiBvcGVuKGZpbGUpOgorICAgICAgICAjIEZJWE1FOiBUaGlz IGNvdWxkIGJlIGNsZWFuZXIgdXNpbmcgYSBsaXN0IGNvbXByZWhlbnNpb24uCisgICAgICAgIGZv ciBsaW5lIGluIGNvZGVjcy5vcGVuKGZpbGUsICJyIiwgInV0Zi04Iik6CiAgICAgICAgICAgICBs aW5lID0gdGVzdF9leHBlY3RhdGlvbnMuc3RyaXBfY29tbWVudHMobGluZSkKICAgICAgICAgICAg IGlmIGxpbmU6CiAgICAgICAgICAgICAgICAgdGVzdHMuYXBwZW5kKGxpbmUpCmRpZmYgLS1naXQg YS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy90ZXN0X3R5cGVzL2lt YWdlX2RpZmYucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy90 ZXN0X3R5cGVzL2ltYWdlX2RpZmYucHkKaW5kZXggYjQxNDM1OC4uMTk0N2RmOCAxMDA2NDQKLS0t IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvdGVzdF90eXBlcy9p bWFnZV9kaWZmLnB5CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rl c3RzL3Rlc3RfdHlwZXMvaW1hZ2VfZGlmZi5weQpAQCAtMzQsNiArMzQsOSBAQCBtYXRjaCwgcmV0 dXJucyBGYWlsdXJlSW1hZ2VIYXNoTWlzbWF0Y2ggYW5kIG91dHB1dHMgYm90aCBoYXNoZXMgaW50 byB0aGUgbGF5b3V0CiB0ZXN0IHJlc3VsdHMgZGlyZWN0b3J5LgogIiIiCiAKK2Zyb20gX19mdXR1 cmVfXyBpbXBvcnQgd2l0aF9zdGF0ZW1lbnQKKworaW1wb3J0IGNvZGVjcwogaW1wb3J0IGVycm5v CiBpbXBvcnQgbG9nZ2luZwogaW1wb3J0IG9zCkBAIC03OCw5ICs4MSw4IEBAIGNsYXNzIEltYWdl RGlmZih0ZXN0X3R5cGVfYmFzZS5UZXN0VHlwZUJhc2UpOgogICAgICAgICAgIHBuZ19wYXRoOiBw YXRoIHRvIHRoZSBhY3R1YWwgUE5HIHJlc3VsdCBmaWxlCiAgICAgICAgICAgY2hlY2tzdW06IHZh bHVlIG9mIHRoZSBhY3R1YWwgY2hlY2tzdW0gcmVzdWx0CiAgICAgICAgICIiIgotICAgICAgICBw bmdfZmlsZSA9IG9wZW4ocG5nX3BhdGgsICJyYiIpCi0gICAgICAgIHBuZ19kYXRhID0gcG5nX2Zp bGUucmVhZCgpCi0gICAgICAgIHBuZ19maWxlLmNsb3NlKCkKKyAgICAgICAgd2l0aCBvcGVuKHBu Z19wYXRoLCAicmIiKSBhcyBwbmdfZmlsZToKKyAgICAgICAgICAgIHBuZ19kYXRhID0gcG5nX2Zp bGUucmVhZCgpCiAgICAgICAgIHNlbGYuX3NhdmVfYmFzZWxpbmVfZGF0YShmaWxlbmFtZSwgcG5n X2RhdGEsICIucG5nIikKICAgICAgICAgc2VsZi5fc2F2ZV9iYXNlbGluZV9kYXRhKGZpbGVuYW1l LCBjaGVja3N1bSwgIi5jaGVja3N1bSIpCiAKQEAgLTE0MCw4ICsxNDIsMTAgQEAgY2xhc3MgSW1h Z2VEaWZmKHRlc3RfdHlwZV9iYXNlLlRlc3RUeXBlQmFzZSk6CiAgICAgICAgICAgICBfbG9nLmRl YnVnKCdVc2luZyAlcycgJSBleHBlY3RlZF9oYXNoX2ZpbGUpCiAgICAgICAgICAgICBfbG9nLmRl YnVnKCdVc2luZyAlcycgJSBleHBlY3RlZF9wbmdfZmlsZSkKIAorICAgICAgICAjIEZJWE1FOiBX ZSByZXBlYXQgdGhpcyBwYXR0ZXJuIG9mdGVuLCB3ZSBzaG91bGQgc2hhcmUgY29kZS4KICAgICAg ICAgdHJ5OgotICAgICAgICAgICAgZXhwZWN0ZWRfaGFzaCA9IG9wZW4oZXhwZWN0ZWRfaGFzaF9m aWxlLCAiciIpLnJlYWQoKQorICAgICAgICAgICAgd2l0aCBjb2RlY3Mub3BlbihleHBlY3RlZF9o YXNoX2ZpbGUsICJyIiwgImFzY2lpIikgYXMgZmlsZToKKyAgICAgICAgICAgICAgICBleHBlY3Rl ZF9oYXNoID0gZmlsZS5yZWFkKCkKICAgICAgICAgZXhjZXB0IElPRXJyb3IsIGU6CiAgICAgICAg ICAgICBpZiBlcnJuby5FTk9FTlQgIT0gZS5lcnJubzoKICAgICAgICAgICAgICAgICByYWlzZQpk aWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvdGVz dF90eXBlcy90ZXN0X3R5cGVfYmFzZS5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkv bGF5b3V0X3Rlc3RzL3Rlc3RfdHlwZXMvdGVzdF90eXBlX2Jhc2UucHkKaW5kZXggNGM5OWJlMC4u YzNlNjJhMCAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRf dGVzdHMvdGVzdF90eXBlcy90ZXN0X3R5cGVfYmFzZS5weQorKysgYi9XZWJLaXRUb29scy9TY3Jp cHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy90ZXN0X3R5cGVzL3Rlc3RfdHlwZV9iYXNlLnB5CkBA IC0zMiw2ICszMiw5IEBACiBBbHNvIGRlZmluZXMgdGhlIFRlc3RBcmd1bWVudHMgInN0cnVjdCIg dG8gcGFzcyB0aGVtIGFkZGl0aW9uYWwgYXJndW1lbnRzLgogIiIiCiAKK2Zyb20gX19mdXR1cmVf XyBpbXBvcnQgd2l0aF9zdGF0ZW1lbnQKKworaW1wb3J0IGNvZGVjcwogaW1wb3J0IGNnaQogaW1w b3J0IGVycm5vCiBpbXBvcnQgbG9nZ2luZwpAQCAtMTUwLDEwICsxNTMsMTEgQEAgY2xhc3MgVGVz dFR5cGVCYXNlKG9iamVjdCk6CiAgICAgICAgICIiIgogICAgICAgICByYWlzZSBOb3RJbXBsZW1l bnRlZAogCi0gICAgZGVmIF93cml0ZV9pbnRvX2ZpbGVfYXRfcGF0aChzZWxmLCBmaWxlX3BhdGgs IGNvbnRlbnRzKToKLSAgICAgICAgZmlsZSA9IG9wZW4oZmlsZV9wYXRoLCAid2IiKQotICAgICAg ICBmaWxlLndyaXRlKGNvbnRlbnRzKQotICAgICAgICBmaWxlLmNsb3NlKCkKKyAgICBkZWYgX3dy aXRlX2ludG9fZmlsZV9hdF9wYXRoKHNlbGYsIGZpbGVfcGF0aCwgYnl0ZV9hcnJheSk6CisgICAg ICAgICIiIlRoaXMgbWV0aG9kIGFzc3VtZXMgdGhhdCBieXRlX2FycmF5IGlzIGFscmVhZHkgZW5j b2RlZAorICAgICAgICBpbnRvIHRoZSByaWdodCBmb3JtYXQuIiIiCisgICAgICAgIHdpdGggb3Bl bihmaWxlX3BhdGgsICJ3YiIpIGFzIGZpbGU6CisgICAgICAgICAgICBmaWxlLndyaXRlKGJ5dGVf YXJyYXkpCiAKICAgICBkZWYgd3JpdGVfb3V0cHV0X2ZpbGVzKHNlbGYsIHBvcnQsIGZpbGVuYW1l LCBmaWxlX3R5cGUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICBvdXRwdXQsIGV4cGVjdGVk LCBwcmludF90ZXh0X2RpZmZzPUZhbHNlKToKQEAgLTE4OCwxNCArMTkyLDE0IEBAIGNsYXNzIFRl c3RUeXBlQmFzZShvYmplY3QpOgogCiAgICAgICAgIGRpZmYgPSBwb3J0LmRpZmZfdGV4dChleHBl Y3RlZCwgb3V0cHV0LCBleHBlY3RlZF9maWxlbmFtZSwgYWN0dWFsX2ZpbGVuYW1lKQogICAgICAg ICBkaWZmX2ZpbGVuYW1lID0gc2VsZi5vdXRwdXRfZmlsZW5hbWUoZmlsZW5hbWUsIHNlbGYuRklM RU5BTUVfU1VGRklYX0RJRkYgKyBmaWxlX3R5cGUpCi0gICAgICAgIHNlbGYuX3dyaXRlX2ludG9f ZmlsZV9hdF9wYXRoKGRpZmZfZmlsZW5hbWUsIGRpZmYpCisgICAgICAgIHNlbGYuX3dyaXRlX2lu dG9fZmlsZV9hdF9wYXRoKGRpZmZfZmlsZW5hbWUsIGRpZmYuZW5jb2RlKCJ1dGYtOCIpKQogCiAg ICAgICAgICMgU2hlbGwgb3V0IHRvIHdkaWZmIHRvIGdldCBjb2xvcmVkIGlubGluZSBkaWZmcy4K ICAgICAgICAgd2RpZmYgPSBwb3J0LndkaWZmX3RleHQoZXhwZWN0ZWRfZmlsZW5hbWUsIGFjdHVh bF9maWxlbmFtZSkKICAgICAgICAgd2RpZmZfZmlsZW5hbWUgPSBzZWxmLm91dHB1dF9maWxlbmFt ZShmaWxlbmFtZSwgc2VsZi5GSUxFTkFNRV9TVUZGSVhfV0RJRkYpCi0gICAgICAgIHNlbGYuX3dy aXRlX2ludG9fZmlsZV9hdF9wYXRoKHdkaWZmX2ZpbGVuYW1lLCB3ZGlmZikKKyAgICAgICAgc2Vs Zi5fd3JpdGVfaW50b19maWxlX2F0X3BhdGgod2RpZmZfZmlsZW5hbWUsIHdkaWZmLmVuY29kZSgi dXRmLTgiKSkKIAogICAgICAgICAjIFVzZSBXZWJLaXQncyBQcmV0dHlQYXRjaC5yYiB0byBnZXQg YW4gSFRNTCBkaWZmLgogICAgICAgICBwcmV0dHlfcGF0Y2ggPSBwb3J0LnByZXR0eV9wYXRjaF90 ZXh0KGRpZmZfZmlsZW5hbWUpCiAgICAgICAgIHByZXR0eV9wYXRjaF9maWxlbmFtZSA9IHNlbGYu b3V0cHV0X2ZpbGVuYW1lKGZpbGVuYW1lLCBzZWxmLkZJTEVOQU1FX1NVRkZJWF9QUkVUVFlfUEFU Q0gpCi0gICAgICAgIHNlbGYuX3dyaXRlX2ludG9fZmlsZV9hdF9wYXRoKHByZXR0eV9wYXRjaF9m aWxlbmFtZSwgcHJldHR5X3BhdGNoKQorICAgICAgICBzZWxmLl93cml0ZV9pbnRvX2ZpbGVfYXRf cGF0aChwcmV0dHlfcGF0Y2hfZmlsZW5hbWUsIHByZXR0eV9wYXRjaC5lbmNvZGUoInV0Zi04Iikp CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy90 ZXN0X3R5cGVzL3RleHRfZGlmZi5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5 b3V0X3Rlc3RzL3Rlc3RfdHlwZXMvdGV4dF9kaWZmLnB5CmluZGV4IDhmNzkwN2MuLmQzZTZjYWYg MTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3Rl c3RfdHlwZXMvdGV4dF9kaWZmLnB5CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkv bGF5b3V0X3Rlc3RzL3Rlc3RfdHlwZXMvdGV4dF9kaWZmLnB5CkBAIC0zMyw2ICszMyw5IEBAIElm IHRoZSBvdXRwdXQgZG9lc24ndCBtYXRjaCwgcmV0dXJucyBGYWlsdXJlVGV4dE1pc21hdGNoIGFu ZCBvdXRwdXRzIHRoZSBkaWZmCiBmaWxlcyBpbnRvIHRoZSBsYXlvdXQgdGVzdCByZXN1bHRzIGRp cmVjdG9yeS4KICIiIgogCitmcm9tIF9fZnV0dXJlX18gaW1wb3J0IHdpdGhfc3RhdGVtZW50CisK K2ltcG9ydCBjb2RlY3MKIGltcG9ydCBlcnJubwogaW1wb3J0IGxvZ2dpbmcKIGltcG9ydCBvcy5w YXRoCkBAIC03MCw4ICs3MywxMCBAQCBjbGFzcyBUZXN0VGV4dERpZmYodGVzdF90eXBlX2Jhc2Uu VGVzdFR5cGVCYXNlKToKICAgICAgICAgcmV0dXJuIHNlbGYuZ2V0X25vcm1hbGl6ZWRfdGV4dChl eHBlY3RlZF9maWxlbmFtZSkKIAogICAgIGRlZiBnZXRfbm9ybWFsaXplZF90ZXh0KHNlbGYsIGZp bGVuYW1lKToKKyAgICAgICAgIyBGSVhNRTogV2UgcmVwZWF0IHRoaXMgcGF0dGVybiBvZnRlbiwg d2Ugc2hvdWxkIHNoYXJlIGNvZGUuCiAgICAgICAgIHRyeToKLSAgICAgICAgICAgIHRleHQgPSBv cGVuKGZpbGVuYW1lKS5yZWFkKCkKKyAgICAgICAgICAgIHdpdGggY29kZWNzLm9wZW4oZmlsZW5h bWUsICJyIiwgInV0Zi04IikgYXMgZmlsZToKKyAgICAgICAgICAgICAgICB0ZXh0ID0gZmlsZS5y ZWFkKCkKICAgICAgICAgZXhjZXB0IElPRXJyb3IsIGU6CiAgICAgICAgICAgICBpZiBlcnJuby5F Tk9FTlQgIT0gZS5lcnJubzoKICAgICAgICAgICAgICAgICByYWlzZQpkaWZmIC0tZ2l0IGEvV2Vi S2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9zdHlsZS9maWxlcmVhZGVyX3VuaXR0ZXN0LnB5IGIv V2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9zdHlsZS9maWxlcmVhZGVyX3VuaXR0ZXN0LnB5 CmluZGV4IDhkMWExNTkuLjU3YjQxMjYgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMv d2Via2l0cHkvc3R5bGUvZmlsZXJlYWRlcl91bml0dGVzdC5weQorKysgYi9XZWJLaXRUb29scy9T Y3JpcHRzL3dlYmtpdHB5L3N0eWxlL2ZpbGVyZWFkZXJfdW5pdHRlc3QucHkKQEAgLTIyLDYgKzIy LDkgQEAKIAogIiIiQ29udGFpbnMgdW5pdCB0ZXN0cyBmb3IgZmlsZXJlYWRlci5weS4iIiIKIAor ZnJvbSBfX2Z1dHVyZV9fIGltcG9ydCB3aXRoX3N0YXRlbWVudAorCitpbXBvcnQgY29kZWNzCiBp bXBvcnQgb3MKIGltcG9ydCBzaHV0aWwKIGltcG9ydCB0ZW1wZmlsZQpAQCAtNjcsMTQgKzcwLDEy IEBAIGNsYXNzIFRleHRGaWxlUmVhZGVyVGVzdChMb2dnaW5nVGVzdENhc2UpOgogICAgICAgICBM b2dnaW5nVGVzdENhc2UudGVhckRvd24oc2VsZikKICAgICAgICAgc2h1dGlsLnJtdHJlZShzZWxm Ll90ZW1wX2RpcikKIAotICAgIGRlZiBfY3JlYXRlX2ZpbGUoc2VsZiwgcmVsX3BhdGgsIHRleHQp OgorICAgIGRlZiBfY3JlYXRlX2ZpbGUoc2VsZiwgcmVsX3BhdGgsIHRleHQsIGVuY29kaW5nPSJ1 dGYtOCIpOgogICAgICAgICAiIiJDcmVhdGUgYSBmaWxlIHdpdGggZ2l2ZW4gdGV4dCBhbmQgcmV0 dXJuIHRoZSBwYXRoIHRvIHRoZSBmaWxlLiIiIgorICAgICAgICAjIEZJWE1FOiBUaGVyZSBhcmUg YmV0dGVyL21vcmUgc2VjdXJlIEFQSXMgZm9yIGNyZWF0aW4gdG1wIGZpbGUgcGF0aHMuCiAgICAg ICAgIGZpbGVfcGF0aCA9IG9zLnBhdGguam9pbihzZWxmLl90ZW1wX2RpciwgcmVsX3BhdGgpCi0K LSAgICAgICAgZmlsZSA9IG9wZW4oZmlsZV9wYXRoLCAndycpCi0gICAgICAgIGZpbGUud3JpdGUo dGV4dCkKLSAgICAgICAgZmlsZS5jbG9zZSgpCi0KKyAgICAgICAgd2l0aCBjb2RlY3Mub3Blbihm aWxlX3BhdGgsICJ3IiwgZW5jb2RpbmcpIGFzIGZpbGU6CisgICAgICAgICAgICBmaWxlLndyaXRl KHRleHQpCiAgICAgICAgIHJldHVybiBmaWxlX3BhdGgKIAogICAgIGRlZiBfcGFzc2VkX3RvX3By b2Nlc3NvcihzZWxmKToKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkv dGhpcmRwYXJ0eS9fX2luaXRfXy5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGhp cmRwYXJ0eS9fX2luaXRfXy5weQppbmRleCBmMWU1MzM0Li5jMDUyZjAwIDEwMDY0NAotLS0gYS9X ZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L3RoaXJkcGFydHkvX19pbml0X18ucHkKKysrIGIv V2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS90aGlyZHBhcnR5L19faW5pdF9fLnB5CkBAIC0y NCw2ICsyNCw5IEBACiAKICIiIkF1dG9pbnN0YWxscyB0aGlyZC1wYXJ0eSBjb2RlIHJlcXVpcmVk IGJ5IFdlYktpdC4iIiIKIAorZnJvbSBfX2Z1dHVyZV9fIGltcG9ydCB3aXRoX3N0YXRlbWVudAor CitpbXBvcnQgY29kZWNzCiBpbXBvcnQgb3MKIAogZnJvbSB3ZWJraXRweS5jb21tb24uc3lzdGVt LmF1dG9pbnN0YWxsIGltcG9ydCBBdXRvSW5zdGFsbGVyCkBAIC04OCwxMCArOTEsNyBAQCBpbnN0 YWxsZXIuaW5zdGFsbCh1cmw9Imh0dHA6Ly9pd2ViLmRsLnNvdXJjZWZvcmdlLm5ldC9wcm9qZWN0 L3B5dGhvbi1pcmNsaWIvcHl0aAogCiByZWFkbWVfcGF0aCA9IG9zLnBhdGguam9pbihhdXRvaW5z dGFsbGVkX2RpciwgIlJFQURNRSIpCiBpZiBub3Qgb3MucGF0aC5leGlzdHMocmVhZG1lX3BhdGgp OgotICAgIGZpbGUgPSBvcGVuKHJlYWRtZV9wYXRoLCAidyIpCi0gICAgdHJ5OgorICAgIHdpdGgg Y29kZWNzLm9wZW4ocmVhZG1lX3BhdGgsICJ3IiwgImFzY2lpIikgYXMgZmlsZToKICAgICAgICAg ZmlsZS53cml0ZSgiVGhpcyBkaXJlY3RvcnkgaXMgYXV0by1nZW5lcmF0ZWQgYnkgV2ViS2l0IGFu ZCBpcyAiCiAgICAgICAgICAgICAgICAgICAgInNhZmUgdG8gZGVsZXRlLlxuSXQgY29udGFpbnMg bmVlZGVkIHRoaXJkLXBhcnR5IFB5dGhvbiAiCiAgICAgICAgICAgICAgICAgICAgInBhY2thZ2Vz IGF1dG9tYXRpY2FsbHkgZG93bmxvYWRlZCBmcm9tIHRoZSB3ZWIuIikKLSAgICBmaW5hbGx5Ogot ICAgICAgICBmaWxlLmNsb3NlKCkKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvdG9vbC9jb21tYW5kcy9lYXJseXdhcm5pbmdzeXN0ZW0ucHkgYi9XZWJLaXRUb29scy9T Y3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29tbWFuZHMvZWFybHl3YXJuaW5nc3lzdGVtLnB5CmluZGV4 IDllYTM0YzAuLjc1MDVjNjIgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0 cHkvdG9vbC9jb21tYW5kcy9lYXJseXdhcm5pbmdzeXN0ZW0ucHkKKysrIGIvV2ViS2l0VG9vbHMv U2NyaXB0cy93ZWJraXRweS90b29sL2NvbW1hbmRzL2Vhcmx5d2FybmluZ3N5c3RlbS5weQpAQCAt MjYsOCArMjYsNiBAQAogIyAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklT SU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKICMgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJ RiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KIAotZnJvbSBTdHJp bmdJTyBpbXBvcnQgU3RyaW5nSU8KLQogZnJvbSB3ZWJraXRweS50b29sLmNvbW1hbmRzLnF1ZXVl cyBpbXBvcnQgQWJzdHJhY3RSZXZpZXdRdWV1ZQogZnJvbSB3ZWJraXRweS5jb21tb24uY29uZmln LmNvbW1pdHRlcnMgaW1wb3J0IENvbW1pdHRlckxpc3QKIGZyb20gd2Via2l0cHkuY29tbW9uLmNv bmZpZy5wb3J0cyBpbXBvcnQgV2ViS2l0UG9ydApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2Ny aXB0cy93ZWJraXRweS90b29sL2NvbW1hbmRzL3F1ZXVlcy5weSBiL1dlYktpdFRvb2xzL1Njcmlw dHMvd2Via2l0cHkvdG9vbC9jb21tYW5kcy9xdWV1ZXMucHkKaW5kZXggZjBkYTM3OS4uNzc1YWE0 NCAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL2NvbW1hbmRz L3F1ZXVlcy5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29tbWFu ZHMvcXVldWVzLnB5CkBAIC03MSw4ICs3MSwxMSBAQCBjbGFzcyBBYnN0cmFjdFF1ZXVlKENvbW1h bmQsIFF1ZXVlRW5naW5lRGVsZWdhdGUpOgogICAgIGRlZiBydW5fd2Via2l0X3BhdGNoKHNlbGYs IGFyZ3MpOgogICAgICAgICB3ZWJraXRfcGF0Y2hfYXJncyA9IFtzZWxmLnRvb2wucGF0aCgpXQog ICAgICAgICAjIEZJWE1FOiBUaGlzIGlzIGEgaGFjaywgd2Ugc2hvdWxkIGhhdmUgYSBtb3JlIGdl bmVyYWwgd2F5IHRvIHBhc3MgZ2xvYmFsIG9wdGlvbnMuCisgICAgICAgICMgRklYTUU6IFdlIG11 c3QgYWx3YXlzIHBhc3MgZ2xvYmFsIG9wdGlvbnMgYW5kIHRoZWlyIHZhbHVlIGluIG9uZSBhcmd1 bWVudAorICAgICAgICAjIGJlY2F1c2Ugb3VyIGdsb2JhbCBvcHRpb24gY29kZSBsb29rcyBmb3Ig dGhlIGZpcnN0IGFyZ3VtZW50IHdoaWNoIGRvZXMKKyAgICAgICAgIyBub3QgYmVnaW4gd2l0aCAi LSIgYW5kIGFzc3VtZXMgdGhhdCBpcyB0aGUgY29tbWFuZCBuYW1lLgogICAgICAgICB3ZWJraXRf cGF0Y2hfYXJncyArPSBbIi0tc3RhdHVzLWhvc3Q9JXMiICUgc2VsZi50b29sLnN0YXR1c19zZXJ2 ZXIuaG9zdF0KLSAgICAgICAgd2Via2l0X3BhdGNoX2FyZ3MgKz0gbWFwKHN0ciwgYXJncykKKyAg ICAgICAgd2Via2l0X3BhdGNoX2FyZ3MuZXh0ZW5kKGFyZ3MpCiAgICAgICAgIHJldHVybiBzZWxm LnRvb2wuZXhlY3V0aXZlLnJ1bl9hbmRfdGhyb3dfaWZfZmFpbCh3ZWJraXRfcGF0Y2hfYXJncykK IAogICAgIGRlZiBfbG9nX2RpcmVjdG9yeShzZWxmKToKQEAgLTEyMyw3ICsxMjYsMTAgQEAgY2xh c3MgQWJzdHJhY3RRdWV1ZShDb21tYW5kLCBRdWV1ZUVuZ2luZURlbGVnYXRlKToKICAgICAgICAg aWYgaXNfZXJyb3I6CiAgICAgICAgICAgICBtZXNzYWdlID0gIkVycm9yOiAlcyIgJSBtZXNzYWdl CiAgICAgICAgIG91dHB1dCA9IHNjcmlwdF9lcnJvci5tZXNzYWdlX3dpdGhfb3V0cHV0KG91dHB1 dF9saW1pdD0xMDI0KjEwMjQpICMgMU1CCi0gICAgICAgIHJldHVybiB0b29sLnN0YXR1c19zZXJ2 ZXIudXBkYXRlX3N0YXR1cyhjbHMubmFtZSwgbWVzc2FnZSwgc3RhdGVbInBhdGNoIl0sIFN0cmlu Z0lPKG91dHB1dCkpCisgICAgICAgICMgV2UgcHJlLWVuY29kZSB0aGUgc3RyaW5nIHRvIGEgYnl0 ZSBhcnJheSBiZWZvcmUgcGFzc2luZyBpdAorICAgICAgICAjIHRvIHN0YXR1c19zZXJ2ZXIsIGJl Y2F1c2UgQ2xpZW50Rm9ybSAocGFydCBvZiBtZWNoYW5pemUpCisgICAgICAgICMgd2FudHMgYSBm aWxlLWxpa2Ugb2JqZWN0IHdpdGggcHJlLWVuY29kZWQgZGF0YS4KKyAgICAgICAgcmV0dXJuIHRv b2wuc3RhdHVzX3NlcnZlci51cGRhdGVfc3RhdHVzKGNscy5uYW1lLCBtZXNzYWdlLCBzdGF0ZVsi cGF0Y2giXSwgU3RyaW5nSU8ob3V0cHV0LmVuY29kZSgidXRmLTgiKSkpCiAKIAogY2xhc3MgQWJz dHJhY3RQYXRjaFF1ZXVlKEFic3RyYWN0UXVldWUpOgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMv U2NyaXB0cy93ZWJraXRweS90b29sL2NvbW1hbmRzL3F1ZXVlc191bml0dGVzdC5weSBiL1dlYktp dFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9jb21tYW5kcy9xdWV1ZXNfdW5pdHRlc3QucHkK aW5kZXggZjBmN2M4Ni4uMTZlYjA1MyAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93 ZWJraXRweS90b29sL2NvbW1hbmRzL3F1ZXVlc191bml0dGVzdC5weQorKysgYi9XZWJLaXRUb29s cy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29tbWFuZHMvcXVldWVzX3VuaXR0ZXN0LnB5CkBAIC03 NSw3ICs3NSw3IEBAIGNsYXNzIEFic3RyYWN0UXVldWVUZXN0KENvbW1hbmRzVGVzdCk6CiAgICAg ICAgIHF1ZXVlLmJpbmRfdG9fdG9vbCh0b29sKQogCiAgICAgICAgIHF1ZXVlLnJ1bl93ZWJraXRf cGF0Y2gocnVuX2FyZ3MpCi0gICAgICAgIGV4cGVjdGVkX3J1bl9hcmdzID0gWyJlY2hvIiwgIi0t c3RhdHVzLWhvc3Q9ZXhhbXBsZS5jb20iXSArIG1hcChzdHIsIHJ1bl9hcmdzKQorICAgICAgICBl eHBlY3RlZF9ydW5fYXJncyA9IFsiZWNobyIsICItLXN0YXR1cy1ob3N0PWV4YW1wbGUuY29tIl0g KyBydW5fYXJncwogICAgICAgICB0b29sLmV4ZWN1dGl2ZS5ydW5fYW5kX3Rocm93X2lmX2ZhaWwu YXNzZXJ0X2NhbGxlZF93aXRoKGV4cGVjdGVkX3J1bl9hcmdzKQogCiAgICAgZGVmIHRlc3RfcnVu X3dlYmtpdF9wYXRjaChzZWxmKToKQEAgLTE1MCw3ICsxNTAsNyBAQCBXYXJuaW5nLCBhdHRhY2ht ZW50IDEyOCBvbiBidWcgNDIgaGFzIGludmFsaWQgY29tbWl0dGVyIChub24tY29tbWl0dGVyQGV4 YW1wbGUuYwogV2FybmluZywgYXR0YWNobWVudCAxMjggb24gYnVnIDQyIGhhcyBpbnZhbGlkIGNv bW1pdHRlciAobm9uLWNvbW1pdHRlckBleGFtcGxlLmNvbSkKIDEgcGF0Y2ggaW4gY29tbWl0LXF1 ZXVlIFsxMDZdCiAiIiIsCi0gICAgICAgICAgICAicHJvY2Vzc193b3JrX2l0ZW0iOiAiTU9DSyBy dW5fYW5kX3Rocm93X2lmX2ZhaWw6IFsnZWNobycsICctLXN0YXR1cy1ob3N0PWV4YW1wbGUuY29t JywgJ2xhbmQtYXR0YWNobWVudCcsICctLWZvcmNlLWNsZWFuJywgJy0tYnVpbGQnLCAnLS10ZXN0 JywgJy0tbm9uLWludGVyYWN0aXZlJywgJy0taWdub3JlLWJ1aWxkZXJzJywgJy0tYnVpbGQtc3R5 bGU9Ym90aCcsICctLXF1aWV0JywgJzc2NTQzJ11cbiIsCisgICAgICAgICAgICAicHJvY2Vzc193 b3JrX2l0ZW0iOiAiTU9DSyBydW5fYW5kX3Rocm93X2lmX2ZhaWw6IFsnZWNobycsICctLXN0YXR1 cy1ob3N0PWV4YW1wbGUuY29tJywgJ2xhbmQtYXR0YWNobWVudCcsICctLWZvcmNlLWNsZWFuJywg Jy0tYnVpbGQnLCAnLS10ZXN0JywgJy0tbm9uLWludGVyYWN0aXZlJywgJy0taWdub3JlLWJ1aWxk ZXJzJywgJy0tYnVpbGQtc3R5bGU9Ym90aCcsICctLXF1aWV0JywgNzY1NDNdXG4iLAogICAgICAg ICB9CiAgICAgICAgIHNlbGYuYXNzZXJ0X3F1ZXVlX291dHB1dHMoQ29tbWl0UXVldWUoKSwgdG9v bD10b29sLCB3b3JrX2l0ZW09cm9sbG91dF9wYXRjaCwgZXhwZWN0ZWRfc3RkZXJyPWV4cGVjdGVk X3N0ZGVycikKIApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29s L2NvbW1hbmRzL3VwbG9hZC5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9j b21tYW5kcy91cGxvYWQucHkKaW5kZXggYmRmMDYwYS4uMzNiY2E3YSAxMDA2NDQKLS0tIGEvV2Vi S2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL2NvbW1hbmRzL3VwbG9hZC5weQorKysgYi9X ZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29tbWFuZHMvdXBsb2FkLnB5CkBAIC0z MCw3ICszMCw2IEBACiAKIGltcG9ydCBvcwogaW1wb3J0IHJlCi1pbXBvcnQgU3RyaW5nSU8KIGlt cG9ydCBzeXMKIAogZnJvbSBvcHRwYXJzZSBpbXBvcnQgbWFrZV9vcHRpb24KQEAgLTI2MCwxMCAr MjU5LDYgQEAgY2xhc3MgUG9zdENvbW1pdHMoQWJzdHJhY3REZWNsYXJhdGl2ZUNvbW1hbmQpOgog ICAgICAgICAgICAgY29tbWVudF90ZXh0ICs9IHRvb2wuc2NtKCkuZmlsZXNfY2hhbmdlZF9zdW1t YXJ5X2Zvcl9jb21taXQoY29tbWl0X2lkKQogICAgICAgICByZXR1cm4gY29tbWVudF90ZXh0CiAK LSAgICBkZWYgX2RpZmZfZmlsZV9mb3JfY29tbWl0KHNlbGYsIHRvb2wsIGNvbW1pdF9pZCk6Ci0g ICAgICAgIGRpZmYgPSB0b29sLnNjbSgpLmNyZWF0ZV9wYXRjaF9mcm9tX2xvY2FsX2NvbW1pdChj b21taXRfaWQpCi0gICAgICAgIHJldHVybiBTdHJpbmdJTy5TdHJpbmdJTyhkaWZmKSAjIGFkZF9w YXRjaF90b19idWcgZXhwZWN0cyBhIGZpbGUtbGlrZSBvYmplY3QKLQogICAgIGRlZiBleGVjdXRl KHNlbGYsIG9wdGlvbnMsIGFyZ3MsIHRvb2wpOgogICAgICAgICBjb21taXRfaWRzID0gdG9vbC5z Y20oKS5jb21taXRfaWRzX2Zyb21fY29tbWl0aXNoX2FyZ3VtZW50cyhhcmdzKQogICAgICAgICBp ZiBsZW4oY29tbWl0X2lkcykgPiAxMDogIyBXZSBjb3VsZCBsb3dlciB0aGlzIGxpbWl0LCAxMCBp cyB0b28gbWFueSBmb3Igb25lIGJ1ZyBhcy1pcy4KQEAgLTI4NCwxMCArMjc5LDEwIEBAIGNsYXNz IFBvc3RDb21taXRzKEFic3RyYWN0RGVjbGFyYXRpdmVDb21tYW5kKToKICAgICAgICAgICAgICAg ICBzdGVwcy5PYnNvbGV0ZVBhdGNoZXModG9vbCwgb3B0aW9ucykucnVuKHN0YXRlKQogICAgICAg ICAgICAgICAgIGhhdmVfb2Jzb2xldGVkX3BhdGNoZXMuYWRkKGJ1Z19pZCkKIAotICAgICAgICAg ICAgZGlmZl9maWxlID0gc2VsZi5fZGlmZl9maWxlX2Zvcl9jb21taXQodG9vbCwgY29tbWl0X2lk KQorICAgICAgICAgICAgZGlmZiA9IHRvb2wuc2NtKCkuY3JlYXRlX3BhdGNoX2Zyb21fbG9jYWxf Y29tbWl0KGNvbW1pdF9pZCkKICAgICAgICAgICAgIGRlc2NyaXB0aW9uID0gb3B0aW9ucy5kZXNj cmlwdGlvbiBvciBjb21taXRfbWVzc2FnZS5kZXNjcmlwdGlvbihsc3RyaXA9VHJ1ZSwgc3RyaXBf dXJsPVRydWUpCiAgICAgICAgICAgICBjb21tZW50X3RleHQgPSBzZWxmLl9jb21tZW50X3RleHRf Zm9yX2NvbW1pdChvcHRpb25zLCBjb21taXRfbWVzc2FnZSwgdG9vbCwgY29tbWl0X2lkKQotICAg ICAgICAgICAgdG9vbC5idWdzLmFkZF9wYXRjaF90b19idWcoYnVnX2lkLCBkaWZmX2ZpbGUsIGRl c2NyaXB0aW9uLCBjb21tZW50X3RleHQsIG1hcmtfZm9yX3Jldmlldz1vcHRpb25zLnJldmlldywg bWFya19mb3JfY29tbWl0X3F1ZXVlPW9wdGlvbnMucmVxdWVzdF9jb21taXQpCisgICAgICAgICAg ICB0b29sLmJ1Z3MuYWRkX3BhdGNoX3RvX2J1ZyhidWdfaWQsIGRpZmYsIGRlc2NyaXB0aW9uLCBj b21tZW50X3RleHQsIG1hcmtfZm9yX3Jldmlldz1vcHRpb25zLnJldmlldywgbWFya19mb3JfY29t bWl0X3F1ZXVlPW9wdGlvbnMucmVxdWVzdF9jb21taXQpCiAKIAogIyBGSVhNRTogVGhpcyBjb21t YW5kIG5lZWRzIHRvIGJlIGJyb3VnaHQgaW50byB0aGUgbW9kZXJuIGFnZSB3aXRoIHN0ZXBzIGFu ZCBDb21taXRJbmZvLgpAQCAtNDA0LDggKzM5OSw3IEBAIGNsYXNzIENyZWF0ZUJ1ZyhBYnN0cmFj dERlY2xhcmF0aXZlQ29tbWFuZCk6CiAgICAgICAgICAgICBjb21tZW50X3RleHQgKz0gdG9vbC5z Y20oKS5maWxlc19jaGFuZ2VkX3N1bW1hcnlfZm9yX2NvbW1pdChjb21taXRfaWQpCiAKICAgICAg ICAgZGlmZiA9IHRvb2wuc2NtKCkuY3JlYXRlX3BhdGNoX2Zyb21fbG9jYWxfY29tbWl0KGNvbW1p dF9pZCkKLSAgICAgICAgZGlmZl9maWxlID0gU3RyaW5nSU8uU3RyaW5nSU8oZGlmZikgIyBjcmVh dGVfYnVnIGV4cGVjdHMgYSBmaWxlLWxpa2Ugb2JqZWN0Ci0gICAgICAgIGJ1Z19pZCA9IHRvb2wu YnVncy5jcmVhdGVfYnVnKGJ1Z190aXRsZSwgY29tbWVudF90ZXh0LCBvcHRpb25zLmNvbXBvbmVu dCwgZGlmZl9maWxlLCAiUGF0Y2giLCBjYz1vcHRpb25zLmNjLCBtYXJrX2Zvcl9yZXZpZXc9b3B0 aW9ucy5yZXZpZXcsIG1hcmtfZm9yX2NvbW1pdF9xdWV1ZT1vcHRpb25zLnJlcXVlc3RfY29tbWl0 KQorICAgICAgICBidWdfaWQgPSB0b29sLmJ1Z3MuY3JlYXRlX2J1ZyhidWdfdGl0bGUsIGNvbW1l bnRfdGV4dCwgb3B0aW9ucy5jb21wb25lbnQsIGRpZmYsICJQYXRjaCIsIGNjPW9wdGlvbnMuY2Ms IG1hcmtfZm9yX3Jldmlldz1vcHRpb25zLnJldmlldywgbWFya19mb3JfY29tbWl0X3F1ZXVlPW9w dGlvbnMucmVxdWVzdF9jb21taXQpCiAKICAgICAgICAgaWYgYnVnX2lkIGFuZCBsZW4oY29tbWl0 X2lkcykgPiAxOgogICAgICAgICAgICAgb3B0aW9ucy5idWdfaWQgPSBidWdfaWQKQEAgLTQyNCw4 ICs0MTgsNyBAQCBjbGFzcyBDcmVhdGVCdWcoQWJzdHJhY3REZWNsYXJhdGl2ZUNvbW1hbmQpOgog ICAgICAgICAgICAgY29tbWVudF90ZXh0ID0gY29tbWl0X21lc3NhZ2UuYm9keShsc3RyaXA9VHJ1 ZSkKIAogICAgICAgICBkaWZmID0gdG9vbC5zY20oKS5jcmVhdGVfcGF0Y2goKQotICAgICAgICBk aWZmX2ZpbGUgPSBTdHJpbmdJTy5TdHJpbmdJTyhkaWZmKSAjIGNyZWF0ZV9idWcgZXhwZWN0cyBh IGZpbGUtbGlrZSBvYmplY3QKLSAgICAgICAgYnVnX2lkID0gdG9vbC5idWdzLmNyZWF0ZV9idWco YnVnX3RpdGxlLCBjb21tZW50X3RleHQsIG9wdGlvbnMuY29tcG9uZW50LCBkaWZmX2ZpbGUsICJQ YXRjaCIsIGNjPW9wdGlvbnMuY2MsIG1hcmtfZm9yX3Jldmlldz1vcHRpb25zLnJldmlldywgbWFy a19mb3JfY29tbWl0X3F1ZXVlPW9wdGlvbnMucmVxdWVzdF9jb21taXQpCisgICAgICAgIGJ1Z19p ZCA9IHRvb2wuYnVncy5jcmVhdGVfYnVnKGJ1Z190aXRsZSwgY29tbWVudF90ZXh0LCBvcHRpb25z LmNvbXBvbmVudCwgZGlmZiwgIlBhdGNoIiwgY2M9b3B0aW9ucy5jYywgbWFya19mb3JfcmV2aWV3 PW9wdGlvbnMucmV2aWV3LCBtYXJrX2Zvcl9jb21taXRfcXVldWU9b3B0aW9ucy5yZXF1ZXN0X2Nv bW1pdCkKIAogICAgIGRlZiBwcm9tcHRfZm9yX2J1Z190aXRsZV9hbmRfY29tbWVudChzZWxmKToK ICAgICAgICAgYnVnX3RpdGxlID0gVXNlci5wcm9tcHQoIkJ1ZyB0aXRsZTogIikKZGlmZiAtLWdp dCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9tb2NrdG9vbC5weSBiL1dlYktp dFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9tb2NrdG9vbC5weQppbmRleCBjYzM2MWZmLi4w MTY5NTU5IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvbW9j a3Rvb2wucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL21vY2t0b29s LnB5CkBAIC0yNjAsNyArMjYwLDcgQEAgY2xhc3MgTW9ja0J1Z3ppbGxhKE1vY2spOgogICAgICAg ICAgICAgICAgICAgIGJ1Z190aXRsZSwKICAgICAgICAgICAgICAgICAgICBidWdfZGVzY3JpcHRp b24sCiAgICAgICAgICAgICAgICAgICAgY29tcG9uZW50PU5vbmUsCi0gICAgICAgICAgICAgICAg ICAgcGF0Y2hfZmlsZV9vYmplY3Q9Tm9uZSwKKyAgICAgICAgICAgICAgICAgICBkaWZmPU5vbmUs CiAgICAgICAgICAgICAgICAgICAgcGF0Y2hfZGVzY3JpcHRpb249Tm9uZSwKICAgICAgICAgICAg ICAgICAgICBjYz1Ob25lLAogICAgICAgICAgICAgICAgICAgIGJsb2NrZWQ9Tm9uZSwKQEAgLTMw Miw3ICszMDIsNyBAQCBjbGFzcyBNb2NrQnVnemlsbGEoTW9jayk6CiAKICAgICBkZWYgYWRkX3Bh dGNoX3RvX2J1ZyhzZWxmLAogICAgICAgICAgICAgICAgICAgICAgICAgIGJ1Z19pZCwKLSAgICAg ICAgICAgICAgICAgICAgICAgICBwYXRjaF9maWxlX29iamVjdCwKKyAgICAgICAgICAgICAgICAg ICAgICAgICBkaWZmLAogICAgICAgICAgICAgICAgICAgICAgICAgIGRlc2NyaXB0aW9uLAogICAg ICAgICAgICAgICAgICAgICAgICAgIGNvbW1lbnRfdGV4dD1Ob25lLAogICAgICAgICAgICAgICAg ICAgICAgICAgIG1hcmtfZm9yX3Jldmlldz1GYWxzZSwKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xz L1NjcmlwdHMvd2Via2l0cHkvdG9vbC9zdGVwcy9hYnN0cmFjdHN0ZXAucHkgYi9XZWJLaXRUb29s cy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvYWJzdHJhY3RzdGVwLnB5CmluZGV4IDFhZDM0 M2QuLjIxODdmYzAgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9v bC9zdGVwcy9hYnN0cmFjdHN0ZXAucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRw eS90b29sL3N0ZXBzL2Fic3RyYWN0c3RlcC5weQpAQCAtMzksNyArMzksNyBAQCBjbGFzcyBBYnN0 cmFjdFN0ZXAob2JqZWN0KToKICAgICBkZWYgX3J1bl9zY3JpcHQoc2VsZiwgc2NyaXB0X25hbWUs IHF1aWV0PUZhbHNlLCBwb3J0PVdlYktpdFBvcnQpOgogICAgICAgICBsb2coIlJ1bm5pbmcgJXMi ICUgc2NyaXB0X25hbWUpCiAgICAgICAgICMgRklYTUU6IFRoaXMgc2hvdWxkIHVzZSBzZWxmLnBv cnQoKQotICAgICAgICBzZWxmLl90b29sLmV4ZWN1dGl2ZS5ydW5fYW5kX3Rocm93X2lmX2ZhaWwo cG9ydC5zY3JpcHRfcGF0aChzY3JpcHRfbmFtZSksIHF1aWV0KQorICAgICAgICBzZWxmLl90b29s LmV4ZWN1dGl2ZS5ydW5fYW5kX3Rocm93X2lmX2ZhaWwoW3BvcnQuc2NyaXB0X3BhdGgoc2NyaXB0 X25hbWUpXSwgcXVpZXQpCiAKICAgICAjIEZJWE1FOiBUaGUgcG9ydCBzaG91bGQgbGl2ZSBvbiB0 aGUgdG9vbC4KICAgICBkZWYgcG9ydChzZWxmKToKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1Nj cmlwdHMvd2Via2l0cHkvdG9vbC9zdGVwcy9wb3N0ZGlmZi5weSBiL1dlYktpdFRvb2xzL1Njcmlw dHMvd2Via2l0cHkvdG9vbC9zdGVwcy9wb3N0ZGlmZi5weQppbmRleCA2YTNkZWU0Li44MGRhY2Nh IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvcG9z dGRpZmYucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBzL3Bv c3RkaWZmLnB5CkBAIC0yNiw4ICsyNiw2IEBACiAjIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBP VEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQogIyBPRiBUSElTIFNP RlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdF LgogCi1pbXBvcnQgU3RyaW5nSU8KLQogZnJvbSB3ZWJraXRweS50b29sLnN0ZXBzLmFic3RyYWN0 c3RlcCBpbXBvcnQgQWJzdHJhY3RTdGVwCiBmcm9tIHdlYmtpdHB5LnRvb2wuc3RlcHMub3B0aW9u cyBpbXBvcnQgT3B0aW9ucwogCkBAIC00NCw3ICs0Miw2IEBAIGNsYXNzIFBvc3REaWZmKEFic3Ry YWN0U3RlcCk6CiAKICAgICBkZWYgcnVuKHNlbGYsIHN0YXRlKToKICAgICAgICAgZGlmZiA9IHNl bGYuY2FjaGVkX2xvb2t1cChzdGF0ZSwgImRpZmYiKQotICAgICAgICBkaWZmX2ZpbGUgPSBTdHJp bmdJTy5TdHJpbmdJTyhkaWZmKSAjIGFkZF9wYXRjaF90b19idWcgZXhwZWN0cyBhIGZpbGUtbGlr ZSBvYmplY3QKICAgICAgICAgZGVzY3JpcHRpb24gPSBzZWxmLl9vcHRpb25zLmRlc2NyaXB0aW9u IG9yICJQYXRjaCIKICAgICAgICAgY29tbWVudF90ZXh0ID0gTm9uZQogICAgICAgICBjb2RlcmV2 aWV3X2lzc3VlID0gc3RhdGUuZ2V0KCJjb2RlcmV2aWV3X2lzc3VlIikKQEAgLTUyLDYgKzQ5LDYg QEAgY2xhc3MgUG9zdERpZmYoQWJzdHJhY3RTdGVwKToKICAgICAgICAgIyBidXQgaXQgbWFrZXMg ZG9pbmcgdGhlIHJpZXR2ZWxkIGludGVncmF0aW9uIGEgbG90IGVhc2llci4KICAgICAgICAgaWYg Y29kZXJldmlld19pc3N1ZToKICAgICAgICAgICAgIGRlc2NyaXB0aW9uICs9ICItJXMiICUgc3Rh dGVbImNvZGVyZXZpZXdfaXNzdWUiXQotICAgICAgICBzZWxmLl90b29sLmJ1Z3MuYWRkX3BhdGNo X3RvX2J1ZyhzdGF0ZVsiYnVnX2lkIl0sIGRpZmZfZmlsZSwgZGVzY3JpcHRpb24sIGNvbW1lbnRf dGV4dD1jb21tZW50X3RleHQsIG1hcmtfZm9yX3Jldmlldz1zZWxmLl9vcHRpb25zLnJldmlldywg bWFya19mb3JfY29tbWl0X3F1ZXVlPXNlbGYuX29wdGlvbnMucmVxdWVzdF9jb21taXQpCisgICAg ICAgIHNlbGYuX3Rvb2wuYnVncy5hZGRfcGF0Y2hfdG9fYnVnKHN0YXRlWyJidWdfaWQiXSwgZGlm ZiwgZGVzY3JpcHRpb24sIGNvbW1lbnRfdGV4dD1jb21tZW50X3RleHQsIG1hcmtfZm9yX3Jldmll dz1zZWxmLl9vcHRpb25zLnJldmlldywgbWFya19mb3JfY29tbWl0X3F1ZXVlPXNlbGYuX29wdGlv bnMucmVxdWVzdF9jb21taXQpCiAgICAgICAgIGlmIHNlbGYuX29wdGlvbnMub3Blbl9idWc6CiAg ICAgICAgICAgICBzZWxmLl90b29sLnVzZXIub3Blbl91cmwoc2VsZi5fdG9vbC5idWdzLmJ1Z191 cmxfZm9yX2J1Z19pZChzdGF0ZVsiYnVnX2lkIl0pKQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMv U2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBzL3Bvc3RkaWZmZm9yY29tbWl0LnB5IGIvV2ViS2l0 VG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBzL3Bvc3RkaWZmZm9yY29tbWl0LnB5Cmlu ZGV4IDAzYjllNzguLjEzYmMwMGMgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvdG9vbC9zdGVwcy9wb3N0ZGlmZmZvcmNvbW1pdC5weQorKysgYi9XZWJLaXRUb29scy9T Y3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvcG9zdGRpZmZmb3Jjb21taXQucHkKQEAgLTI2LDgg KzI2LDYgQEAKICMgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJ TiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCiAjIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURW SVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCiAKLWltcG9ydCBTdHJpbmdJ TwotCiBmcm9tIHdlYmtpdHB5LnRvb2wuc3RlcHMuYWJzdHJhY3RzdGVwIGltcG9ydCBBYnN0cmFj dFN0ZXAKIAogCkBAIC0zNSw3ICszMyw3IEBAIGNsYXNzIFBvc3REaWZmRm9yQ29tbWl0KEFic3Ry YWN0U3RlcCk6CiAgICAgZGVmIHJ1bihzZWxmLCBzdGF0ZSk6CiAgICAgICAgIHNlbGYuX3Rvb2wu YnVncy5hZGRfcGF0Y2hfdG9fYnVnKAogICAgICAgICAgICAgc3RhdGVbImJ1Z19pZCJdLAotICAg ICAgICAgICAgU3RyaW5nSU8uU3RyaW5nSU8oc2VsZi5jYWNoZWRfbG9va3VwKHN0YXRlLCAiZGlm ZiIpKSwKKyAgICAgICAgICAgIHNlbGYuY2FjaGVkX2xvb2t1cChzdGF0ZSwgImRpZmYiKSwKICAg ICAgICAgICAgICJQYXRjaCBmb3IgbGFuZGluZyIsCiAgICAgICAgICAgICBtYXJrX2Zvcl9yZXZp ZXc9RmFsc2UsCiAgICAgICAgICAgICBtYXJrX2Zvcl9sYW5kaW5nPVRydWUpCmRpZmYgLS1naXQg YS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvcG9zdGRpZmZmb3JyZXZl cnQucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvcG9zdGRpZmZm b3JyZXZlcnQucHkKaW5kZXggM2I5ZGEwNC4uYmZhNjMxZiAxMDA2NDQKLS0tIGEvV2ViS2l0VG9v bHMvU2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBzL3Bvc3RkaWZmZm9ycmV2ZXJ0LnB5CisrKyBi L1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9zdGVwcy9wb3N0ZGlmZmZvcnJldmVy dC5weQpAQCAtMjYsOCArMjYsNiBAQAogIyAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJX SVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKICMgT0YgVEhJUyBTT0ZUV0FS RSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KIAot aW1wb3J0IFN0cmluZ0lPCi0KIGZyb20gd2Via2l0cHkuY29tbW9uLm5ldC5idWd6aWxsYSBpbXBv cnQgQXR0YWNobWVudAogZnJvbSB3ZWJraXRweS50b29sLnN0ZXBzLmFic3RyYWN0c3RlcCBpbXBv cnQgQWJzdHJhY3RTdGVwCiAKQEAgLTQ0LDcgKzQyLDcgQEAgZm9sbG93aW5nIGNvbW1hbmQ6XG5c blwKIHdoZXJlIEFUVEFDSE1FTlRfSUQgaXMgdGhlIElEIG9mIHRoaXMgYXR0YWNobWVudC4iCiAg ICAgICAgIHNlbGYuX3Rvb2wuYnVncy5hZGRfcGF0Y2hfdG9fYnVnKAogICAgICAgICAgICAgc3Rh dGVbImJ1Z19pZCJdLAotICAgICAgICAgICAgU3RyaW5nSU8uU3RyaW5nSU8oc2VsZi5jYWNoZWRf bG9va3VwKHN0YXRlLCAiZGlmZiIpKSwKKyAgICAgICAgICAgIHNlbGYuY2FjaGVkX2xvb2t1cChz dGF0ZSwgImRpZmYiKSwKICAgICAgICAgICAgICIlcyVzIiAlIChBdHRhY2htZW50LnJvbGxvdXRf cHJlYW1ibGUsIHN0YXRlWyJyZXZpc2lvbiJdKSwKICAgICAgICAgICAgIGNvbW1lbnRfdGV4dD1j b21tZW50X3RleHQsCiAgICAgICAgICAgICBtYXJrX2Zvcl9yZXZpZXc9RmFsc2UsCmRpZmYgLS1n aXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvc3RlcHNfdW5pdHRl c3QucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvc3RlcHNfdW5p dHRlc3QucHkKaW5kZXggNDBiZWU5MC4uNWFiZmM2ZCAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMv U2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBzL3N0ZXBzX3VuaXR0ZXN0LnB5CisrKyBiL1dlYktp dFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9zdGVwcy9zdGVwc191bml0dGVzdC5weQpAQCAt NDgsNyArNDgsOCBAQCBjbGFzcyBTdGVwc1Rlc3QodW5pdHRlc3QuVGVzdENhc2UpOgogICAgIGRl ZiB0ZXN0X3VwZGF0ZV9zdGVwKHNlbGYpOgogICAgICAgICBvcHRpb25zID0gTW9jaygpCiAgICAg ICAgIG9wdGlvbnMudXBkYXRlID0gVHJ1ZQotICAgICAgICBzZWxmLl9ydW5fc3RlcChVcGRhdGUs IG9wdGlvbnMpCisgICAgICAgIGV4cGVjdGVkX3N0ZGVyciA9ICJVcGRhdGluZyB3b3JraW5nIGRp cmVjdG9yeVxuIgorICAgICAgICBPdXRwdXRDYXB0dXJlKCkuYXNzZXJ0X291dHB1dHMoc2VsZiwg c2VsZi5fcnVuX3N0ZXAsIFtVcGRhdGUsIG9wdGlvbnNdLCBleHBlY3RlZF9zdGRlcnI9ZXhwZWN0 ZWRfc3RkZXJyKQogCiAgICAgZGVmIHRlc3RfcHJvbXB0X2Zvcl9idWdfb3JfdGl0bGVfc3RlcChz ZWxmKToKICAgICAgICAgdG9vbCA9IE1vY2tUb29sKCkK 53998 2010-04-21 15:47:27 -0700 2010-04-21 20:10:21 -0700 Fix Chromium Canaries bug-37765-20100421154722.patch text/plain 3755 eric ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxv ZwppbmRleCAwYmI1NDM3Li5lYzI5NThjIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9DaGFuZ2VM b2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDUgKzEsMTUgQEAKIDIwMTAtMDQt MjEgIEVyaWMgU2VpZGVsICA8ZXJpY0B3ZWJraXQub3JnPgogCisgICAgICAgIFJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFJFR1JFU1NJT04oNTc1MzEpOiB0aGUgY29tbWl0 LXF1ZXVlIHN0aWxsIGhhdGVzIFRvciBBcm5lIFZlc3Riw7gKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM3NzY1CisKKyAgICAgICAgKiBTY3JpcHRzL3dl YmtpdHB5L2xheW91dF90ZXN0cy90ZXN0X3R5cGVzL3Rlc3RfdHlwZV9iYXNlLnB5OgorICAgICAg ICAgLSBQYXNzIGFuZCBlbmNvZGluZyB0byBfd3JpdGVfaW50b19maWxlX2F0X3BhdGgKKworMjAx MC0wNC0yMSAgRXJpYyBTZWlkZWwgIDxlcmljQHdlYmtpdC5vcmc+CisKICAgICAgICAgUmV2aWV3 ZWQgYnkgQWRhbSBCYXJ0aC4KIAogICAgICAgICBSRUdSRVNTSU9OKDU3NTMxKTogdGhlIGNvbW1p dC1xdWV1ZSBzdGlsbCBoYXRlcyBUb3IgQXJuZSBWZXN0YsO4CmRpZmYgLS1naXQgYS9XZWJLaXRU b29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy90ZXN0X3R5cGVzL3Rlc3RfdHlwZV9i YXNlLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvdGVzdF90 eXBlcy90ZXN0X3R5cGVfYmFzZS5weQppbmRleCBjM2U2MmEwLi40OGQ0NTQ2IDEwMDY0NAotLS0g YS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy90ZXN0X3R5cGVzL3Rl c3RfdHlwZV9iYXNlLnB5CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0 X3Rlc3RzL3Rlc3RfdHlwZXMvdGVzdF90eXBlX2Jhc2UucHkKQEAgLTE1MywxMSArMTUzLDEwIEBA IGNsYXNzIFRlc3RUeXBlQmFzZShvYmplY3QpOgogICAgICAgICAiIiIKICAgICAgICAgcmFpc2Ug Tm90SW1wbGVtZW50ZWQKIAotICAgIGRlZiBfd3JpdGVfaW50b19maWxlX2F0X3BhdGgoc2VsZiwg ZmlsZV9wYXRoLCBieXRlX2FycmF5KToKLSAgICAgICAgIiIiVGhpcyBtZXRob2QgYXNzdW1lcyB0 aGF0IGJ5dGVfYXJyYXkgaXMgYWxyZWFkeSBlbmNvZGVkCi0gICAgICAgIGludG8gdGhlIHJpZ2h0 IGZvcm1hdC4iIiIKLSAgICAgICAgd2l0aCBvcGVuKGZpbGVfcGF0aCwgIndiIikgYXMgZmlsZToK LSAgICAgICAgICAgIGZpbGUud3JpdGUoYnl0ZV9hcnJheSkKKyAgICBkZWYgX3dyaXRlX2ludG9f ZmlsZV9hdF9wYXRoKHNlbGYsIGZpbGVfcGF0aCwgY29udGVudHMsIGVuY29kaW5nPU5vbmUpOgor ICAgICAgICAiIiJXcml0ZXMgY29udGVudHMgYXQgZmlsZV9wYXRoLCB1c2luZyBlbmNvZGluZy4i IiIKKyAgICAgICAgd2l0aCBjb2RlY3Mub3BlbihmaWxlX3BhdGgsICJ3IiwgZW5jb2RpbmcpIGFz IGZpbGU6CisgICAgICAgICAgICBmaWxlLndyaXRlKGNvbnRlbnRzKQogCiAgICAgZGVmIHdyaXRl X291dHB1dF9maWxlcyhzZWxmLCBwb3J0LCBmaWxlbmFtZSwgZmlsZV90eXBlLAogICAgICAgICAg ICAgICAgICAgICAgICAgICAgb3V0cHV0LCBleHBlY3RlZCwgcHJpbnRfdGV4dF9kaWZmcz1GYWxz ZSk6CkBAIC0xNzksMTAgKzE3OCwxMyBAQCBjbGFzcyBUZXN0VHlwZUJhc2Uob2JqZWN0KToKICAg ICAgICAgc2VsZi5fbWFrZV9vdXRwdXRfZGlyZWN0b3J5KGZpbGVuYW1lKQogICAgICAgICBhY3R1 YWxfZmlsZW5hbWUgPSBzZWxmLm91dHB1dF9maWxlbmFtZShmaWxlbmFtZSwgc2VsZi5GSUxFTkFN RV9TVUZGSVhfQUNUVUFMICsgZmlsZV90eXBlKQogICAgICAgICBleHBlY3RlZF9maWxlbmFtZSA9 IHNlbGYub3V0cHV0X2ZpbGVuYW1lKGZpbGVuYW1lLCBzZWxmLkZJTEVOQU1FX1NVRkZJWF9FWFBF Q1RFRCArIGZpbGVfdHlwZSkKKyAgICAgICAgIyBGSVhNRTogVGhlIGZhY3QgdGhhdCB0aGlzIGZ1 bmN0aW9uIGNhbiB0YWtlIG1hbnkgZGlmZmVyZW50CisgICAgICAgICMgdHlwZXMgb2YgZGF0YSBp cyBhIHRvdGFsIGhhY2suCisgICAgICAgIGVuY29kaW5nID0gInV0Zi04IiBpZiBwcmludF90ZXh0 X2RpZmZzIGVsc2UgTm9uZQogICAgICAgICBpZiBvdXRwdXQ6Ci0gICAgICAgICAgICBzZWxmLl93 cml0ZV9pbnRvX2ZpbGVfYXRfcGF0aChhY3R1YWxfZmlsZW5hbWUsIG91dHB1dCkKKyAgICAgICAg ICAgIHNlbGYuX3dyaXRlX2ludG9fZmlsZV9hdF9wYXRoKGFjdHVhbF9maWxlbmFtZSwgb3V0cHV0 LCBlbmNvZGluZykKICAgICAgICAgaWYgZXhwZWN0ZWQ6Ci0gICAgICAgICAgICBzZWxmLl93cml0 ZV9pbnRvX2ZpbGVfYXRfcGF0aChleHBlY3RlZF9maWxlbmFtZSwgZXhwZWN0ZWQpCisgICAgICAg ICAgICBzZWxmLl93cml0ZV9pbnRvX2ZpbGVfYXRfcGF0aChleHBlY3RlZF9maWxlbmFtZSwgZXhw ZWN0ZWQsIGVuY29kaW5nKQogCiAgICAgICAgIGlmIG5vdCBvdXRwdXQgb3Igbm90IGV4cGVjdGVk OgogICAgICAgICAgICAgcmV0dXJuCkBAIC0xOTIsMTQgKzE5NCwxNCBAQCBjbGFzcyBUZXN0VHlw ZUJhc2Uob2JqZWN0KToKIAogICAgICAgICBkaWZmID0gcG9ydC5kaWZmX3RleHQoZXhwZWN0ZWQs IG91dHB1dCwgZXhwZWN0ZWRfZmlsZW5hbWUsIGFjdHVhbF9maWxlbmFtZSkKICAgICAgICAgZGlm Zl9maWxlbmFtZSA9IHNlbGYub3V0cHV0X2ZpbGVuYW1lKGZpbGVuYW1lLCBzZWxmLkZJTEVOQU1F X1NVRkZJWF9ESUZGICsgZmlsZV90eXBlKQotICAgICAgICBzZWxmLl93cml0ZV9pbnRvX2ZpbGVf YXRfcGF0aChkaWZmX2ZpbGVuYW1lLCBkaWZmLmVuY29kZSgidXRmLTgiKSkKKyAgICAgICAgc2Vs Zi5fd3JpdGVfaW50b19maWxlX2F0X3BhdGgoZGlmZl9maWxlbmFtZSwgZGlmZiwgZW5jb2Rpbmc9 InV0Zi04IikKIAogICAgICAgICAjIFNoZWxsIG91dCB0byB3ZGlmZiB0byBnZXQgY29sb3JlZCBp bmxpbmUgZGlmZnMuCiAgICAgICAgIHdkaWZmID0gcG9ydC53ZGlmZl90ZXh0KGV4cGVjdGVkX2Zp bGVuYW1lLCBhY3R1YWxfZmlsZW5hbWUpCiAgICAgICAgIHdkaWZmX2ZpbGVuYW1lID0gc2VsZi5v dXRwdXRfZmlsZW5hbWUoZmlsZW5hbWUsIHNlbGYuRklMRU5BTUVfU1VGRklYX1dESUZGKQotICAg ICAgICBzZWxmLl93cml0ZV9pbnRvX2ZpbGVfYXRfcGF0aCh3ZGlmZl9maWxlbmFtZSwgd2RpZmYu ZW5jb2RlKCJ1dGYtOCIpKQorICAgICAgICBzZWxmLl93cml0ZV9pbnRvX2ZpbGVfYXRfcGF0aCh3 ZGlmZl9maWxlbmFtZSwgd2RpZmYsIGVuY29kaW5nPSJ1dGYtOCIpCiAKICAgICAgICAgIyBVc2Ug V2ViS2l0J3MgUHJldHR5UGF0Y2gucmIgdG8gZ2V0IGFuIEhUTUwgZGlmZi4KICAgICAgICAgcHJl dHR5X3BhdGNoID0gcG9ydC5wcmV0dHlfcGF0Y2hfdGV4dChkaWZmX2ZpbGVuYW1lKQogICAgICAg ICBwcmV0dHlfcGF0Y2hfZmlsZW5hbWUgPSBzZWxmLm91dHB1dF9maWxlbmFtZShmaWxlbmFtZSwg c2VsZi5GSUxFTkFNRV9TVUZGSVhfUFJFVFRZX1BBVENIKQotICAgICAgICBzZWxmLl93cml0ZV9p bnRvX2ZpbGVfYXRfcGF0aChwcmV0dHlfcGF0Y2hfZmlsZW5hbWUsIHByZXR0eV9wYXRjaC5lbmNv ZGUoInV0Zi04IikpCisgICAgICAgIHNlbGYuX3dyaXRlX2ludG9fZmlsZV9hdF9wYXRoKHByZXR0 eV9wYXRjaF9maWxlbmFtZSwgcHJldHR5X3BhdGNoLCBlbmNvZGluZz0idXRmLTgiKQo= 54018 2010-04-21 20:10:29 -0700 2010-04-21 20:40:42 -0700 Fix for run-webkit-tests --chromium bug-37765-20100421201027.patch text/plain 2050 eric ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxv ZwppbmRleCAxM2JlYWM5Li4yNTJiNGFiIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9DaGFuZ2VM b2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDUgKzEsMTYgQEAKIDIwMTAtMDQt MjEgIEVyaWMgU2VpZGVsICA8ZXJpY0B3ZWJraXQub3JnPgogCisgICAgICAgIFVucmV2aWV3ZWQs IGp1c3QgYWRkaW5nIG1pc3NpbmcgIjoiIGluIHB5dGhvbiBmaWxlLgorCisgICAgICAgIFJFR1JF U1NJT04oNTc1MzEpOiB0aGUgY29tbWl0LXF1ZXVlIHN0aWxsIGhhdGVzIFRvciBBcm5lIFZlc3Ri w7gKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM3NzY1 CisKKyAgICAgICAgbmV3LXJ1bi13ZWJraXQtdGVzdHMgLS1jaHJvbWl1bSB3YXMgYm9ya2VkLgor CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1bS5w eToKKworMjAxMC0wNC0yMSAgRXJpYyBTZWlkZWwgIDxlcmljQHdlYmtpdC5vcmc+CisKICAgICAg ICAgUmV2aWV3ZWQgYnkgQWRhbSBCYXJ0aC4KIAogICAgICAgICBSRUdSRVNTSU9OKDU3NTMxKTog dGhlIGNvbW1pdC1xdWV1ZSBzdGlsbCBoYXRlcyBUb3IgQXJuZSBWZXN0YsO4CmRpZmYgLS1naXQg YS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVt LnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJv bWl1bS5weQppbmRleCBiNmUzOTExLi44ODQyYWQ5IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9T Y3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtLnB5CisrKyBiL1dlYktp dFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hyb21pdW0ucHkKQEAg LTIwOSwxOCArMjA5LDE4IEBAIGNsYXNzIENocm9taXVtUG9ydChiYXNlLlBvcnQpOgogICAgICAg ICBCYXNpY2FsbHkgdGhpcyBzdHJpbmcgc2hvdWxkIGNvbnRhaW4gdGhlIGVxdWl2YWxlbnQgb2Yg YQogICAgICAgICB0ZXN0X2V4cGVjdGF0aW9ucyBmaWxlLiBTZWUgdGVzdF9leHBlY3RhdGlvbnMu cHkgZm9yIG1vcmUgZGV0YWlscy4iIiIKICAgICAgICAgZXhwZWN0YXRpb25zX3BhdGggPSBzZWxm LnBhdGhfdG9fdGVzdF9leHBlY3RhdGlvbnNfZmlsZSgpCi0gICAgICAgIHdpdGggY29kZWNzLm9w ZW4oZXhwZWN0YXRpb25zX2ZpbGUsICJyIiwgInV0Zi04IikgYXMgZmlsZToKKyAgICAgICAgd2l0 aCBjb2RlY3Mub3BlbihleHBlY3RhdGlvbnNfcGF0aCwgInIiLCAidXRmLTgiKSBhcyBmaWxlOgog ICAgICAgICAgICAgcmV0dXJuIGZpbGUucmVhZCgpCiAKICAgICBkZWYgdGVzdF9leHBlY3RhdGlv bnNfb3ZlcnJpZGVzKHNlbGYpOgogICAgICAgICB0cnk6Ci0gICAgICAgICAgICBvdmVycmlkZXNf ZmlsZSA9IHNlbGYucGF0aF9mcm9tX2Nocm9taXVtX2Jhc2UoJ3dlYmtpdCcsICd0b29scycsCisg ICAgICAgICAgICBvdmVycmlkZXNfcGF0aCA9IHNlbGYucGF0aF9mcm9tX2Nocm9taXVtX2Jhc2Uo J3dlYmtpdCcsICd0b29scycsCiAgICAgICAgICAgICAgICAgJ2xheW91dF90ZXN0cycsICd0ZXN0 X2V4cGVjdGF0aW9ucy50eHQnKQogICAgICAgICBleGNlcHQgQXNzZXJ0aW9uRXJyb3I6CiAgICAg ICAgICAgICByZXR1cm4gTm9uZQotICAgICAgICBpZiBub3Qgb3MucGF0aC5leGlzdHMob3ZlcnJp ZGVzX2ZpbGUpOgorICAgICAgICBpZiBub3Qgb3MucGF0aC5leGlzdHMob3ZlcnJpZGVzX3BhdGgp OgogICAgICAgICAgICAgcmV0dXJuIE5vbmUKLSAgICAgICAgd2l0aCBjb2RlY3Mub3BlbihvdmVy cmlkZXNfZmlsZSwgInIiLCAidXRmLTgiKSBhcyBmaWxlCisgICAgICAgIHdpdGggY29kZWNzLm9w ZW4ob3ZlcnJpZGVzX3BhdGgsICJyIiwgInV0Zi04IikgYXMgZmlsZToKICAgICAgICAgICAgIHJl dHVybiBmaWxlLnJlYWQoKQogCiAgICAgZGVmIHRlc3RfcGxhdGZvcm1fbmFtZXMoc2VsZik6Cg== 54019 2010-04-21 20:40:51 -0700 2010-04-21 20:40:51 -0700 Patch bug-37765-20100421204050.patch text/plain 1488 eric ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxv ZwppbmRleCAyNTJiNGFiLi41M2Q5MGQ1IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9DaGFuZ2VM b2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDUgKzEsMTQgQEAKIDIwMTAtMDQt MjEgIEVyaWMgU2VpZGVsICA8ZXJpY0B3ZWJraXQub3JnPgogCisgICAgICAgIFVucmV2aWV3ZWQs IGFkZCBiYWNrIGNoZWNrIHRvIGZpeCBkdW1waW5nIG9mIGV4cGVjdGVkIHJlc3VsdHMgd2l0aCB1 bmljb2RlLgorCisgICAgICAgIFJFR1JFU1NJT04oNTc1MzEpOiB0aGUgY29tbWl0LXF1ZXVlIHN0 aWxsIGhhdGVzIFRvciBBcm5lIFZlc3Riw7gKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTM3NzY1CisKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xh eW91dF90ZXN0cy90ZXN0X3R5cGVzL3Rlc3RfdHlwZV9iYXNlLnB5OgorCisyMDEwLTA0LTIxICBF cmljIFNlaWRlbCAgPGVyaWNAd2Via2l0Lm9yZz4KKwogICAgICAgICBVbnJldmlld2VkLCBqdXN0 IGFkZGluZyBtaXNzaW5nICI6IiBpbiBweXRob24gZmlsZS4KIAogICAgICAgICBSRUdSRVNTSU9O KDU3NTMxKTogdGhlIGNvbW1pdC1xdWV1ZSBzdGlsbCBoYXRlcyBUb3IgQXJuZSBWZXN0YsO4CmRp ZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy90ZXN0 X3R5cGVzL3Rlc3RfdHlwZV9iYXNlLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9s YXlvdXRfdGVzdHMvdGVzdF90eXBlcy90ZXN0X3R5cGVfYmFzZS5weQppbmRleCBjM2U2MmEwLi5m YzdmM2VmIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90 ZXN0cy90ZXN0X3R5cGVzL3Rlc3RfdHlwZV9iYXNlLnB5CisrKyBiL1dlYktpdFRvb2xzL1Njcmlw dHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3Rlc3RfdHlwZXMvdGVzdF90eXBlX2Jhc2UucHkKQEAg LTE3OSw2ICsxNzksNyBAQCBjbGFzcyBUZXN0VHlwZUJhc2Uob2JqZWN0KToKICAgICAgICAgc2Vs Zi5fbWFrZV9vdXRwdXRfZGlyZWN0b3J5KGZpbGVuYW1lKQogICAgICAgICBhY3R1YWxfZmlsZW5h bWUgPSBzZWxmLm91dHB1dF9maWxlbmFtZShmaWxlbmFtZSwgc2VsZi5GSUxFTkFNRV9TVUZGSVhf QUNUVUFMICsgZmlsZV90eXBlKQogICAgICAgICBleHBlY3RlZF9maWxlbmFtZSA9IHNlbGYub3V0 cHV0X2ZpbGVuYW1lKGZpbGVuYW1lLCBzZWxmLkZJTEVOQU1FX1NVRkZJWF9FWFBFQ1RFRCArIGZp bGVfdHlwZSkKKyAgICAgICAgZW5jb2RpbmcgPSAidXRmLTgiIGlmIHByaW50X3RleHRfZGlmZnMg ZWxzZSBOb25lCiAgICAgICAgIGlmIG91dHB1dDoKICAgICAgICAgICAgIHNlbGYuX3dyaXRlX2lu dG9fZmlsZV9hdF9wYXRoKGFjdHVhbF9maWxlbmFtZSwgb3V0cHV0KQogICAgICAgICBpZiBleHBl Y3RlZDoK