149496 2015-09-23 02:12:23 -0700 [GTK][WPE] Use mobile user-agent on tablet 2020-10-23 06:07:11 -0700 1 1 1 Unclassified WebKit WebKitGTK Other Unspecified Unspecified RESOLVED FIXED https://bugzilla.gnome.org/show_bug.cgi?id=754089 https://bugs.webkit.org/show_bug.cgi?id=218122 P2 Normal --- 1 bugzilla webkit-unassigned annulen aperez benjamin bugs-noreply cdumez cgarcia cmarcelo ews-watchlist gyuyoung.kim jan.brummer mcatanzaro pgriffis ryuan.choi sergio oldest_to_newest 1128255 0 bugzilla 2015-09-23 02:12:23 -0700 From https://bugzilla.gnome.org/show_bug.cgi?id=754089 $ gdbus introspect --system --dest org.freedesktop.hostname1 --object-path /org/freedesktop/hostname1 | grep 'Chassis ' readonly s Chassis = 'laptop'; Using that data, we should switch to using a mobile user-agent when "tablet" is detected ("handset" could also switch to that). 1667093 1 mcatanzaro 2020-06-29 07:57:49 -0700 We stared discussing this in https://gitlab.gnome.org/GNOME/epiphany/-/merge_requests/601#note_853104 Let's have WebKit perform this chassis check. UserAgentGLib.cpp under Source/WebCore/platform/glib would be the best place. Let's also add a ChassisType parameter to UserAgentQuirks::quirksForURL in UserAgentQuirks.[cpp,h] so we can disable quirks that are not appropriate for mobile: ``` // At least finance.yahoo.com displays a mobile version with WebKitGTK's standard user agent. if (baseDomain == "yahoo.com") return true; // taobao.com displays a mobile version with WebKitGTK's standard user agent. if (baseDomain == "taobao.com") return true; ``` 1667218 2 403095 jan.brummer 2020-06-29 12:17:03 -0700 Created attachment 403095 Patch 1667221 3 jan.brummer 2020-06-29 12:18:49 -0700 This is a almost working solution with debug statements. For urls without a quirk everything works fine, but as soon as a quirk is needed ChassisType is Unknown. Don't know why. Therefore please review my current attempt and obviously i did something wrong in this area... Thanks. 1667239 4 403095 mcatanzaro 2020-06-29 13:14:10 -0700 Comment on attachment 403095 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=403095&action=review Guess: since standardUserAgentForURL() is called in the web process, it is not going to have D-Bus access to hostnamed. Drat. I bet if you use WEBKIT_FORCE_SANDBOX=0 then this would work? Please check. I think if you add a call to getpid() to your debug statements, the problem would become a bit clearer... although beware, because the web process runs inside a pid namespace. So um, this is actually a much trickier problem than I expected it to be. I'm not actually sure what to do. We could pass the information from the UI process to the web process via IPC, but that doesn't work if we're running in flatpak because the UI process won't have permission to talk to hostnamed either. There might not be any way around this without hardcoding --talk-name=org.freedesktop.hostname1 in every application's flatpak manifest, and surely we don't want to add code that relies on that. So I know this isn't what you want to hear, but I think we need to talk to Patrick (TingPing) and the other xdg-desktop-portal developers about what a chassis portal would look like. At least, I don't see a good way to do this properly without constructing a new portal. We should try to get more opinions. > Source/WebCore/platform/UserAgentQuirks.cpp:155 > + bool ret = isGoogle(url) && (chassisType != UserAgentQuirks::ChassisTypeMobile); I know this line is just here for debugging, but WebKit style avoids the unnecessary parentheses around chassisType != UserAgentQuirks::ChassisTypeMobile > Source/WebCore/platform/UserAgentQuirks.h:47 > + enum ChassisType { > + ChassisTypeUnknown, > + ChassisTypeDesktop, > + ChassisTypeMobile > + }; This doesn't belong in UserAgentQuirks because the ChassisType is also used in UserAgentGLib.cpp. I would declare it in Source/WebCore/platform/UserAgent.h inside the #else block for !PLATFORM(COCOA). Whereas UserAgentQuirk is a plain enum because it's used as a C-style flags variable, ChassisType should be a C++ scoped enum, like this: enum class ChassisType { Unknown, Desktop, Mobile }; Then instead of writing e.g. ChassisTypeUnknown, you would write ChassisType::Unknown. > Source/WebCore/platform/glib/UserAgentGLib.cpp:55 > + if (chassisType == UserAgentQuirks::ChassisTypeUnknown) { So problem here is that if chassis type is unknown (e.g. because hostnamed is not running), then we run all the code again and again every time. Better use a static bool variable that is always set after the first run to ensure this function is really only ever executed exactly once. > Source/WebCore/platform/glib/UserAgentGLib.cpp:59 > + g_autoptr(GError) error = NULL; > + g_autoptr(GDBusConnection) connection = NULL; > + g_autoptr(GVariant) var = NULL; > + g_autoptr(GVariant) v = NULL; We don't use autoptrs in WebKit because this is C++, so we have real smart pointers instead. Much safer: GUniqueOutPtr<GError> error; GRefPtr<GDBusConnection> connection; GRefPtr<GVariant> var; // of course you'll pick better names for var and v GRefPtr<GVariant> v; // (perhaps variant and childVariant?) But we also don't declare variables before first use, so all of these get declared below, not at the top of the function. Also: NULL -> nullptr > Source/WebCore/platform/glib/UserAgentGLib.cpp:62 > + connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error); BTW, you asked on IRC how we could avoid doing sync I/O in this awkward place, and I said I don't think it's easily avoidable. This is unfortunate, but without changing the user agent APIs to be async, there's not really anything we can do about it. And we definitely don't want to change the user agent APIs to be async. If other reviewers have any better ideas, I'd love to hear them, but this seems to me like the best we can do. BTW, to convert to GUniqueOutPtr, you would write: GUniqueOutPtr<GError> error; g_bus_get_sync(G_BUS_TYPE_SYSTEM, nullptr, &error.outPtr()); (Note again NULL -> nullptr.) > Source/WebCore/platform/glib/UserAgentGLib.cpp:65 > + g_debug("Could not connect to system bus: %s", error->message); > + WTFLogAlways("%s(): EXIT 1 %s\n", __FUNCTION__, error->message); For the final version of the patch, you would change the g_debug() to g_warning(). (And delete the WTFLogAlways, but I known that's just there for debugging.) > Source/WebCore/platform/glib/UserAgentGLib.cpp:69 > + var = g_dbus_connection_call_sync(connection, To use smart pointers, you would write: var = adoptGRef(g_dbus_connection_call_sync(connection.get(), adoptGRef() adopts the initial reference (otherwise the refcount would be increased to 2 here and we'd get a leak) and .get() returns the GDBusConnection* owned by the GRefPtr<GDBusConnection>. > Source/WebCore/platform/glib/UserAgentGLib.cpp:70 > + var = g_dbus_connection_call_sync(connection, > + "org.freedesktop.hostname1", For indentation, we indent four spaces relative to the start of the previous line. So: GRefPtr<GVariant> var = adoptGRef(g_dbus_connection_call_sync(connection.get(), "org.freedesktop.hostname1", > Source/WebCore/platform/glib/UserAgentGLib.cpp:83 > + g_debug("Could not access chassis property: %s", error->message); Here I don't think we need to print anything at all, since apparently not all the world uses systemd and it's just expected that it might not be present. We don't use g_debug() in WebKit and I don't see any particular reason to log here. Returning ChassisType::Unknown will be fine. > Source/WebCore/platform/glib/UserAgentGLib.cpp:87 > + g_variant_get(var, "(v)", &v); I guess you cannot use g_variant_get_variant() here, because the type is G_VARIANT_TYPE_TUPLE rather than G_VARIANT_TYPE_VARIANT? You can do: GRefPtr<GVariant> v; g_variant_get(var.get(), "(v)", &v.outPtr()); I suggest renaming var to variant (no abbreviations!) and v to childVariant, or something like that. > Source/WebCore/platform/glib/UserAgentGLib.cpp:88 > + chassis = g_variant_get_string(v, NULL); GUniquePtr<char> chassis(g_variant_get_string(v, nullptr)); > Source/WebCore/platform/glib/UserAgentGLib.cpp:91 > + /* convertible is just for testing at the moment */ // Convertible is just for testing at the moment. C++ // comment, full sentence with sentence case capitalization and a period at the end. > Source/WebCore/platform/glib/UserAgentGLib.cpp:110 > + Nit: it looks better without this blank line here. > Source/WebCore/platform/glib/UserAgentGLib.cpp:123 > struct utsname name; > uname(&name); > static NeverDestroyed<const String> uaOSVersion(makeString(name.sysname, ' ', name.machine)); > + > + if (getChassisType() == UserAgentQuirks::ChassisTypeMobile) > + return "like Android 4.4"; Check the chassis type first, before you call uname(). Avoid wasted work. 1667243 5 mcatanzaro 2020-06-29 13:21:14 -0700 (In reply to Michael Catanzaro from comment #4) > So I know this isn't what you want to hear, but I think we need to talk to > Patrick (TingPing) and the other xdg-desktop-portal developers about what a > chassis portal would look like. At least, I don't see a good way to do this > properly without constructing a new portal. We should try to get more > opinions. Might even want to add a chassis type function to GTK 4, that way we wouldn't need to add a portal that wouldn't be used by GTK. 1667276 6 jan.brummer 2020-06-29 14:25:35 -0700 > Guess: since standardUserAgentForURL() is called in the web process, it is > not going to have D-Bus access to hostnamed. Drat. I bet if you use > WEBKIT_FORCE_SANDBOX=0 then this would work? Please check. I think if you > add a call to getpid() to your debug statements, the problem would become a > bit clearer... although beware, because the web process runs inside a pid > namespace. Short update: WEBKIT_FORCE_SANDBOX=0 works fine. 1667481 7 403176 jan.brummer 2020-06-29 23:35:53 -0700 Created attachment 403176 Patch 1667482 8 jan.brummer 2020-06-29 23:38:59 -0700 Thanks for the detailed review Michael, i really appreciate it. I've integrated those findings in my updated patch. It's a good starting point to get in contact with TingPing now. The impact of this patch is massive for the mobile experience as for supported pages the download size is much lower and thus improves rendering speed. 1667485 9 403177 jan.brummer 2020-06-29 23:49:46 -0700 Created attachment 403177 Patch 1667486 10 jan.brummer 2020-06-29 23:50:21 -0700 Removed some blank lines... 1667521 11 jan.brummer 2020-06-30 02:46:52 -0700 Another working option is to parse: /sys/devices/virtual/dmi/id/chassis_type and /etc/machine-info manually. 1667574 12 403199 jan.brummer 2020-06-30 07:58:09 -0700 Created attachment 403199 Patch 1667576 13 jan.brummer 2020-06-30 08:02:36 -0700 I have uploaded a patch which only makes use of /etc/machine-info as DMI is not present on all systems. Please note that the default is always ChassisType::Desktop to ensure that everything stays the same for all other systems. Only once tablet or handset is detected it is switched to ChassisType::Mobile and the user agent is modified. In order to test it you can easily switch your chassis type. Not sure this is an accepted solution, but it is working fine for me. Flatpak does not mirror this file at the moment, so in both cases (file/portal) flatpak needs to be updated. 1667596 14 403199 mcatanzaro 2020-06-30 09:13:05 -0700 Comment on attachment 403199 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=403199&action=review > Source/WebCore/platform/UserAgent.h:46 > +}; > WEBCORE_EXPORT String standardUserAgent(const String& applicationName = emptyString(), const String& applicationVersion = emptyString()); Blank line here > Source/WebCore/platform/UserAgentQuirks.cpp:155 > + return isGoogle(url) && chassisType == ChassisType::Desktop; Let's use && chassisType != ChassisType::Mobile here, since we know affected websites are likely to be broken without the user agent quirk.... > Source/WebCore/platform/glib/UserAgentGLib.cpp:50 > +static ChassisType getChassisType() I think we should follow hostnamed as closely as possible here: https://github.com/systemd/systemd/blob/d7f4ad203acb07e728865d5ea117f7df5e8d8166/src/hostname/hostnamed.c#L186 First it reads /etc/machine-info to get the chassis type. That's going to fail by default. I don't have anything set in my /etc/machine-info other than PRETTY_HOSTNAME. So if you're relying only on this, I think you're going to be pretty disappointed with the results. After /etc/machine-info, it next tries /sys/class/dmi/id/chassis_type, then finally it tries "/sys/firmware/acpi/pm_profile" if not available. I see that /etc is mounted by BubblewrapLauncher.cpp, but not by flatpak. (Surprise! Wasn't expecting that to be different.) /sys/class is allowed by both BubblewrapLauncher and flatpak, so no changes needed there. /sys/firmware is not allowed by either (and I have no idea if that would be safe). We are going to change something in flatpak no matter what, either to expose a filtered version of hostnamed, or to expose /etc/machine-info. And we need to decide how to change flatpak before we change WebKit. > Source/WebCore/platform/glib/UserAgentGLib.cpp:56 > + std::ifstream infoFile("/etc/machine-info"); std::ifstream can throw exceptions, so we can't use it in WebKit. Use either GLib or POSIX APIs instead. 1668667 15 403492 jan.brummer 2020-07-03 14:44:47 -0700 Created attachment 403492 Patch 1668671 16 jan.brummer 2020-07-03 14:47:32 -0700 We (Michael & Patrick) agreed on using the hostnamed logic without webkit. Updated patch accordingly and integrated review comments. 1668692 17 403492 mcatanzaro 2020-07-03 16:30:14 -0700 Comment on attachment 403492 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=403492&action=review OK, this is looking better, but it's still written too much like C code rather than C++, so I will try to show you how to fix that. Will you also open a flatpak pull request to expose /etc/machine-info? > Source/WebCore/platform/glib/UserAgentGLib.cpp:49 > +static ChassisType readMachineInfo(void) static ChassisType readMachineInfo() The void is implicit in C++. > Source/WebCore/platform/glib/UserAgentGLib.cpp:51 > + ChassisType type = ChassisType::Unknown; You don't need to declare this (see below). > Source/WebCore/platform/glib/UserAgentGLib.cpp:52 > + GUniqueOutPtr<GError> error; You actually don't need this after all (see below). > Source/WebCore/platform/glib/UserAgentGLib.cpp:53 > + char* buffer; GUniqueOutPtr<char> buffer; > Source/WebCore/platform/glib/UserAgentGLib.cpp:54 > + if (!g_file_get_contents("/etc/machine-info", &buffer, NULL, &error.outPtr())) { (..., &buffer.outPtr(), nullptr, ...) > Source/WebCore/platform/glib/UserAgentGLib.cpp:55 > + g_debug("Could not open /etc/machine-info: %s\n", error->message); We don't use g_debug() in WebKit. It's expected the file might not exist, so instead you can pass nullptr for the error and just return here without printing anything. > Source/WebCore/platform/glib/UserAgentGLib.cpp:59 > + GStrv split = g_strsplit(buffer, "\n", -1); GStrv is only for use with g_autofree, where you can't write gchar**. In C++, you ought to ensure the ownership is held in a smart pointer class; this is expected in WebKit. Use GUniquePtr: GUniquePtr<char*> split(g_strsplit(...)); That will help avoid accidental memory leaks, including the one you have here, because you forgot to free it. ;) > Source/WebCore/platform/glib/UserAgentGLib.cpp:62 > + for (guint i = 0; i < g_strv_length(split); i++) { Don't use guint in WebKit (except for public APIs). You're calling g_strv_length() once per iteration of the loop, that means you're traversing the entire length of the array to get the length every loop, even though it doesn't change. You could calculate the length outside the loop instead, but in this case you don't actually need it: for (int i = 0; split[i]; i++) > Source/WebCore/platform/glib/UserAgentGLib.cpp:66 > + if (!g_strcmp0(chassis, "tablet") || !g_strcmp0(chassis, "handset")) Use normal strcmp() here, because chassis can never be nullptr. > Source/WebCore/platform/glib/UserAgentGLib.cpp:67 > + type = ChassisType::Mobile; return ChassisType::Mobile; > Source/WebCore/platform/glib/UserAgentGLib.cpp:69 > + type = ChassisType::Desktop; return ChassisType::Desktop; > Source/WebCore/platform/glib/UserAgentGLib.cpp:75 > + return type; return ChassisType::Unknown; > Source/WebCore/platform/glib/UserAgentGLib.cpp:78 > +static ChassisType readFallbackChassis(void) static ChassisType readFallbackChassis() I would split this into two functions: readDMIChassisType() and readACPIChassisType() > Source/WebCore/platform/glib/UserAgentGLib.cpp:82 > + GUniqueOutPtr<GError> error; > + char* buffer; > + int t; Remember what I said about not declaring things at the top of functions, only at first use. So here you really do need to declare error and buffer, but there should be no blank line between the declarations and where they are first used, because you want the declarations as close as possible to where they are used. (Except you don't need error after all, since you're just going to ignore the error.) And t should be declared below. Also: GUniquePtr<char> buffer; > Source/WebCore/platform/glib/UserAgentGLib.cpp:84 > + if (!g_file_get_contents("/sys/class/dmi/id/chassis_type", &buffer, NULL, &error.outPtr())) { nullptr > Source/WebCore/platform/glib/UserAgentGLib.cpp:85 > + g_debug("Could not open /sys/class/dmi/id/chassis_type: %s\n", error->message); Don't use g_debug(), just ignore the error. > Source/WebCore/platform/glib/UserAgentGLib.cpp:86 > + goto tryACPI; You don't need goto for this, just invert the condition and move the switch inside the conditional. We almost never use goto in C++ because it's not needed for manually freeing things in error paths. > Source/WebCore/platform/glib/UserAgentGLib.cpp:89 > + t = atoi(buffer); int t = atoi(buffer.get()); > Source/WebCore/platform/glib/UserAgentGLib.cpp:114 > + if (!g_file_get_contents("/sys/firmware/acpi/pm_profile", &buffer, NULL, &error.outPtr())) { if (!g_file_get_contents("/sys/firmware/acpi/pm_profile", &buffer.outPtr(), nullptr, nullptr)) > Source/WebCore/platform/glib/UserAgentGLib.cpp:115 > + g_debug("Could not open /sys/firmware/acpi/pm_profile: %s\n", error->message); And get rid of the g_debug > Source/WebCore/platform/glib/UserAgentGLib.cpp:119 > + t = atoi(buffer); t = atoi(buffer.get()) > Source/WebCore/platform/glib/UserAgentGLib.cpp:141 > + static ChassisType chassisType = ChassisType::Desktop; static ChassisType chassisType; There's no point in initializing it to a value that's guaranteed to be overwritten below (and static variables are zero-initialized anyway). > Source/WebCore/platform/glib/UserAgentGLib.cpp:171 > + return "like Android 4.4"; > struct utsname name; Nit: I'd add a blank line here. 1668762 18 403517 jan.brummer 2020-07-04 01:38:00 -0700 Created attachment 403517 Patch 1668763 19 jan.brummer 2020-07-04 01:41:04 -0700 (In reply to Michael Catanzaro from comment #17) > Comment on attachment 403492 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=403492&action=review > > OK, this is looking better, but it's still written too much like C code > rather than C++, so I will try to show you how to fix that. Thanks, yes a decade ago i used to write C++ and now it's C all the time. :) > Will you also open a flatpak pull request to expose /etc/machine-info? Sure, i promised it and will do it today. Patch is updated based on your comments and i've splitted the second function into two for better readability. 1668765 20 jan.brummer 2020-07-04 02:01:27 -0700 Flatpak pull request: https://github.com/flatpak/flatpak/pull/3727 1668780 21 403517 mcatanzaro 2020-07-04 08:02:10 -0700 Comment on attachment 403517 Patch OK, this looks good. Let's wait and see if the flatpak patch is accepted before we commit. Bastien has suggested in the flatpak PR that we might need to write a portal instead. 1669013 22 403517 aperez 2020-07-06 03:46:38 -0700 Comment on attachment 403517 Patch The logic in the patch looks good overall, but there are still a few things that I would prefer to see ironed out before landing. At any rate, thanks a ton for working on it! View in context: https://bugs.webkit.org/attachment.cgi?id=403517&action=review > Source/WebCore/platform/glib/UserAgentGLib.cpp:52 > + if (!g_file_get_contents("/etc/machine-info", &buffer.outPtr(), nullptr, nullptr)) Please use a GError here and emit a warning if the error is other than G_IO_ERROR_NOT_FOUND, which will make it much easier to figure out the cause when things don't work. In general silently skipping over errors is a bad idea. > Source/WebCore/platform/glib/UserAgentGLib.cpp:72 > + if (g_file_get_contents("/sys/class/dmi/id/chassis_type", &buffer.outPtr(), nullptr, nullptr)) { Use a GError here as well, please. > Source/WebCore/platform/glib/UserAgentGLib.cpp:73 > + int t = atoi(buffer.get()); Please use strtol() instead and check its result for conversion errors. Even better, use WTF::toIntegralType() which also can report errors. > Source/WebCore/platform/glib/UserAgentGLib.cpp:75 > + switch (t) { A comment here indicating which source file in the kernel defines these constants would be useful, in case somebody need to re-check it in the future to update the “switch” statement. > Source/WebCore/platform/glib/UserAgentGLib.cpp:104 > + int t = atoi(buffer.get()); Ditto: Do not silently skip over all errors, use a checked numeric conversion function, and add a comment indicating which Linux kernel source file defines the magic values. 1669014 23 aperez 2020-07-06 03:48:01 -0700 Also, this touches UserAgentGLib.cpp, so the bug description should have the [WPE] tag as well. 1669017 24 403517 cgarcia 2020-07-06 04:02:44 -0700 Comment on attachment 403517 Patch We already have WebContentMode, Apple uses it via content policies and it changes the user agent for iOS. We could at least reuse the enum. 1669054 25 403599 jan.brummer 2020-07-06 09:54:57 -0700 Created attachment 403599 Patch 1669056 26 jan.brummer 2020-07-06 09:58:02 -0700 Patch updated: - I've readded the error handling code which only prints out a warning in case it is not G_IO_ERROR_NOT_FOUND. - Used strtol. - Added documentation links where those types are coming from. - Added [WPE] within ChangeLog. I did not switch to WebContentMode as i think it does not reflect a chassis type and in future this type can be expanded for other devices. Take a look at cocoa where there is something similar. 1669672 27 403599 cgarcia 2020-07-07 23:42:59 -0700 Comment on attachment 403599 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=403599&action=review > Source/WebCore/platform/glib/UserAgentGLib.cpp:55 > + if (!g_error_matches(error.get(), G_IO_ERROR, G_IO_ERROR_NOT_FOUND)) > + g_warning("Could not open /etc/machine-info: %s", error->message); This is not working, all API tests are failing because of this warning: FATAL-WARNING: Could not open /etc/machine-info: Failed to open file “/etc/machine-info”: No such file or directory > Source/WebCore/platform/glib/UserAgentGLib.cpp:140 > +static ChassisType getChassisType() We don't use getFoo in WebKit when the result is returned as return value. > Source/WebCore/platform/glib/UserAgentGLib.cpp:145 > + static bool firstRun = true; > + > + if (firstRun) { Use std::once_flag > Source/WebCore/platform/glib/UserAgentGLib.cpp:282 > + auto quirks = UserAgentQuirks::quirksForURL(url, getChassisType()); I wonder if we could move the chassisType() to WTF and simply use it every, instead of passing it as an argument. For now it's only used by user agent, but doesn't really belong to UserAgent, I would say. 1669680 28 jan.brummer 2020-07-08 00:54:47 -0700 (In reply to Carlos Garcia Campos from comment #27) > Comment on attachment 403599 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=403599&action=review > > > Source/WebCore/platform/glib/UserAgentGLib.cpp:55 > > + if (!g_error_matches(error.get(), G_IO_ERROR, G_IO_ERROR_NOT_FOUND)) > > + g_warning("Could not open /etc/machine-info: %s", error->message); > > This is not working, all API tests are failing because of this warning: > > FATAL-WARNING: Could not open /etc/machine-info: Failed to open file > “/etc/machine-info”: No such file or directory Shall i remove the error again? > > > Source/WebCore/platform/glib/UserAgentGLib.cpp:140 > > +static ChassisType getChassisType() > > We don't use getFoo in WebKit when the result is returned as return value. So just chassisType()? > > > Source/WebCore/platform/glib/UserAgentGLib.cpp:145 > > + static bool firstRun = true; > > + > > + if (firstRun) { > > Use std::once_flag > > > Source/WebCore/platform/glib/UserAgentGLib.cpp:282 > > + auto quirks = UserAgentQuirks::quirksForURL(url, getChassisType()); > > I wonder if we could move the chassisType() to WTF and simply use it every, > instead of passing it as an argument. For now it's only used by user agent, > but doesn't really belong to UserAgent, I would say. Just below WTF or in an existing file? 1669690 29 403599 cgarcia 2020-07-08 01:31:06 -0700 Comment on attachment 403599 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=403599&action=review >>> Source/WebCore/platform/glib/UserAgentGLib.cpp:55 >>> + g_warning("Could not open /etc/machine-info: %s", error->message); >> >> This is not working, all API tests are failing because of this warning: >> >> FATAL-WARNING: Could not open /etc/machine-info: Failed to open file “/etc/machine-info”: No such file or directory > > Shall i remove the error again? We should handle the right error, g_file_get_contents is not a gio function, so the error is not a G_IO_ERROR but a G_FILE_ERROR. >>> Source/WebCore/platform/glib/UserAgentGLib.cpp:140 >>> +static ChassisType getChassisType() >> >> We don't use getFoo in WebKit when the result is returned as return value. > > So just chassisType()? Right. >>> Source/WebCore/platform/glib/UserAgentGLib.cpp:145 >>> + if (firstRun) { >> >> Use std::once_flag > > Just below WTF or in an existing file? Since it's only used by glib, under WTF/wtf/glib I would say. See RAMSize or MemoryFootprint for examples. 1669732 30 403775 jan.brummer 2020-07-08 06:22:52 -0700 Created attachment 403775 Patch 1669733 31 403776 jan.brummer 2020-07-08 06:32:15 -0700 Created attachment 403776 Patch 1669734 32 jan.brummer 2020-07-08 06:34:11 -0700 Ok, I've integrated Carlos suggestions. Feel free to review again. 1670040 33 403776 cgarcia 2020-07-09 01:21:12 -0700 Comment on attachment 403776 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=403776&action=review > Source/WTF/wtf/PlatformGTK.cmake:27 > + glib/ChassisType.cpp You have to add the files to PlatformWPE.cmake too. > Source/WTF/wtf/glib/ChassisType.cpp:88 > + } else { > + if (!g_error_matches(error.get(), G_FILE_ERROR, G_FILE_ERROR_NOENT)) else if? > Source/WTF/wtf/glib/ChassisType.cpp:118 > + } else { > + if (!g_error_matches(error.get(), G_FILE_ERROR, G_FILE_ERROR_NOENT)) Ditto. > Source/WTF/wtf/glib/ChassisType.cpp:136 > + if (chassisType == ChassisType::Unknown) > + chassisType = ChassisType::Desktop; So, Unknown is never exposed, we always fallback to Desktop. I think it would be better to use Optional<> instead of adding the Unknown value to the enum. All read functions would return Optional<ChassisType>, returning WTF::nullopt when unknown. 1670093 34 403863 jan.brummer 2020-07-09 07:20:28 -0700 Created attachment 403863 Patch 1670094 35 jan.brummer 2020-07-09 07:21:13 -0700 Makes sense, updated. 1670100 36 403863 cgarcia 2020-07-09 07:48:28 -0700 Comment on attachment 403863 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=403863&action=review > Source/WebCore/ChangeLog:8 > + No new tests (OOPS!). This line should be removed, otherwise commit-queue will reject the patch. > Source/WTF/wtf/glib/ChassisType.cpp:121 > +Optional<ChassisType> chassisType() This shouldn't be optional since we are always falling back to Desktop, it never returns nullopt. > Source/WTF/wtf/glib/ChassisType.cpp:123 > + static Optional<ChassisType> chassisType; Same here, we will always return a valid enum value. > Source/WTF/wtf/glib/ChassisType.cpp:126 > + chassisType = readMachineInfoChassisType(); We will need an optional here though. > Source/WTF/wtf/glib/ChassisType.cpp:127 > + if (chassisType == WTF::nullopt) Don't compare to nullopt, use !chassisType > Source/WTF/wtf/glib/ChassisType.cpp:132 > + if (chassisType == WTF::nullopt) > + chassisType = ChassisType::Desktop; And here we could do chassisType = optionalChassisType.valueOr(ChassisType::Desktop); 1670104 37 403865 jan.brummer 2020-07-09 08:18:04 -0700 Created attachment 403865 Patch 1670105 38 jan.brummer 2020-07-09 08:18:39 -0700 Thanks Carlos, patch updated. 1670368 39 403865 cgarcia 2020-07-09 23:12:29 -0700 Comment on attachment 403865 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=403865&action=review > Source/WTF/wtf/glib/ChassisType.h:22 > +#include <wtf/Optional.h> You don't need this include in the header, move it to the cpp, please. 1670381 40 403949 jan.brummer 2020-07-10 00:18:55 -0700 Created attachment 403949 Patch 1670382 41 jan.brummer 2020-07-10 00:19:15 -0700 Moved include to cpp file. 1670391 42 403949 cgarcia 2020-07-10 02:12:50 -0700 Comment on attachment 403949 Patch Excellent, thanks! 1670393 43 ews-feeder 2020-07-10 02:16:23 -0700 Committed r264213: <https://trac.webkit.org/changeset/264213> All reviewed patches have been landed. Closing bug and clearing flags on attachment 403949. 403095 2020-06-29 12:17:03 -0700 2020-06-29 23:35:47 -0700 Patch bug-149496-20200629211701.patch text/plain 8895 jan.brummer U3VidmVyc2lvbiBSZXZpc2lvbjogMjYzNjYzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggODc2MWFiMDQyYzc3MjNl M2ZiYTJmN2RlMmZmZTVjM2JjZmY3ZjU3Ni4uODNjZGJmYzU2NTZjZWExYTI2NDUyYTBmYjBlMjFj MDMyZGFiM2Y0NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI1IEBACisyMDIwLTA2LTI5ICBKYW4t TWljaGFlbCBCcnVtbWVyICA8amFuLmJydW1tZXJAdGFib3Mub3JnPgorCisgICAgICAgIFtHVEtd IFVzZSBtb2JpbGUgdXNlci1hZ2VudCBvbiB0YWJsZXQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE0OTQ5NgorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIE5vIG5ldyB0ZXN0cyAoT09QUyEpLgorCisgICAgICAg ICogcGxhdGZvcm0vVXNlckFnZW50UXVpcmtzLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OnVybFJl cXVpcmVzTWFjaW50b3NoUGxhdGZvcm0pOgorICAgICAgICAoV2ViQ29yZTo6dXJsUmVxdWlyZXNM aW51eERlc2t0b3BQbGF0Zm9ybSk6CisgICAgICAgIChXZWJDb3JlOjpVc2VyQWdlbnRRdWlya3M6 OnF1aXJrc0ZvclVSTCk6CisgICAgICAgICogcGxhdGZvcm0vVXNlckFnZW50UXVpcmtzLmg6Cisg ICAgICAgICogcGxhdGZvcm0vZ2xpYi9Vc2VyQWdlbnRHTGliLmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OmdldENoYXNzaXNUeXBlKToKKyAgICAgICAgKFdlYkNvcmU6OnBsYXRmb3JtRm9yVUFTdHJp bmcpOgorICAgICAgICAoV2ViQ29yZTo6cGxhdGZvcm1WZXJzaW9uRm9yVUFTdHJpbmcpOgorICAg ICAgICAoV2ViQ29yZTo6YnVpbGRVc2VyQWdlbnRTdHJpbmcpOgorICAgICAgICAoV2ViQ29yZTo6 c3RhbmRhcmRVc2VyQWdlbnQpOgorICAgICAgICAoV2ViQ29yZTo6c3RhbmRhcmRVc2VyQWdlbnRG b3JVUkwpOgorCiAyMDIwLTA2LTI5ICBDaHJpcyBEdW1leiAgPGNkdW1lekBhcHBsZS5jb20+CiAK ICAgICAgICAgT24gbG9hZCBmcm9tIGJhY2svZm9yd2FyZCBjYWNoZSwgY2FsbCBjaGVja0NvbXBs ZXRlZCgpIGZvciBBTEwgZnJhbWVzIGluc2lkZSBGcmFtZUxvYWRlcjo6Y29tbWl0UHJvdmlzaW9u YWxMb2FkKCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1VzZXJBZ2VudFF1 aXJrcy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9Vc2VyQWdlbnRRdWlya3MuY3BwCmlu ZGV4IDRhYmRiODZiN2Q3OWQ1ODljMDE4YTdlMmIxMDRlNDU5ZWNhZmVkNDMuLmEwZTQ5NGQ0Njdi ODJiOGUxNzJmOTRmZWFhM2FkMDMyMGVlNWM2OTEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL1VzZXJBZ2VudFF1aXJrcy5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vVXNlckFnZW50UXVpcmtzLmNwcApAQCAtMTEzLDE3ICsxMTMsMTcgQEAgc3RhdGljIGJvb2wg dXJsUmVxdWlyZXNGaXJlZm94QnJvd3Nlcihjb25zdCBVUkwmIHVybCkKICAgICByZXR1cm4gZmFs c2U7CiB9CiAKLXN0YXRpYyBib29sIHVybFJlcXVpcmVzTWFjaW50b3NoUGxhdGZvcm0oY29uc3Qg VVJMJiB1cmwpCitzdGF0aWMgYm9vbCB1cmxSZXF1aXJlc01hY2ludG9zaFBsYXRmb3JtKGNvbnN0 IFVSTCYgdXJsLCBVc2VyQWdlbnRRdWlya3M6OkNoYXNzaXNUeXBlIGNoYXNzaXNUeXBlKQogewog ICAgIFN0cmluZyBkb21haW4gPSB1cmwuaG9zdCgpLnRvU3RyaW5nKCk7CiAgICAgU3RyaW5nIGJh c2VEb21haW4gPSB0b3BQcml2YXRlbHlDb250cm9sbGVkRG9tYWluKGRvbWFpbik7CiAKICAgICAv LyBBdCBsZWFzdCBmaW5hbmNlLnlhaG9vLmNvbSBkaXNwbGF5cyBhIG1vYmlsZSB2ZXJzaW9uIHdp dGggV2ViS2l0R1RLJ3Mgc3RhbmRhcmQgdXNlciBhZ2VudC4KLSAgICBpZiAoYmFzZURvbWFpbiA9 PSAieWFob28uY29tIikKKyAgICBpZiAoY2hhc3Npc1R5cGUgIT0gVXNlckFnZW50UXVpcmtzOjpD aGFzc2lzVHlwZU1vYmlsZSAmJiBiYXNlRG9tYWluID09ICJ5YWhvby5jb20iKQogICAgICAgICBy ZXR1cm4gdHJ1ZTsKIAogICAgIC8vIHRhb2Jhby5jb20gZGlzcGxheXMgYSBtb2JpbGUgdmVyc2lv biB3aXRoIFdlYktpdEdUSydzIHN0YW5kYXJkIHVzZXIgYWdlbnQuCi0gICAgaWYgKGJhc2VEb21h aW4gPT0gInRhb2Jhby5jb20iKQorICAgIGlmIChjaGFzc2lzVHlwZSAhPSBVc2VyQWdlbnRRdWly a3M6OkNoYXNzaXNUeXBlTW9iaWxlICYmIGJhc2VEb21haW4gPT0gInRhb2Jhby5jb20iKQogICAg ICAgICByZXR1cm4gdHJ1ZTsKIAogICAgIC8vIHdlYi53aGF0c2FwcC5jb20gY29tcGxldGVseSBi bG9ja3MgdXNlcnMgd2l0aCBXZWJLaXRHVEsncyBzdGFuZGFyZCB1c2VyIGFnZW50LgpAQCAtMTUw LDEyICsxNTAsMTUgQEAgc3RhdGljIGJvb2wgdXJsUmVxdWlyZXNNYWNpbnRvc2hQbGF0Zm9ybShj b25zdCBVUkwmIHVybCkKICAgICByZXR1cm4gZmFsc2U7CiB9CiAKLXN0YXRpYyBib29sIHVybFJl cXVpcmVzTGludXhEZXNrdG9wUGxhdGZvcm0oY29uc3QgVVJMJiB1cmwpCitzdGF0aWMgYm9vbCB1 cmxSZXF1aXJlc0xpbnV4RGVza3RvcFBsYXRmb3JtKGNvbnN0IFVSTCYgdXJsLCBVc2VyQWdlbnRR dWlya3M6OkNoYXNzaXNUeXBlIGNoYXNzaXNUeXBlKQogewotICAgIHJldHVybiBpc0dvb2dsZSh1 cmwpOworICAgIGJvb2wgcmV0ID0gaXNHb29nbGUodXJsKSAmJiAoY2hhc3Npc1R5cGUgIT0gVXNl ckFnZW50UXVpcmtzOjpDaGFzc2lzVHlwZU1vYmlsZSk7CisKKyAgICBXVEZMb2dBbHdheXMoIiVz OiAlZCwgJWRcbiIsIHVybC5ob3N0KCkudG9TdHJpbmcoKS51dGY4KCkuZGF0YSgpLCByZXQsIGNo YXNzaXNUeXBlKTsKKyAgICByZXR1cm4gcmV0OwogfQogCi1Vc2VyQWdlbnRRdWlya3MgVXNlckFn ZW50UXVpcmtzOjpxdWlya3NGb3JVUkwoY29uc3QgVVJMJiB1cmwpCitVc2VyQWdlbnRRdWlya3Mg VXNlckFnZW50UXVpcmtzOjpxdWlya3NGb3JVUkwoY29uc3QgVVJMJiB1cmwsIFVzZXJBZ2VudFF1 aXJrczo6Q2hhc3Npc1R5cGUgY2hhc3Npc1R5cGUpCiB7CiAgICAgQVNTRVJUKCF1cmwuaXNOdWxs KCkpOwogCkBAIC0xNjYsOSArMTY5LDkgQEAgVXNlckFnZW50UXVpcmtzIFVzZXJBZ2VudFF1aXJr czo6cXVpcmtzRm9yVVJMKGNvbnN0IFVSTCYgdXJsKQogICAgIGVsc2UgaWYgKHVybFJlcXVpcmVz RmlyZWZveEJyb3dzZXIodXJsKSkKICAgICAgICAgcXVpcmtzLmFkZChVc2VyQWdlbnRRdWlya3M6 Ok5lZWRzRmlyZWZveEJyb3dzZXIpOwogCi0gICAgaWYgKHVybFJlcXVpcmVzTWFjaW50b3NoUGxh dGZvcm0odXJsKSkKKyAgICBpZiAodXJsUmVxdWlyZXNNYWNpbnRvc2hQbGF0Zm9ybSh1cmwsIGNo YXNzaXNUeXBlKSkKICAgICAgICAgcXVpcmtzLmFkZChVc2VyQWdlbnRRdWlya3M6Ok5lZWRzTWFj aW50b3NoUGxhdGZvcm0pOwotICAgIGVsc2UgaWYgKHVybFJlcXVpcmVzTGludXhEZXNrdG9wUGxh dGZvcm0odXJsKSkKKyAgICBlbHNlIGlmICh1cmxSZXF1aXJlc0xpbnV4RGVza3RvcFBsYXRmb3Jt KHVybCwgY2hhc3Npc1R5cGUpKQogICAgICAgICBxdWlya3MuYWRkKFVzZXJBZ2VudFF1aXJrczo6 TmVlZHNMaW51eERlc2t0b3BQbGF0Zm9ybSk7CiAKICAgICByZXR1cm4gcXVpcmtzOwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVXNlckFnZW50UXVpcmtzLmggYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9Vc2VyQWdlbnRRdWlya3MuaAppbmRleCA5ODJmODdmOGMxYzRhYjkw YzdjZmMwY2M4NmY1YzRiZmUzNmZhZWYzLi5kMmVkNWNlMWM2MDFmZjAwM2U5NzNiNWVmY2NjYzZi YjMxZTg0Y2ZmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9Vc2VyQWdlbnRR dWlya3MuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9Vc2VyQWdlbnRRdWlya3MuaApA QCAtNDAsNiArNDAsMTEgQEAgcHVibGljOgogCiAgICAgICAgIE51bVVzZXJBZ2VudFF1aXJrcwog ICAgIH07CisgICAgZW51bSBDaGFzc2lzVHlwZSB7CisgICAgICAgIENoYXNzaXNUeXBlVW5rbm93 biwKKyAgICAgICAgQ2hhc3Npc1R5cGVEZXNrdG9wLAorICAgICAgICBDaGFzc2lzVHlwZU1vYmls ZQorICAgIH07CiAKICAgICBVc2VyQWdlbnRRdWlya3MoKQogICAgICAgICA6IG1fcXVpcmtzKDAp CkBAIC02Miw3ICs2Nyw3IEBAIHB1YmxpYzoKIAogICAgIGJvb2wgaXNFbXB0eSgpIGNvbnN0IHsg cmV0dXJuICFtX3F1aXJrczsgfQogCi0gICAgc3RhdGljIFVzZXJBZ2VudFF1aXJrcyBxdWlya3NG b3JVUkwoY29uc3QgVVJMJik7CisgICAgc3RhdGljIFVzZXJBZ2VudFF1aXJrcyBxdWlya3NGb3JV UkwoY29uc3QgVVJMJiwgQ2hhc3Npc1R5cGUpOwogCiAgICAgc3RhdGljIFN0cmluZyBzdHJpbmdG b3JRdWlyayhVc2VyQWdlbnRRdWlyayk7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dsaWIvVXNlckFnZW50R0xpYi5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n bGliL1VzZXJBZ2VudEdMaWIuY3BwCmluZGV4IDNlMTZjN2FhZjc5ODEyNWM0ZmY4ZmU3MDc0ZWMy Mjc0Mjg3YWRlNzkuLmMxNjhkYjhlNTllOWYzNzRkNDFmZTRhZTNhNjg5Y2VlMWQ4MWFmZTkgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dsaWIvVXNlckFnZW50R0xpYi5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ2xpYi9Vc2VyQWdlbnRHTGliLmNwcApAQCAt MzcsNiArMzcsOCBAQAogI2luY2x1ZGUgPHN5cy91dHNuYW1lLmg+CiAjZW5kaWYKIAorI2luY2x1 ZGUgPGdpby9naW8uaD4KKwogLy8gV0FSTklORyEgV0FSTklORyEgV0FSTklORyEKIC8vCiAvLyBU aGUgdXNlciBhZ2VudCBpcyBsdWRpY3JvdXNseSBmcmFnaWxlLiBUaGUgbW9zdCBpbm5vY2VudCBj aGFuZ2UgY2FuCkBAIC00NSwxMSArNDcsNjcgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCitz dGF0aWMgVXNlckFnZW50UXVpcmtzOjpDaGFzc2lzVHlwZSBnZXRDaGFzc2lzVHlwZSgpCit7Cisg ICAgc3RhdGljIFVzZXJBZ2VudFF1aXJrczo6Q2hhc3Npc1R5cGUgY2hhc3Npc1R5cGUgPSBVc2Vy QWdlbnRRdWlya3M6OkNoYXNzaXNUeXBlVW5rbm93bjsKKworICAgIFdURkxvZ0Fsd2F5cygiJXMo KTogRU5URVJcbiIsIF9fRlVOQ1RJT05fXyk7CisgICAgaWYgKGNoYXNzaXNUeXBlID09IFVzZXJB Z2VudFF1aXJrczo6Q2hhc3Npc1R5cGVVbmtub3duKSB7CisgICAgICAgIGdfYXV0b3B0cihHRXJy b3IpIGVycm9yID0gTlVMTDsKKyAgICAgICAgZ19hdXRvcHRyKEdEQnVzQ29ubmVjdGlvbikgY29u bmVjdGlvbiA9IE5VTEw7CisgICAgICAgIGdfYXV0b3B0cihHVmFyaWFudCkgdmFyID0gTlVMTDsK KyAgICAgICAgZ19hdXRvcHRyKEdWYXJpYW50KSB2ID0gTlVMTDsKKyAgICAgICAgY29uc3QgY2hh ciogY2hhc3NpczsKKworICAgICAgICBjb25uZWN0aW9uID0gZ19idXNfZ2V0X3N5bmMoR19CVVNf VFlQRV9TWVNURU0sIE5VTEwsICZlcnJvcik7CisgICAgICAgIGlmICghY29ubmVjdGlvbikgewor ICAgICAgICAgICAgZ19kZWJ1ZygiQ291bGQgbm90IGNvbm5lY3QgdG8gc3lzdGVtIGJ1czogJXMi LCBlcnJvci0+bWVzc2FnZSk7CisgICAgICAgICAgICBXVEZMb2dBbHdheXMoIiVzKCk6IEVYSVQg MSAlc1xuIiwgX19GVU5DVElPTl9fLCBlcnJvci0+bWVzc2FnZSk7CisgICAgICAgICAgICByZXR1 cm4gVXNlckFnZW50UXVpcmtzOjpDaGFzc2lzVHlwZVVua25vd247CisgICAgICAgIH0KKworICAg ICAgICB2YXIgPSBnX2RidXNfY29ubmVjdGlvbl9jYWxsX3N5bmMoY29ubmVjdGlvbiwKKyAgICAi b3JnLmZyZWVkZXNrdG9wLmhvc3RuYW1lMSIsCisgICAgIi9vcmcvZnJlZWRlc2t0b3AvaG9zdG5h bWUxIiwKKyAgICAib3JnLmZyZWVkZXNrdG9wLkRCdXMuUHJvcGVydGllcyIsCisgICAgIkdldCIs CisgICAgZ192YXJpYW50X25ldygiKHNzKSIsICJvcmcuZnJlZWRlc2t0b3AuaG9zdG5hbWUxIiwg IkNoYXNzaXMiKSwKKyAgICBudWxscHRyLAorICAgIEdfREJVU19DQUxMX0ZMQUdTX05PTkUsCisg ICAgLTEsCisgICAgbnVsbHB0ciwKKyAgICAmZXJyb3IpOworCisgICAgICAgIGlmICghdmFyKSB7 CisgICAgICAgICAgICBXVEZMb2dBbHdheXMoIiVzKCk6IEVYSVQgMlxuIiwgX19GVU5DVElPTl9f KTsKKyAgICAgICAgICAgIGdfZGVidWcoIkNvdWxkIG5vdCBhY2Nlc3MgY2hhc3NpcyBwcm9wZXJ0 eTogJXMiLCBlcnJvci0+bWVzc2FnZSk7CisgICAgICAgICAgICByZXR1cm4gVXNlckFnZW50UXVp cmtzOjpDaGFzc2lzVHlwZVVua25vd247CisgICAgICAgIH0KKworICAgICAgICBnX3ZhcmlhbnRf Z2V0KHZhciwgIih2KSIsICZ2KTsKKyAgICAgICAgY2hhc3NpcyA9IGdfdmFyaWFudF9nZXRfc3Ry aW5nKHYsIE5VTEwpOworICAgICAgICBXVEZMb2dBbHdheXMoIiVzKCk6IEVYSVQgKCVzKVxuIiwg X19GVU5DVElPTl9fLCBjaGFzc2lzKTsKKworICAgICAgICAvKiBjb252ZXJ0aWJsZSBpcyBqdXN0 IGZvciB0ZXN0aW5nIGF0IHRoZSBtb21lbnQgKi8KKyAgICAgICAgaWYgKCFzdHJjbXAoY2hhc3Np cywgImhhbmRzZXQiKSB8fCAhc3RyY21wKGNoYXNzaXMsICJjb252ZXJ0aWJsZSIpKQorICAgICAg ICAgICAgY2hhc3Npc1R5cGUgPSBVc2VyQWdlbnRRdWlya3M6OkNoYXNzaXNUeXBlTW9iaWxlOwor ICAgICAgICBlbHNlCisgICAgICAgICAgICBjaGFzc2lzVHlwZSA9IFVzZXJBZ2VudFF1aXJrczo6 Q2hhc3Npc1R5cGVEZXNrdG9wOworICAgIH0KKworICAgIFdURkxvZ0Fsd2F5cygiJXMoKTogKCVk KVxuIiwgX19GVU5DVElPTl9fLCBjaGFzc2lzVHlwZSk7CisKKyAgICByZXR1cm4gY2hhc3Npc1R5 cGU7Cit9CisKIHN0YXRpYyBjb25zdCBjaGFyKiBwbGF0Zm9ybUZvclVBU3RyaW5nKCkKIHsKICNp ZiBPUyhNQUNfT1NfWCkKICAgICByZXR1cm4gIk1hY2ludG9zaCI7CiAjZWxzZQorICAgIGlmIChn ZXRDaGFzc2lzVHlwZSgpID09IFVzZXJBZ2VudFF1aXJrczo6Q2hhc3Npc1R5cGVNb2JpbGUpCisg ICAgICAgIHJldHVybiAiTGludXgiOworCiAgICAgcmV0dXJuICJYMTEiOwogI2VuZGlmCiB9CkBA IC02MCw2ICsxMTgsMTAgQEAgc3RhdGljIGNvbnN0IFN0cmluZyBwbGF0Zm9ybVZlcnNpb25Gb3JV QVN0cmluZygpCiAgICAgc3RydWN0IHV0c25hbWUgbmFtZTsKICAgICB1bmFtZSgmbmFtZSk7CiAg ICAgc3RhdGljIE5ldmVyRGVzdHJveWVkPGNvbnN0IFN0cmluZz4gdWFPU1ZlcnNpb24obWFrZVN0 cmluZyhuYW1lLnN5c25hbWUsICcgJywgbmFtZS5tYWNoaW5lKSk7CisKKyAgICBpZiAoZ2V0Q2hh c3Npc1R5cGUoKSA9PSBVc2VyQWdlbnRRdWlya3M6OkNoYXNzaXNUeXBlTW9iaWxlKQorICAgICAg ICByZXR1cm4gImxpa2UgQW5kcm9pZCA0LjQiOworCiAgICAgcmV0dXJuIHVhT1NWZXJzaW9uOwog I2Vsc2UKICAgICAvLyBXZSB3aWxsIGFsd2F5cyBjbGFpbSB0byBiZSBTYWZhcmkgaW4gSW50ZWwg TWFjIE9TIFgsIHNpbmNlIFNhZmFyaSB3aXRob3V0CkBAIC03OSw2ICsxNDEsNyBAQCBzdGF0aWMg aW5saW5lIGNvbnN0IGNoYXIqIHZlcnNpb25Gb3JVQVN0cmluZygpCiBzdGF0aWMgU3RyaW5nIGJ1 aWxkVXNlckFnZW50U3RyaW5nKGNvbnN0IFVzZXJBZ2VudFF1aXJrcyYgcXVpcmtzKQogewogICAg IFN0cmluZ0J1aWxkZXIgdWFTdHJpbmc7CisKICAgICB1YVN0cmluZy5hcHBlbmRMaXRlcmFsKCJN b3ppbGxhLzUuMCAiKTsKICAgICB1YVN0cmluZy5hcHBlbmQoJygnKTsKIApAQCAtMTEzLDYgKzE3 NiwxMCBAQCBzdGF0aWMgU3RyaW5nIGJ1aWxkVXNlckFnZW50U3RyaW5nKGNvbnN0IFVzZXJBZ2Vu dFF1aXJrcyYgcXVpcmtzKQogICAgIC8vIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0xMzM0MDMgZm9yIGRldGFpbHMuCiAgICAgfSBlbHNlCiAgICAgICAgIHVhU3RyaW5n LmFwcGVuZExpdGVyYWwoIlZlcnNpb24vMTMuMCAiKTsKKworICAgIGlmIChnZXRDaGFzc2lzVHlw ZSgpID09IFVzZXJBZ2VudFF1aXJrczo6Q2hhc3Npc1R5cGVNb2JpbGUpCisgICAgICAgIHVhU3Ry aW5nLmFwcGVuZExpdGVyYWwoIk1vYmlsZSAiKTsKKwogICAgIHVhU3RyaW5nLmFwcGVuZExpdGVy YWwoIlNhZmFyaS8iKTsKICAgICB1YVN0cmluZy5hcHBlbmQodmVyc2lvbkZvclVBU3RyaW5nKCkp OwogCkBAIC0xMzcsNiArMjA0LDcgQEAgU3RyaW5nIHN0YW5kYXJkVXNlckFnZW50KGNvbnN0IFN0 cmluZyYgYXBwbGljYXRpb25OYW1lLCBjb25zdCBTdHJpbmcmIGFwcGxpY2F0aW8KICAgICAvLyBz aXRlcyB3b24ndCBsb2FkIHJlc291cmNlcyBhdCBhbGwuCiAKICAgICBTdHJpbmcgdXNlckFnZW50 OworCiAgICAgaWYgKGFwcGxpY2F0aW9uTmFtZS5pc0VtcHR5KCkpIHsKICAgICAgICAgdXNlckFn ZW50ID0gc3RhbmRhcmRVc2VyQWdlbnRTdGF0aWMoKTsKICAgICB9IGVsc2UgewpAQCAtMTU5LDcg KzIyNyw3IEBAIFN0cmluZyBzdGFuZGFyZFVzZXJBZ2VudChjb25zdCBTdHJpbmcmIGFwcGxpY2F0 aW9uTmFtZSwgY29uc3QgU3RyaW5nJiBhcHBsaWNhdGlvCiAKIFN0cmluZyBzdGFuZGFyZFVzZXJB Z2VudEZvclVSTChjb25zdCBVUkwmIHVybCkKIHsKLSAgICBhdXRvIHF1aXJrcyA9IFVzZXJBZ2Vu dFF1aXJrczo6cXVpcmtzRm9yVVJMKHVybCk7CisgICAgYXV0byBxdWlya3MgPSBVc2VyQWdlbnRR dWlya3M6OnF1aXJrc0ZvclVSTCh1cmwsIGdldENoYXNzaXNUeXBlKCkpOwogICAgIC8vIFRoZSBu dWxsIHN0cmluZyBtZWFucyB3ZSBkb24ndCBuZWVkIGEgc3BlY2lmaWMgVUEgZm9yIHRoZSBnaXZl biBVUkwuCiAgICAgaWYgKHF1aXJrcy5pc0VtcHR5KCkpCiAgICAgICAgIHJldHVybiBTdHJpbmco KTsK 403176 2020-06-29 23:35:53 -0700 2020-06-29 23:49:40 -0700 Patch bug-149496-20200630083551.patch text/plain 9561 jan.brummer U3VidmVyc2lvbiBSZXZpc2lvbjogMjYzNjYzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggODc2MWFiMDQyYzc3MjNl M2ZiYTJmN2RlMmZmZTVjM2JjZmY3ZjU3Ni4uODNjZGJmYzU2NTZjZWExYTI2NDUyYTBmYjBlMjFj MDMyZGFiM2Y0NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI1IEBACisyMDIwLTA2LTI5ICBKYW4t TWljaGFlbCBCcnVtbWVyICA8amFuLmJydW1tZXJAdGFib3Mub3JnPgorCisgICAgICAgIFtHVEtd IFVzZSBtb2JpbGUgdXNlci1hZ2VudCBvbiB0YWJsZXQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE0OTQ5NgorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIE5vIG5ldyB0ZXN0cyAoT09QUyEpLgorCisgICAgICAg ICogcGxhdGZvcm0vVXNlckFnZW50UXVpcmtzLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OnVybFJl cXVpcmVzTWFjaW50b3NoUGxhdGZvcm0pOgorICAgICAgICAoV2ViQ29yZTo6dXJsUmVxdWlyZXNM aW51eERlc2t0b3BQbGF0Zm9ybSk6CisgICAgICAgIChXZWJDb3JlOjpVc2VyQWdlbnRRdWlya3M6 OnF1aXJrc0ZvclVSTCk6CisgICAgICAgICogcGxhdGZvcm0vVXNlckFnZW50UXVpcmtzLmg6Cisg ICAgICAgICogcGxhdGZvcm0vZ2xpYi9Vc2VyQWdlbnRHTGliLmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OmdldENoYXNzaXNUeXBlKToKKyAgICAgICAgKFdlYkNvcmU6OnBsYXRmb3JtRm9yVUFTdHJp bmcpOgorICAgICAgICAoV2ViQ29yZTo6cGxhdGZvcm1WZXJzaW9uRm9yVUFTdHJpbmcpOgorICAg ICAgICAoV2ViQ29yZTo6YnVpbGRVc2VyQWdlbnRTdHJpbmcpOgorICAgICAgICAoV2ViQ29yZTo6 c3RhbmRhcmRVc2VyQWdlbnQpOgorICAgICAgICAoV2ViQ29yZTo6c3RhbmRhcmRVc2VyQWdlbnRG b3JVUkwpOgorCiAyMDIwLTA2LTI5ICBDaHJpcyBEdW1leiAgPGNkdW1lekBhcHBsZS5jb20+CiAK ICAgICAgICAgT24gbG9hZCBmcm9tIGJhY2svZm9yd2FyZCBjYWNoZSwgY2FsbCBjaGVja0NvbXBs ZXRlZCgpIGZvciBBTEwgZnJhbWVzIGluc2lkZSBGcmFtZUxvYWRlcjo6Y29tbWl0UHJvdmlzaW9u YWxMb2FkKCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1VzZXJBZ2VudC5o IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVXNlckFnZW50LmgKaW5kZXggZWJjZGIxZGQwODEy NGZiZWJmNTM2ODdjMjk4YTg3ZjFlYTY1MWE0NS4uNjI3Yjk3NDBiNmY4NWJkZTRlNDA3OTIzOWUw ZTI1YjFkN2ZlNWUxMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVXNlckFn ZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVXNlckFnZW50LmgKQEAgLTM3LDcg KzM3LDExIEBAIFdFQkNPUkVfRVhQT1JUIFN0cmluZyBzdGFuZGFyZFVzZXJBZ2VudFdpdGhBcHBs aWNhdGlvbk5hbWUoY29uc3QgU3RyaW5nJiBhcHBsaWNhCiBXRUJDT1JFX0VYUE9SVCBTdHJpbmcg b3NOYW1lRm9yVXNlckFnZW50KCk7CiBXRUJDT1JFX0VYUE9SVCBTdHJpbmcgc3lzdGVtTWFya2V0 aW5nVmVyc2lvbkZvclVzZXJBZ2VudFN0cmluZygpOwogI2Vsc2UKLQorZW51bSBjbGFzcyBDaGFz c2lzVHlwZSB7CisgICAgVW5rbm93biwKKyAgICBEZXNrdG9wLAorICAgIE1vYmlsZQorfTsKIFdF QkNPUkVfRVhQT1JUIFN0cmluZyBzdGFuZGFyZFVzZXJBZ2VudChjb25zdCBTdHJpbmcmIGFwcGxp Y2F0aW9uTmFtZSA9IGVtcHR5U3RyaW5nKCksIGNvbnN0IFN0cmluZyYgYXBwbGljYXRpb25WZXJz aW9uID0gZW1wdHlTdHJpbmcoKSk7CiBXRUJDT1JFX0VYUE9SVCBTdHJpbmcgc3RhbmRhcmRVc2Vy QWdlbnRGb3JVUkwoY29uc3QgVVJMJik7CiAjZW5kaWYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL1VzZXJBZ2VudFF1aXJrcy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9Vc2VyQWdlbnRRdWlya3MuY3BwCmluZGV4IDRhYmRiODZiN2Q3OWQ1ODljMDE4YTdlMmIxMDRl NDU5ZWNhZmVkNDMuLjJlYzc2MDdkNDkzZDJjZDNlYzg5ODI3ZTY5ZWVjNmQ2NTcxNjVmZjIgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1VzZXJBZ2VudFF1aXJrcy5jcHAKKysr IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVXNlckFnZW50UXVpcmtzLmNwcApAQCAtMTEzLDE3 ICsxMTMsMTcgQEAgc3RhdGljIGJvb2wgdXJsUmVxdWlyZXNGaXJlZm94QnJvd3Nlcihjb25zdCBV UkwmIHVybCkKICAgICByZXR1cm4gZmFsc2U7CiB9CiAKLXN0YXRpYyBib29sIHVybFJlcXVpcmVz TWFjaW50b3NoUGxhdGZvcm0oY29uc3QgVVJMJiB1cmwpCitzdGF0aWMgYm9vbCB1cmxSZXF1aXJl c01hY2ludG9zaFBsYXRmb3JtKGNvbnN0IFVSTCYgdXJsLCBDaGFzc2lzVHlwZSBjaGFzc2lzVHlw ZSkKIHsKICAgICBTdHJpbmcgZG9tYWluID0gdXJsLmhvc3QoKS50b1N0cmluZygpOwogICAgIFN0 cmluZyBiYXNlRG9tYWluID0gdG9wUHJpdmF0ZWx5Q29udHJvbGxlZERvbWFpbihkb21haW4pOwog CiAgICAgLy8gQXQgbGVhc3QgZmluYW5jZS55YWhvby5jb20gZGlzcGxheXMgYSBtb2JpbGUgdmVy c2lvbiB3aXRoIFdlYktpdEdUSydzIHN0YW5kYXJkIHVzZXIgYWdlbnQuCi0gICAgaWYgKGJhc2VE b21haW4gPT0gInlhaG9vLmNvbSIpCisgICAgaWYgKGNoYXNzaXNUeXBlICE9IENoYXNzaXNUeXBl OjpNb2JpbGUgJiYgYmFzZURvbWFpbiA9PSAieWFob28uY29tIikKICAgICAgICAgcmV0dXJuIHRy dWU7CiAKICAgICAvLyB0YW9iYW8uY29tIGRpc3BsYXlzIGEgbW9iaWxlIHZlcnNpb24gd2l0aCBX ZWJLaXRHVEsncyBzdGFuZGFyZCB1c2VyIGFnZW50LgotICAgIGlmIChiYXNlRG9tYWluID09ICJ0 YW9iYW8uY29tIikKKyAgICBpZiAoY2hhc3Npc1R5cGUgIT0gQ2hhc3Npc1R5cGU6Ok1vYmlsZSAm JiBiYXNlRG9tYWluID09ICJ0YW9iYW8uY29tIikKICAgICAgICAgcmV0dXJuIHRydWU7CiAKICAg ICAvLyB3ZWIud2hhdHNhcHAuY29tIGNvbXBsZXRlbHkgYmxvY2tzIHVzZXJzIHdpdGggV2ViS2l0 R1RLJ3Mgc3RhbmRhcmQgdXNlciBhZ2VudC4KQEAgLTE1MCwxMiArMTUwLDE1IEBAIHN0YXRpYyBi b29sIHVybFJlcXVpcmVzTWFjaW50b3NoUGxhdGZvcm0oY29uc3QgVVJMJiB1cmwpCiAgICAgcmV0 dXJuIGZhbHNlOwogfQogCi1zdGF0aWMgYm9vbCB1cmxSZXF1aXJlc0xpbnV4RGVza3RvcFBsYXRm b3JtKGNvbnN0IFVSTCYgdXJsKQorc3RhdGljIGJvb2wgdXJsUmVxdWlyZXNMaW51eERlc2t0b3BQ bGF0Zm9ybShjb25zdCBVUkwmIHVybCwgQ2hhc3Npc1R5cGUgY2hhc3Npc1R5cGUpCiB7Ci0gICAg cmV0dXJuIGlzR29vZ2xlKHVybCk7CisgICAgYm9vbCByZXQgPSBpc0dvb2dsZSh1cmwpICYmIGNo YXNzaXNUeXBlICE9IENoYXNzaXNUeXBlOjpNb2JpbGU7CisKKyAgICBXVEZMb2dBbHdheXMoIiVz OiAlZCwgJWRcbiIsIHVybC5ob3N0KCkudG9TdHJpbmcoKS51dGY4KCkuZGF0YSgpLCByZXQsIGNo YXNzaXNUeXBlKTsKKyAgICByZXR1cm4gcmV0OwogfQogCi1Vc2VyQWdlbnRRdWlya3MgVXNlckFn ZW50UXVpcmtzOjpxdWlya3NGb3JVUkwoY29uc3QgVVJMJiB1cmwpCitVc2VyQWdlbnRRdWlya3Mg VXNlckFnZW50UXVpcmtzOjpxdWlya3NGb3JVUkwoY29uc3QgVVJMJiB1cmwsIENoYXNzaXNUeXBl IGNoYXNzaXNUeXBlKQogewogICAgIEFTU0VSVCghdXJsLmlzTnVsbCgpKTsKIApAQCAtMTY2LDkg KzE2OSw5IEBAIFVzZXJBZ2VudFF1aXJrcyBVc2VyQWdlbnRRdWlya3M6OnF1aXJrc0ZvclVSTChj b25zdCBVUkwmIHVybCkKICAgICBlbHNlIGlmICh1cmxSZXF1aXJlc0ZpcmVmb3hCcm93c2VyKHVy bCkpCiAgICAgICAgIHF1aXJrcy5hZGQoVXNlckFnZW50UXVpcmtzOjpOZWVkc0ZpcmVmb3hCcm93 c2VyKTsKIAotICAgIGlmICh1cmxSZXF1aXJlc01hY2ludG9zaFBsYXRmb3JtKHVybCkpCisgICAg aWYgKHVybFJlcXVpcmVzTWFjaW50b3NoUGxhdGZvcm0odXJsLCBjaGFzc2lzVHlwZSkpCiAgICAg ICAgIHF1aXJrcy5hZGQoVXNlckFnZW50UXVpcmtzOjpOZWVkc01hY2ludG9zaFBsYXRmb3JtKTsK LSAgICBlbHNlIGlmICh1cmxSZXF1aXJlc0xpbnV4RGVza3RvcFBsYXRmb3JtKHVybCkpCisgICAg ZWxzZSBpZiAodXJsUmVxdWlyZXNMaW51eERlc2t0b3BQbGF0Zm9ybSh1cmwsIGNoYXNzaXNUeXBl KSkKICAgICAgICAgcXVpcmtzLmFkZChVc2VyQWdlbnRRdWlya3M6Ok5lZWRzTGludXhEZXNrdG9w UGxhdGZvcm0pOwogCiAgICAgcmV0dXJuIHF1aXJrczsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL1VzZXJBZ2VudFF1aXJrcy5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v VXNlckFnZW50UXVpcmtzLmgKaW5kZXggOTgyZjg3ZjhjMWM0YWI5MGM3Y2ZjMGNjODZmNWM0YmZl MzZmYWVmMy4uZjNiYTQ1MjQzNzE2NGJmMjhmMTlkMTY1ZmFkMTc3MjZmNGEzMmNjYyAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVXNlckFnZW50UXVpcmtzLmgKKysrIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vVXNlckFnZW50UXVpcmtzLmgKQEAgLTI1LDYgKzI1LDcgQEAK IAogI3ByYWdtYSBvbmNlCiAKKyNpbmNsdWRlICJVc2VyQWdlbnQuaCIKICNpbmNsdWRlIDx3dGYv QXNzZXJ0aW9ucy5oPgogI2luY2x1ZGUgPHd0Zi90ZXh0L1dURlN0cmluZy5oPgogCkBAIC02Miw3 ICs2Myw3IEBAIHB1YmxpYzoKIAogICAgIGJvb2wgaXNFbXB0eSgpIGNvbnN0IHsgcmV0dXJuICFt X3F1aXJrczsgfQogCi0gICAgc3RhdGljIFVzZXJBZ2VudFF1aXJrcyBxdWlya3NGb3JVUkwoY29u c3QgVVJMJik7CisgICAgc3RhdGljIFVzZXJBZ2VudFF1aXJrcyBxdWlya3NGb3JVUkwoY29uc3Qg VVJMJiwgQ2hhc3Npc1R5cGUpOwogCiAgICAgc3RhdGljIFN0cmluZyBzdHJpbmdGb3JRdWlyayhV c2VyQWdlbnRRdWlyayk7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2ds aWIvVXNlckFnZW50R0xpYi5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9nbGliL1VzZXJB Z2VudEdMaWIuY3BwCmluZGV4IDNlMTZjN2FhZjc5ODEyNWM0ZmY4ZmU3MDc0ZWMyMjc0Mjg3YWRl NzkuLjIzODAxMGU3NzYzY2Y2OGYyN2I5MzUzMDRkODFmYWIyNjgxMjdjNmEgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dsaWIvVXNlckFnZW50R0xpYi5jcHAKKysrIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ2xpYi9Vc2VyQWdlbnRHTGliLmNwcApAQCAtMzEsMTIgKzMx LDE2IEBACiAjaW5jbHVkZSAiVXNlckFnZW50UXVpcmtzLmgiCiAjaW5jbHVkZSA8d3RmL05ldmVy RGVzdHJveWVkLmg+CiAjaW5jbHVkZSA8d3RmL1VSTC5oPgorI2luY2x1ZGUgPHd0Zi9nbGliL0dS ZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYvZ2xpYi9HVW5pcXVlUHRyLmg+CiAjaW5jbHVkZSA8d3Rm L3RleHQvU3RyaW5nQnVpbGRlci5oPgogCiAjaWYgT1MoVU5JWCkKICNpbmNsdWRlIDxzeXMvdXRz bmFtZS5oPgogI2VuZGlmCiAKKyNpbmNsdWRlIDxnaW8vZ2lvLmg+CisKIC8vIFdBUk5JTkchIFdB Uk5JTkchIFdBUk5JTkchCiAvLwogLy8gVGhlIHVzZXIgYWdlbnQgaXMgbHVkaWNyb3VzbHkgZnJh Z2lsZS4gVGhlIG1vc3QgaW5ub2NlbnQgY2hhbmdlIGNhbgpAQCAtNDUsMTEgKzQ5LDY2IEBACiAK IG5hbWVzcGFjZSBXZWJDb3JlIHsKIAorc3RhdGljIENoYXNzaXNUeXBlIGdldENoYXNzaXNUeXBl KCkKK3sKKyAgICBzdGF0aWMgQ2hhc3Npc1R5cGUgY2hhc3Npc1R5cGUgPSBDaGFzc2lzVHlwZTo6 VW5rbm93bjsKKyAgICBzdGF0aWMgYm9vbCBmaXJzdFJ1biA9IHRydWU7CisKKyAgICBXVEZMb2dB bHdheXMoIiVzKCk6IEVOVEVSXG4iLCBfX0ZVTkNUSU9OX18pOworICAgIGlmIChmaXJzdFJ1bikg eworICAgICAgICBHVW5pcXVlT3V0UHRyPEdFcnJvcj4gZXJyb3I7CisgICAgICAgIEdSZWZQdHI8 R0RCdXNDb25uZWN0aW9uPiBjb25uZWN0aW9uID0gZ19idXNfZ2V0X3N5bmMoR19CVVNfVFlQRV9T WVNURU0sIE5VTEwsICZlcnJvci5vdXRQdHIoKSk7CisgICAgICAgIGlmICghY29ubmVjdGlvbikg eworICAgICAgICAgICAgZ193YXJuaW5nKCJDb3VsZCBub3QgY29ubmVjdCB0byBzeXN0ZW0gYnVz OiAlcyIsIGVycm9yLT5tZXNzYWdlKTsKKyAgICAgICAgICAgIFdURkxvZ0Fsd2F5cygiJXMoKTog RVhJVCAxICVzXG4iLCBfX0ZVTkNUSU9OX18sIGVycm9yLT5tZXNzYWdlKTsKKyAgICAgICAgICAg IGZpcnN0UnVuID0gZmFsc2U7CisgICAgICAgICAgICByZXR1cm4gQ2hhc3Npc1R5cGU6OlVua25v d247CisgICAgICAgIH0KKworICAgICAgICBHUmVmUHRyPEdWYXJpYW50PiByZXR1cm5WYXJpYW50 ID0gYWRvcHRHUmVmKGdfZGJ1c19jb25uZWN0aW9uX2NhbGxfc3luYyhjb25uZWN0aW9uLmdldCgp LAorICAgICAgICAgICAgIm9yZy5mcmVlZGVza3RvcC5ob3N0bmFtZTEiLAorICAgICAgICAgICAg Ii9vcmcvZnJlZWRlc2t0b3AvaG9zdG5hbWUxIiwKKyAgICAgICAgICAgICJvcmcuZnJlZWRlc2t0 b3AuREJ1cy5Qcm9wZXJ0aWVzIiwKKyAgICAgICAgICAgICJHZXQiLAorICAgICAgICAgICAgZ192 YXJpYW50X25ldygiKHNzKSIsICJvcmcuZnJlZWRlc2t0b3AuaG9zdG5hbWUxIiwgIkNoYXNzaXMi KSwKKyAgICAgICAgICAgIG51bGxwdHIsCisgICAgICAgICAgICBHX0RCVVNfQ0FMTF9GTEFHU19O T05FLAorICAgICAgICAgICAgLTEsCisgICAgICAgICAgICBudWxscHRyLAorICAgICAgICAgICAg JmVycm9yLm91dFB0cigpKSk7CisKKyAgICAgICAgaWYgKCFyZXR1cm5WYXJpYW50KSB7CisgICAg ICAgICAgICBXVEZMb2dBbHdheXMoIiVzKCk6IEVYSVQgMlxuIiwgX19GVU5DVElPTl9fKTsKKyAg ICAgICAgICAgIGZpcnN0UnVuID0gZmFsc2U7CisgICAgICAgICAgICByZXR1cm4gQ2hhc3Npc1R5 cGU6OlVua25vd247CisgICAgICAgIH0KKworICAgICAgICBHUmVmUHRyPEdWYXJpYW50PiB2YXJp YW50OworICAgICAgICBnX3ZhcmlhbnRfZ2V0KHJldHVyblZhcmlhbnQuZ2V0KCksICIodikiLCAm dmFyaWFudC5vdXRQdHIoKSk7CisgICAgICAgIGNvbnN0IGNoYXIqIGNoYXNzaXMgPSBnX3Zhcmlh bnRfZ2V0X3N0cmluZyh2YXJpYW50LmdldCgpLCBudWxscHRyKTsKKyAgICAgICAgV1RGTG9nQWx3 YXlzKCIlcygpOiBFWElUICglcylcbiIsIF9fRlVOQ1RJT05fXywgY2hhc3Npcyk7CisKKyAgICAg ICAgLy8gQ2hhc3NpcyBjb252ZXJ0aWJsZSBpcyBqdXN0IGZvciB0ZXN0aW5nIGF0IHRoZSBtb21l bnQuCisgICAgICAgIGlmICghc3RyY21wKGNoYXNzaXMsICJoYW5kc2V0IikgfHwgIXN0cmNtcChj aGFzc2lzLCAiY29udmVydGlibGUiKSkKKyAgICAgICAgICAgIGNoYXNzaXNUeXBlID0gQ2hhc3Np c1R5cGU6Ok1vYmlsZTsKKyAgICAgICAgZWxzZQorICAgICAgICAgICAgY2hhc3Npc1R5cGUgPSBD aGFzc2lzVHlwZTo6RGVza3RvcDsKKworICAgICAgICBmaXJzdFJ1biA9IGZhbHNlOworICAgIH0K KworICAgIFdURkxvZ0Fsd2F5cygiJXMoKTogKCVkKVxuIiwgX19GVU5DVElPTl9fLCBjaGFzc2lz VHlwZSk7CisKKyAgICByZXR1cm4gY2hhc3Npc1R5cGU7Cit9CisKIHN0YXRpYyBjb25zdCBjaGFy KiBwbGF0Zm9ybUZvclVBU3RyaW5nKCkKIHsKICNpZiBPUyhNQUNfT1NfWCkKICAgICByZXR1cm4g Ik1hY2ludG9zaCI7CiAjZWxzZQorICAgIGlmIChnZXRDaGFzc2lzVHlwZSgpID09IENoYXNzaXNU eXBlOjpNb2JpbGUpCisgICAgICAgIHJldHVybiAiTGludXgiOwogICAgIHJldHVybiAiWDExIjsK ICNlbmRpZgogfQpAQCAtNTcsNiArMTE2LDkgQEAgc3RhdGljIGNvbnN0IGNoYXIqIHBsYXRmb3Jt Rm9yVUFTdHJpbmcoKQogc3RhdGljIGNvbnN0IFN0cmluZyBwbGF0Zm9ybVZlcnNpb25Gb3JVQVN0 cmluZygpCiB7CiAjaWYgT1MoVU5JWCkKKyAgICBpZiAoZ2V0Q2hhc3Npc1R5cGUoKSA9PSBDaGFz c2lzVHlwZTo6TW9iaWxlKQorICAgICAgICByZXR1cm4gImxpa2UgQW5kcm9pZCA0LjQiOworCiAg ICAgc3RydWN0IHV0c25hbWUgbmFtZTsKICAgICB1bmFtZSgmbmFtZSk7CiAgICAgc3RhdGljIE5l dmVyRGVzdHJveWVkPGNvbnN0IFN0cmluZz4gdWFPU1ZlcnNpb24obWFrZVN0cmluZyhuYW1lLnN5 c25hbWUsICcgJywgbmFtZS5tYWNoaW5lKSk7CkBAIC03OSw2ICsxNDEsNyBAQCBzdGF0aWMgaW5s aW5lIGNvbnN0IGNoYXIqIHZlcnNpb25Gb3JVQVN0cmluZygpCiBzdGF0aWMgU3RyaW5nIGJ1aWxk VXNlckFnZW50U3RyaW5nKGNvbnN0IFVzZXJBZ2VudFF1aXJrcyYgcXVpcmtzKQogewogICAgIFN0 cmluZ0J1aWxkZXIgdWFTdHJpbmc7CisKICAgICB1YVN0cmluZy5hcHBlbmRMaXRlcmFsKCJNb3pp bGxhLzUuMCAiKTsKICAgICB1YVN0cmluZy5hcHBlbmQoJygnKTsKIApAQCAtMTEzLDYgKzE3Niwx MCBAQCBzdGF0aWMgU3RyaW5nIGJ1aWxkVXNlckFnZW50U3RyaW5nKGNvbnN0IFVzZXJBZ2VudFF1 aXJrcyYgcXVpcmtzKQogICAgIC8vIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0xMzM0MDMgZm9yIGRldGFpbHMuCiAgICAgfSBlbHNlCiAgICAgICAgIHVhU3RyaW5nLmFw cGVuZExpdGVyYWwoIlZlcnNpb24vMTMuMCAiKTsKKworICAgIGlmIChnZXRDaGFzc2lzVHlwZSgp ID09IENoYXNzaXNUeXBlOjpNb2JpbGUpCisgICAgICAgIHVhU3RyaW5nLmFwcGVuZExpdGVyYWwo Ik1vYmlsZSAiKTsKKwogICAgIHVhU3RyaW5nLmFwcGVuZExpdGVyYWwoIlNhZmFyaS8iKTsKICAg ICB1YVN0cmluZy5hcHBlbmQodmVyc2lvbkZvclVBU3RyaW5nKCkpOwogCkBAIC0xMzcsNiArMjA0 LDcgQEAgU3RyaW5nIHN0YW5kYXJkVXNlckFnZW50KGNvbnN0IFN0cmluZyYgYXBwbGljYXRpb25O YW1lLCBjb25zdCBTdHJpbmcmIGFwcGxpY2F0aW8KICAgICAvLyBzaXRlcyB3b24ndCBsb2FkIHJl c291cmNlcyBhdCBhbGwuCiAKICAgICBTdHJpbmcgdXNlckFnZW50OworCiAgICAgaWYgKGFwcGxp Y2F0aW9uTmFtZS5pc0VtcHR5KCkpIHsKICAgICAgICAgdXNlckFnZW50ID0gc3RhbmRhcmRVc2Vy QWdlbnRTdGF0aWMoKTsKICAgICB9IGVsc2UgewpAQCAtMTU5LDcgKzIyNyw3IEBAIFN0cmluZyBz dGFuZGFyZFVzZXJBZ2VudChjb25zdCBTdHJpbmcmIGFwcGxpY2F0aW9uTmFtZSwgY29uc3QgU3Ry aW5nJiBhcHBsaWNhdGlvCiAKIFN0cmluZyBzdGFuZGFyZFVzZXJBZ2VudEZvclVSTChjb25zdCBV UkwmIHVybCkKIHsKLSAgICBhdXRvIHF1aXJrcyA9IFVzZXJBZ2VudFF1aXJrczo6cXVpcmtzRm9y VVJMKHVybCk7CisgICAgYXV0byBxdWlya3MgPSBVc2VyQWdlbnRRdWlya3M6OnF1aXJrc0ZvclVS TCh1cmwsIGdldENoYXNzaXNUeXBlKCkpOwogICAgIC8vIFRoZSBudWxsIHN0cmluZyBtZWFucyB3 ZSBkb24ndCBuZWVkIGEgc3BlY2lmaWMgVUEgZm9yIHRoZSBnaXZlbiBVUkwuCiAgICAgaWYgKHF1 aXJrcy5pc0VtcHR5KCkpCiAgICAgICAgIHJldHVybiBTdHJpbmcoKTsK 403177 2020-06-29 23:49:46 -0700 2020-06-30 07:58:02 -0700 Patch bug-149496-20200630084944.patch text/plain 8962 jan.brummer U3VidmVyc2lvbiBSZXZpc2lvbjogMjYzNjYzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggODc2MWFiMDQyYzc3MjNl M2ZiYTJmN2RlMmZmZTVjM2JjZmY3ZjU3Ni4uODNjZGJmYzU2NTZjZWExYTI2NDUyYTBmYjBlMjFj MDMyZGFiM2Y0NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI1IEBACisyMDIwLTA2LTI5ICBKYW4t TWljaGFlbCBCcnVtbWVyICA8amFuLmJydW1tZXJAdGFib3Mub3JnPgorCisgICAgICAgIFtHVEtd IFVzZSBtb2JpbGUgdXNlci1hZ2VudCBvbiB0YWJsZXQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE0OTQ5NgorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIE5vIG5ldyB0ZXN0cyAoT09QUyEpLgorCisgICAgICAg ICogcGxhdGZvcm0vVXNlckFnZW50UXVpcmtzLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OnVybFJl cXVpcmVzTWFjaW50b3NoUGxhdGZvcm0pOgorICAgICAgICAoV2ViQ29yZTo6dXJsUmVxdWlyZXNM aW51eERlc2t0b3BQbGF0Zm9ybSk6CisgICAgICAgIChXZWJDb3JlOjpVc2VyQWdlbnRRdWlya3M6 OnF1aXJrc0ZvclVSTCk6CisgICAgICAgICogcGxhdGZvcm0vVXNlckFnZW50UXVpcmtzLmg6Cisg ICAgICAgICogcGxhdGZvcm0vZ2xpYi9Vc2VyQWdlbnRHTGliLmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OmdldENoYXNzaXNUeXBlKToKKyAgICAgICAgKFdlYkNvcmU6OnBsYXRmb3JtRm9yVUFTdHJp bmcpOgorICAgICAgICAoV2ViQ29yZTo6cGxhdGZvcm1WZXJzaW9uRm9yVUFTdHJpbmcpOgorICAg ICAgICAoV2ViQ29yZTo6YnVpbGRVc2VyQWdlbnRTdHJpbmcpOgorICAgICAgICAoV2ViQ29yZTo6 c3RhbmRhcmRVc2VyQWdlbnQpOgorICAgICAgICAoV2ViQ29yZTo6c3RhbmRhcmRVc2VyQWdlbnRG b3JVUkwpOgorCiAyMDIwLTA2LTI5ICBDaHJpcyBEdW1leiAgPGNkdW1lekBhcHBsZS5jb20+CiAK ICAgICAgICAgT24gbG9hZCBmcm9tIGJhY2svZm9yd2FyZCBjYWNoZSwgY2FsbCBjaGVja0NvbXBs ZXRlZCgpIGZvciBBTEwgZnJhbWVzIGluc2lkZSBGcmFtZUxvYWRlcjo6Y29tbWl0UHJvdmlzaW9u YWxMb2FkKCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1VzZXJBZ2VudC5o IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVXNlckFnZW50LmgKaW5kZXggZWJjZGIxZGQwODEy NGZiZWJmNTM2ODdjMjk4YTg3ZjFlYTY1MWE0NS4uZTAxYzgxM2U0ZDZlNzA3NTJhM2MwZWMzNTg0 NjgzZDA3YTUyNDZmMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVXNlckFn ZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVXNlckFnZW50LmgKQEAgLTM4LDYg KzM4LDExIEBAIFdFQkNPUkVfRVhQT1JUIFN0cmluZyBvc05hbWVGb3JVc2VyQWdlbnQoKTsKIFdF QkNPUkVfRVhQT1JUIFN0cmluZyBzeXN0ZW1NYXJrZXRpbmdWZXJzaW9uRm9yVXNlckFnZW50U3Ry aW5nKCk7CiAjZWxzZQogCitlbnVtIGNsYXNzIENoYXNzaXNUeXBlIHsKKyAgICBVbmtub3duLAor ICAgIERlc2t0b3AsCisgICAgTW9iaWxlCit9OwogV0VCQ09SRV9FWFBPUlQgU3RyaW5nIHN0YW5k YXJkVXNlckFnZW50KGNvbnN0IFN0cmluZyYgYXBwbGljYXRpb25OYW1lID0gZW1wdHlTdHJpbmco KSwgY29uc3QgU3RyaW5nJiBhcHBsaWNhdGlvblZlcnNpb24gPSBlbXB0eVN0cmluZygpKTsKIFdF QkNPUkVfRVhQT1JUIFN0cmluZyBzdGFuZGFyZFVzZXJBZ2VudEZvclVSTChjb25zdCBVUkwmKTsK ICNlbmRpZgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVXNlckFnZW50UXVp cmtzLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1VzZXJBZ2VudFF1aXJrcy5jcHAKaW5k ZXggNGFiZGI4NmI3ZDc5ZDU4OWMwMThhN2UyYjEwNGU0NTllY2FmZWQ0My4uMmVjNzYwN2Q0OTNk MmNkM2VjODk4MjdlNjllZWM2ZDY1NzE2NWZmMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vVXNlckFnZW50UXVpcmtzLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9Vc2VyQWdlbnRRdWlya3MuY3BwCkBAIC0xMTMsMTcgKzExMywxNyBAQCBzdGF0aWMgYm9vbCB1 cmxSZXF1aXJlc0ZpcmVmb3hCcm93c2VyKGNvbnN0IFVSTCYgdXJsKQogICAgIHJldHVybiBmYWxz ZTsKIH0KIAotc3RhdGljIGJvb2wgdXJsUmVxdWlyZXNNYWNpbnRvc2hQbGF0Zm9ybShjb25zdCBV UkwmIHVybCkKK3N0YXRpYyBib29sIHVybFJlcXVpcmVzTWFjaW50b3NoUGxhdGZvcm0oY29uc3Qg VVJMJiB1cmwsIENoYXNzaXNUeXBlIGNoYXNzaXNUeXBlKQogewogICAgIFN0cmluZyBkb21haW4g PSB1cmwuaG9zdCgpLnRvU3RyaW5nKCk7CiAgICAgU3RyaW5nIGJhc2VEb21haW4gPSB0b3BQcml2 YXRlbHlDb250cm9sbGVkRG9tYWluKGRvbWFpbik7CiAKICAgICAvLyBBdCBsZWFzdCBmaW5hbmNl LnlhaG9vLmNvbSBkaXNwbGF5cyBhIG1vYmlsZSB2ZXJzaW9uIHdpdGggV2ViS2l0R1RLJ3Mgc3Rh bmRhcmQgdXNlciBhZ2VudC4KLSAgICBpZiAoYmFzZURvbWFpbiA9PSAieWFob28uY29tIikKKyAg ICBpZiAoY2hhc3Npc1R5cGUgIT0gQ2hhc3Npc1R5cGU6Ok1vYmlsZSAmJiBiYXNlRG9tYWluID09 ICJ5YWhvby5jb20iKQogICAgICAgICByZXR1cm4gdHJ1ZTsKIAogICAgIC8vIHRhb2Jhby5jb20g ZGlzcGxheXMgYSBtb2JpbGUgdmVyc2lvbiB3aXRoIFdlYktpdEdUSydzIHN0YW5kYXJkIHVzZXIg YWdlbnQuCi0gICAgaWYgKGJhc2VEb21haW4gPT0gInRhb2Jhby5jb20iKQorICAgIGlmIChjaGFz c2lzVHlwZSAhPSBDaGFzc2lzVHlwZTo6TW9iaWxlICYmIGJhc2VEb21haW4gPT0gInRhb2Jhby5j b20iKQogICAgICAgICByZXR1cm4gdHJ1ZTsKIAogICAgIC8vIHdlYi53aGF0c2FwcC5jb20gY29t cGxldGVseSBibG9ja3MgdXNlcnMgd2l0aCBXZWJLaXRHVEsncyBzdGFuZGFyZCB1c2VyIGFnZW50 LgpAQCAtMTUwLDEyICsxNTAsMTUgQEAgc3RhdGljIGJvb2wgdXJsUmVxdWlyZXNNYWNpbnRvc2hQ bGF0Zm9ybShjb25zdCBVUkwmIHVybCkKICAgICByZXR1cm4gZmFsc2U7CiB9CiAKLXN0YXRpYyBi b29sIHVybFJlcXVpcmVzTGludXhEZXNrdG9wUGxhdGZvcm0oY29uc3QgVVJMJiB1cmwpCitzdGF0 aWMgYm9vbCB1cmxSZXF1aXJlc0xpbnV4RGVza3RvcFBsYXRmb3JtKGNvbnN0IFVSTCYgdXJsLCBD aGFzc2lzVHlwZSBjaGFzc2lzVHlwZSkKIHsKLSAgICByZXR1cm4gaXNHb29nbGUodXJsKTsKKyAg ICBib29sIHJldCA9IGlzR29vZ2xlKHVybCkgJiYgY2hhc3Npc1R5cGUgIT0gQ2hhc3Npc1R5cGU6 Ok1vYmlsZTsKKworICAgIFdURkxvZ0Fsd2F5cygiJXM6ICVkLCAlZFxuIiwgdXJsLmhvc3QoKS50 b1N0cmluZygpLnV0ZjgoKS5kYXRhKCksIHJldCwgY2hhc3Npc1R5cGUpOworICAgIHJldHVybiBy ZXQ7CiB9CiAKLVVzZXJBZ2VudFF1aXJrcyBVc2VyQWdlbnRRdWlya3M6OnF1aXJrc0ZvclVSTChj b25zdCBVUkwmIHVybCkKK1VzZXJBZ2VudFF1aXJrcyBVc2VyQWdlbnRRdWlya3M6OnF1aXJrc0Zv clVSTChjb25zdCBVUkwmIHVybCwgQ2hhc3Npc1R5cGUgY2hhc3Npc1R5cGUpCiB7CiAgICAgQVNT RVJUKCF1cmwuaXNOdWxsKCkpOwogCkBAIC0xNjYsOSArMTY5LDkgQEAgVXNlckFnZW50UXVpcmtz IFVzZXJBZ2VudFF1aXJrczo6cXVpcmtzRm9yVVJMKGNvbnN0IFVSTCYgdXJsKQogICAgIGVsc2Ug aWYgKHVybFJlcXVpcmVzRmlyZWZveEJyb3dzZXIodXJsKSkKICAgICAgICAgcXVpcmtzLmFkZChV c2VyQWdlbnRRdWlya3M6Ok5lZWRzRmlyZWZveEJyb3dzZXIpOwogCi0gICAgaWYgKHVybFJlcXVp cmVzTWFjaW50b3NoUGxhdGZvcm0odXJsKSkKKyAgICBpZiAodXJsUmVxdWlyZXNNYWNpbnRvc2hQ bGF0Zm9ybSh1cmwsIGNoYXNzaXNUeXBlKSkKICAgICAgICAgcXVpcmtzLmFkZChVc2VyQWdlbnRR dWlya3M6Ok5lZWRzTWFjaW50b3NoUGxhdGZvcm0pOwotICAgIGVsc2UgaWYgKHVybFJlcXVpcmVz TGludXhEZXNrdG9wUGxhdGZvcm0odXJsKSkKKyAgICBlbHNlIGlmICh1cmxSZXF1aXJlc0xpbnV4 RGVza3RvcFBsYXRmb3JtKHVybCwgY2hhc3Npc1R5cGUpKQogICAgICAgICBxdWlya3MuYWRkKFVz ZXJBZ2VudFF1aXJrczo6TmVlZHNMaW51eERlc2t0b3BQbGF0Zm9ybSk7CiAKICAgICByZXR1cm4g cXVpcmtzOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVXNlckFnZW50UXVp cmtzLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9Vc2VyQWdlbnRRdWlya3MuaAppbmRleCA5 ODJmODdmOGMxYzRhYjkwYzdjZmMwY2M4NmY1YzRiZmUzNmZhZWYzLi5mM2JhNDUyNDM3MTY0YmYy OGYxOWQxNjVmYWQxNzcyNmY0YTMyY2NjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9Vc2VyQWdlbnRRdWlya3MuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9Vc2Vy QWdlbnRRdWlya3MuaApAQCAtMjUsNiArMjUsNyBAQAogCiAjcHJhZ21hIG9uY2UKIAorI2luY2x1 ZGUgIlVzZXJBZ2VudC5oIgogI2luY2x1ZGUgPHd0Zi9Bc3NlcnRpb25zLmg+CiAjaW5jbHVkZSA8 d3RmL3RleHQvV1RGU3RyaW5nLmg+CiAKQEAgLTYyLDcgKzYzLDcgQEAgcHVibGljOgogCiAgICAg Ym9vbCBpc0VtcHR5KCkgY29uc3QgeyByZXR1cm4gIW1fcXVpcmtzOyB9CiAKLSAgICBzdGF0aWMg VXNlckFnZW50UXVpcmtzIHF1aXJrc0ZvclVSTChjb25zdCBVUkwmKTsKKyAgICBzdGF0aWMgVXNl ckFnZW50UXVpcmtzIHF1aXJrc0ZvclVSTChjb25zdCBVUkwmLCBDaGFzc2lzVHlwZSk7CiAKICAg ICBzdGF0aWMgU3RyaW5nIHN0cmluZ0ZvclF1aXJrKFVzZXJBZ2VudFF1aXJrKTsKIApkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ2xpYi9Vc2VyQWdlbnRHTGliLmNwcCBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dsaWIvVXNlckFnZW50R0xpYi5jcHAKaW5kZXggM2UxNmM3 YWFmNzk4MTI1YzRmZjhmZTcwNzRlYzIyNzQyODdhZGU3OS4uMTcwMmM2YWYxNmIxMDY2NzIzYzkx OGI3ZWY0YWU0ZTg1NjUwZDdiMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z2xpYi9Vc2VyQWdlbnRHTGliLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9nbGli L1VzZXJBZ2VudEdMaWIuY3BwCkBAIC0zMSwxMiArMzEsMTYgQEAKICNpbmNsdWRlICJVc2VyQWdl bnRRdWlya3MuaCIKICNpbmNsdWRlIDx3dGYvTmV2ZXJEZXN0cm95ZWQuaD4KICNpbmNsdWRlIDx3 dGYvVVJMLmg+CisjaW5jbHVkZSA8d3RmL2dsaWIvR1JlZlB0ci5oPgorI2luY2x1ZGUgPHd0Zi9n bGliL0dVbmlxdWVQdHIuaD4KICNpbmNsdWRlIDx3dGYvdGV4dC9TdHJpbmdCdWlsZGVyLmg+CiAK ICNpZiBPUyhVTklYKQogI2luY2x1ZGUgPHN5cy91dHNuYW1lLmg+CiAjZW5kaWYKIAorI2luY2x1 ZGUgPGdpby9naW8uaD4KKwogLy8gV0FSTklORyEgV0FSTklORyEgV0FSTklORyEKIC8vCiAvLyBU aGUgdXNlciBhZ2VudCBpcyBsdWRpY3JvdXNseSBmcmFnaWxlLiBUaGUgbW9zdCBpbm5vY2VudCBj aGFuZ2UgY2FuCkBAIC00NSwxMSArNDksNjYgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCitz dGF0aWMgQ2hhc3Npc1R5cGUgZ2V0Q2hhc3Npc1R5cGUoKQoreworICAgIHN0YXRpYyBDaGFzc2lz VHlwZSBjaGFzc2lzVHlwZSA9IENoYXNzaXNUeXBlOjpVbmtub3duOworICAgIHN0YXRpYyBib29s IGZpcnN0UnVuID0gdHJ1ZTsKKworICAgIFdURkxvZ0Fsd2F5cygiJXMoKTogRU5URVJcbiIsIF9f RlVOQ1RJT05fXyk7CisgICAgaWYgKGZpcnN0UnVuKSB7CisgICAgICAgIEdVbmlxdWVPdXRQdHI8 R0Vycm9yPiBlcnJvcjsKKyAgICAgICAgR1JlZlB0cjxHREJ1c0Nvbm5lY3Rpb24+IGNvbm5lY3Rp b24gPSBnX2J1c19nZXRfc3luYyhHX0JVU19UWVBFX1NZU1RFTSwgTlVMTCwgJmVycm9yLm91dFB0 cigpKTsKKyAgICAgICAgaWYgKCFjb25uZWN0aW9uKSB7CisgICAgICAgICAgICBnX3dhcm5pbmco IkNvdWxkIG5vdCBjb25uZWN0IHRvIHN5c3RlbSBidXM6ICVzIiwgZXJyb3ItPm1lc3NhZ2UpOwor ICAgICAgICAgICAgV1RGTG9nQWx3YXlzKCIlcygpOiBFWElUIDEgJXNcbiIsIF9fRlVOQ1RJT05f XywgZXJyb3ItPm1lc3NhZ2UpOworICAgICAgICAgICAgZmlyc3RSdW4gPSBmYWxzZTsKKyAgICAg ICAgICAgIHJldHVybiBDaGFzc2lzVHlwZTo6VW5rbm93bjsKKyAgICAgICAgfQorCisgICAgICAg IEdSZWZQdHI8R1ZhcmlhbnQ+IHJldHVyblZhcmlhbnQgPSBhZG9wdEdSZWYoZ19kYnVzX2Nvbm5l Y3Rpb25fY2FsbF9zeW5jKGNvbm5lY3Rpb24uZ2V0KCksCisgICAgICAgICAgICAib3JnLmZyZWVk ZXNrdG9wLmhvc3RuYW1lMSIsCisgICAgICAgICAgICAiL29yZy9mcmVlZGVza3RvcC9ob3N0bmFt ZTEiLAorICAgICAgICAgICAgIm9yZy5mcmVlZGVza3RvcC5EQnVzLlByb3BlcnRpZXMiLAorICAg ICAgICAgICAgIkdldCIsCisgICAgICAgICAgICBnX3ZhcmlhbnRfbmV3KCIoc3MpIiwgIm9yZy5m cmVlZGVza3RvcC5ob3N0bmFtZTEiLCAiQ2hhc3NpcyIpLAorICAgICAgICAgICAgbnVsbHB0ciwK KyAgICAgICAgICAgIEdfREJVU19DQUxMX0ZMQUdTX05PTkUsCisgICAgICAgICAgICAtMSwKKyAg ICAgICAgICAgIG51bGxwdHIsCisgICAgICAgICAgICAmZXJyb3Iub3V0UHRyKCkpKTsKKworICAg ICAgICBpZiAoIXJldHVyblZhcmlhbnQpIHsKKyAgICAgICAgICAgIFdURkxvZ0Fsd2F5cygiJXMo KTogRVhJVCAyXG4iLCBfX0ZVTkNUSU9OX18pOworICAgICAgICAgICAgZmlyc3RSdW4gPSBmYWxz ZTsKKyAgICAgICAgICAgIHJldHVybiBDaGFzc2lzVHlwZTo6VW5rbm93bjsKKyAgICAgICAgfQor CisgICAgICAgIEdSZWZQdHI8R1ZhcmlhbnQ+IHZhcmlhbnQ7CisgICAgICAgIGdfdmFyaWFudF9n ZXQocmV0dXJuVmFyaWFudC5nZXQoKSwgIih2KSIsICZ2YXJpYW50Lm91dFB0cigpKTsKKyAgICAg ICAgY29uc3QgY2hhciogY2hhc3NpcyA9IGdfdmFyaWFudF9nZXRfc3RyaW5nKHZhcmlhbnQuZ2V0 KCksIG51bGxwdHIpOworICAgICAgICBXVEZMb2dBbHdheXMoIiVzKCk6IEVYSVQgKCVzKVxuIiwg X19GVU5DVElPTl9fLCBjaGFzc2lzKTsKKworICAgICAgICAvLyBDaGFzc2lzIGNvbnZlcnRpYmxl IGlzIGp1c3QgZm9yIHRlc3RpbmcgYXQgdGhlIG1vbWVudC4KKyAgICAgICAgaWYgKCFzdHJjbXAo Y2hhc3NpcywgImhhbmRzZXQiKSB8fCAhc3RyY21wKGNoYXNzaXMsICJjb252ZXJ0aWJsZSIpKQor ICAgICAgICAgICAgY2hhc3Npc1R5cGUgPSBDaGFzc2lzVHlwZTo6TW9iaWxlOworICAgICAgICBl bHNlCisgICAgICAgICAgICBjaGFzc2lzVHlwZSA9IENoYXNzaXNUeXBlOjpEZXNrdG9wOworCisg ICAgICAgIGZpcnN0UnVuID0gZmFsc2U7CisgICAgfQorCisgICAgV1RGTG9nQWx3YXlzKCIlcygp OiAoJWQpXG4iLCBfX0ZVTkNUSU9OX18sIGNoYXNzaXNUeXBlKTsKKworICAgIHJldHVybiBjaGFz c2lzVHlwZTsKK30KKwogc3RhdGljIGNvbnN0IGNoYXIqIHBsYXRmb3JtRm9yVUFTdHJpbmcoKQog ewogI2lmIE9TKE1BQ19PU19YKQogICAgIHJldHVybiAiTWFjaW50b3NoIjsKICNlbHNlCisgICAg aWYgKGdldENoYXNzaXNUeXBlKCkgPT0gQ2hhc3Npc1R5cGU6Ok1vYmlsZSkKKyAgICAgICAgcmV0 dXJuICJMaW51eCI7CiAgICAgcmV0dXJuICJYMTEiOwogI2VuZGlmCiB9CkBAIC01Nyw2ICsxMTYs OCBAQCBzdGF0aWMgY29uc3QgY2hhciogcGxhdGZvcm1Gb3JVQVN0cmluZygpCiBzdGF0aWMgY29u c3QgU3RyaW5nIHBsYXRmb3JtVmVyc2lvbkZvclVBU3RyaW5nKCkKIHsKICNpZiBPUyhVTklYKQor ICAgIGlmIChnZXRDaGFzc2lzVHlwZSgpID09IENoYXNzaXNUeXBlOjpNb2JpbGUpCisgICAgICAg IHJldHVybiAibGlrZSBBbmRyb2lkIDQuNCI7CiAgICAgc3RydWN0IHV0c25hbWUgbmFtZTsKICAg ICB1bmFtZSgmbmFtZSk7CiAgICAgc3RhdGljIE5ldmVyRGVzdHJveWVkPGNvbnN0IFN0cmluZz4g dWFPU1ZlcnNpb24obWFrZVN0cmluZyhuYW1lLnN5c25hbWUsICcgJywgbmFtZS5tYWNoaW5lKSk7 CkBAIC0xMTMsNiArMTc0LDkgQEAgc3RhdGljIFN0cmluZyBidWlsZFVzZXJBZ2VudFN0cmluZyhj b25zdCBVc2VyQWdlbnRRdWlya3MmIHF1aXJrcykKICAgICAvLyBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTMzNDAzIGZvciBkZXRhaWxzLgogICAgIH0gZWxzZQogICAg ICAgICB1YVN0cmluZy5hcHBlbmRMaXRlcmFsKCJWZXJzaW9uLzEzLjAgIik7CisKKyAgICBpZiAo Z2V0Q2hhc3Npc1R5cGUoKSA9PSBDaGFzc2lzVHlwZTo6TW9iaWxlKQorICAgICAgICB1YVN0cmlu Zy5hcHBlbmRMaXRlcmFsKCJNb2JpbGUgIik7CiAgICAgdWFTdHJpbmcuYXBwZW5kTGl0ZXJhbCgi U2FmYXJpLyIpOwogICAgIHVhU3RyaW5nLmFwcGVuZCh2ZXJzaW9uRm9yVUFTdHJpbmcoKSk7CiAK QEAgLTE1OSw3ICsyMjMsNyBAQCBTdHJpbmcgc3RhbmRhcmRVc2VyQWdlbnQoY29uc3QgU3RyaW5n JiBhcHBsaWNhdGlvbk5hbWUsIGNvbnN0IFN0cmluZyYgYXBwbGljYXRpbwogCiBTdHJpbmcgc3Rh bmRhcmRVc2VyQWdlbnRGb3JVUkwoY29uc3QgVVJMJiB1cmwpCiB7Ci0gICAgYXV0byBxdWlya3Mg PSBVc2VyQWdlbnRRdWlya3M6OnF1aXJrc0ZvclVSTCh1cmwpOworICAgIGF1dG8gcXVpcmtzID0g VXNlckFnZW50UXVpcmtzOjpxdWlya3NGb3JVUkwodXJsLCBnZXRDaGFzc2lzVHlwZSgpKTsKICAg ICAvLyBUaGUgbnVsbCBzdHJpbmcgbWVhbnMgd2UgZG9uJ3QgbmVlZCBhIHNwZWNpZmljIFVBIGZv ciB0aGUgZ2l2ZW4gVVJMLgogICAgIGlmIChxdWlya3MuaXNFbXB0eSgpKQogICAgICAgICByZXR1 cm4gU3RyaW5nKCk7Cg== 403199 2020-06-30 07:58:09 -0700 2020-07-03 14:44:41 -0700 Patch bug-149496-20200630165807.patch text/plain 7618 jan.brummer U3VidmVyc2lvbiBSZXZpc2lvbjogMjYzNjYzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggODc2MWFiMDQyYzc3MjNl M2ZiYTJmN2RlMmZmZTVjM2JjZmY3ZjU3Ni4uODNjZGJmYzU2NTZjZWExYTI2NDUyYTBmYjBlMjFj MDMyZGFiM2Y0NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI1IEBACisyMDIwLTA2LTI5ICBKYW4t TWljaGFlbCBCcnVtbWVyICA8amFuLmJydW1tZXJAdGFib3Mub3JnPgorCisgICAgICAgIFtHVEtd IFVzZSBtb2JpbGUgdXNlci1hZ2VudCBvbiB0YWJsZXQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE0OTQ5NgorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIE5vIG5ldyB0ZXN0cyAoT09QUyEpLgorCisgICAgICAg ICogcGxhdGZvcm0vVXNlckFnZW50UXVpcmtzLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OnVybFJl cXVpcmVzTWFjaW50b3NoUGxhdGZvcm0pOgorICAgICAgICAoV2ViQ29yZTo6dXJsUmVxdWlyZXNM aW51eERlc2t0b3BQbGF0Zm9ybSk6CisgICAgICAgIChXZWJDb3JlOjpVc2VyQWdlbnRRdWlya3M6 OnF1aXJrc0ZvclVSTCk6CisgICAgICAgICogcGxhdGZvcm0vVXNlckFnZW50UXVpcmtzLmg6Cisg ICAgICAgICogcGxhdGZvcm0vZ2xpYi9Vc2VyQWdlbnRHTGliLmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OmdldENoYXNzaXNUeXBlKToKKyAgICAgICAgKFdlYkNvcmU6OnBsYXRmb3JtRm9yVUFTdHJp bmcpOgorICAgICAgICAoV2ViQ29yZTo6cGxhdGZvcm1WZXJzaW9uRm9yVUFTdHJpbmcpOgorICAg ICAgICAoV2ViQ29yZTo6YnVpbGRVc2VyQWdlbnRTdHJpbmcpOgorICAgICAgICAoV2ViQ29yZTo6 c3RhbmRhcmRVc2VyQWdlbnQpOgorICAgICAgICAoV2ViQ29yZTo6c3RhbmRhcmRVc2VyQWdlbnRG b3JVUkwpOgorCiAyMDIwLTA2LTI5ICBDaHJpcyBEdW1leiAgPGNkdW1lekBhcHBsZS5jb20+CiAK ICAgICAgICAgT24gbG9hZCBmcm9tIGJhY2svZm9yd2FyZCBjYWNoZSwgY2FsbCBjaGVja0NvbXBs ZXRlZCgpIGZvciBBTEwgZnJhbWVzIGluc2lkZSBGcmFtZUxvYWRlcjo6Y29tbWl0UHJvdmlzaW9u YWxMb2FkKCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1VzZXJBZ2VudC5o IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVXNlckFnZW50LmgKaW5kZXggZWJjZGIxZGQwODEy NGZiZWJmNTM2ODdjMjk4YTg3ZjFlYTY1MWE0NS4uZTAxYzgxM2U0ZDZlNzA3NTJhM2MwZWMzNTg0 NjgzZDA3YTUyNDZmMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVXNlckFn ZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVXNlckFnZW50LmgKQEAgLTM4LDYg KzM4LDExIEBAIFdFQkNPUkVfRVhQT1JUIFN0cmluZyBvc05hbWVGb3JVc2VyQWdlbnQoKTsKIFdF QkNPUkVfRVhQT1JUIFN0cmluZyBzeXN0ZW1NYXJrZXRpbmdWZXJzaW9uRm9yVXNlckFnZW50U3Ry aW5nKCk7CiAjZWxzZQogCitlbnVtIGNsYXNzIENoYXNzaXNUeXBlIHsKKyAgICBVbmtub3duLAor ICAgIERlc2t0b3AsCisgICAgTW9iaWxlCit9OwogV0VCQ09SRV9FWFBPUlQgU3RyaW5nIHN0YW5k YXJkVXNlckFnZW50KGNvbnN0IFN0cmluZyYgYXBwbGljYXRpb25OYW1lID0gZW1wdHlTdHJpbmco KSwgY29uc3QgU3RyaW5nJiBhcHBsaWNhdGlvblZlcnNpb24gPSBlbXB0eVN0cmluZygpKTsKIFdF QkNPUkVfRVhQT1JUIFN0cmluZyBzdGFuZGFyZFVzZXJBZ2VudEZvclVSTChjb25zdCBVUkwmKTsK ICNlbmRpZgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVXNlckFnZW50UXVp cmtzLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1VzZXJBZ2VudFF1aXJrcy5jcHAKaW5k ZXggNGFiZGI4NmI3ZDc5ZDU4OWMwMThhN2UyYjEwNGU0NTllY2FmZWQ0My4uNGUzY2FlNmZhY2Qz YWFjYjFjNDY4YTZkZDVhOWQ2ZDk3YzI0ZjQwZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vVXNlckFnZW50UXVpcmtzLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9Vc2VyQWdlbnRRdWlya3MuY3BwCkBAIC0xMTMsMTcgKzExMywxNyBAQCBzdGF0aWMgYm9vbCB1 cmxSZXF1aXJlc0ZpcmVmb3hCcm93c2VyKGNvbnN0IFVSTCYgdXJsKQogICAgIHJldHVybiBmYWxz ZTsKIH0KIAotc3RhdGljIGJvb2wgdXJsUmVxdWlyZXNNYWNpbnRvc2hQbGF0Zm9ybShjb25zdCBV UkwmIHVybCkKK3N0YXRpYyBib29sIHVybFJlcXVpcmVzTWFjaW50b3NoUGxhdGZvcm0oY29uc3Qg VVJMJiB1cmwsIENoYXNzaXNUeXBlIGNoYXNzaXNUeXBlKQogewogICAgIFN0cmluZyBkb21haW4g PSB1cmwuaG9zdCgpLnRvU3RyaW5nKCk7CiAgICAgU3RyaW5nIGJhc2VEb21haW4gPSB0b3BQcml2 YXRlbHlDb250cm9sbGVkRG9tYWluKGRvbWFpbik7CiAKICAgICAvLyBBdCBsZWFzdCBmaW5hbmNl LnlhaG9vLmNvbSBkaXNwbGF5cyBhIG1vYmlsZSB2ZXJzaW9uIHdpdGggV2ViS2l0R1RLJ3Mgc3Rh bmRhcmQgdXNlciBhZ2VudC4KLSAgICBpZiAoYmFzZURvbWFpbiA9PSAieWFob28uY29tIikKKyAg ICBpZiAoY2hhc3Npc1R5cGUgIT0gQ2hhc3Npc1R5cGU6Ok1vYmlsZSAmJiBiYXNlRG9tYWluID09 ICJ5YWhvby5jb20iKQogICAgICAgICByZXR1cm4gdHJ1ZTsKIAogICAgIC8vIHRhb2Jhby5jb20g ZGlzcGxheXMgYSBtb2JpbGUgdmVyc2lvbiB3aXRoIFdlYktpdEdUSydzIHN0YW5kYXJkIHVzZXIg YWdlbnQuCi0gICAgaWYgKGJhc2VEb21haW4gPT0gInRhb2Jhby5jb20iKQorICAgIGlmIChjaGFz c2lzVHlwZSAhPSBDaGFzc2lzVHlwZTo6TW9iaWxlICYmIGJhc2VEb21haW4gPT0gInRhb2Jhby5j b20iKQogICAgICAgICByZXR1cm4gdHJ1ZTsKIAogICAgIC8vIHdlYi53aGF0c2FwcC5jb20gY29t cGxldGVseSBibG9ja3MgdXNlcnMgd2l0aCBXZWJLaXRHVEsncyBzdGFuZGFyZCB1c2VyIGFnZW50 LgpAQCAtMTUwLDEyICsxNTAsMTIgQEAgc3RhdGljIGJvb2wgdXJsUmVxdWlyZXNNYWNpbnRvc2hQ bGF0Zm9ybShjb25zdCBVUkwmIHVybCkKICAgICByZXR1cm4gZmFsc2U7CiB9CiAKLXN0YXRpYyBi b29sIHVybFJlcXVpcmVzTGludXhEZXNrdG9wUGxhdGZvcm0oY29uc3QgVVJMJiB1cmwpCitzdGF0 aWMgYm9vbCB1cmxSZXF1aXJlc0xpbnV4RGVza3RvcFBsYXRmb3JtKGNvbnN0IFVSTCYgdXJsLCBD aGFzc2lzVHlwZSBjaGFzc2lzVHlwZSkKIHsKLSAgICByZXR1cm4gaXNHb29nbGUodXJsKTsKKyAg ICByZXR1cm4gaXNHb29nbGUodXJsKSAmJiBjaGFzc2lzVHlwZSA9PSBDaGFzc2lzVHlwZTo6RGVz a3RvcDsKIH0KIAotVXNlckFnZW50UXVpcmtzIFVzZXJBZ2VudFF1aXJrczo6cXVpcmtzRm9yVVJM KGNvbnN0IFVSTCYgdXJsKQorVXNlckFnZW50UXVpcmtzIFVzZXJBZ2VudFF1aXJrczo6cXVpcmtz Rm9yVVJMKGNvbnN0IFVSTCYgdXJsLCBDaGFzc2lzVHlwZSBjaGFzc2lzVHlwZSkKIHsKICAgICBB U1NFUlQoIXVybC5pc051bGwoKSk7CiAKQEAgLTE2Niw5ICsxNjYsOSBAQCBVc2VyQWdlbnRRdWly a3MgVXNlckFnZW50UXVpcmtzOjpxdWlya3NGb3JVUkwoY29uc3QgVVJMJiB1cmwpCiAgICAgZWxz ZSBpZiAodXJsUmVxdWlyZXNGaXJlZm94QnJvd3Nlcih1cmwpKQogICAgICAgICBxdWlya3MuYWRk KFVzZXJBZ2VudFF1aXJrczo6TmVlZHNGaXJlZm94QnJvd3Nlcik7CiAKLSAgICBpZiAodXJsUmVx dWlyZXNNYWNpbnRvc2hQbGF0Zm9ybSh1cmwpKQorICAgIGlmICh1cmxSZXF1aXJlc01hY2ludG9z aFBsYXRmb3JtKHVybCwgY2hhc3Npc1R5cGUpKQogICAgICAgICBxdWlya3MuYWRkKFVzZXJBZ2Vu dFF1aXJrczo6TmVlZHNNYWNpbnRvc2hQbGF0Zm9ybSk7Ci0gICAgZWxzZSBpZiAodXJsUmVxdWly ZXNMaW51eERlc2t0b3BQbGF0Zm9ybSh1cmwpKQorICAgIGVsc2UgaWYgKHVybFJlcXVpcmVzTGlu dXhEZXNrdG9wUGxhdGZvcm0odXJsLCBjaGFzc2lzVHlwZSkpCiAgICAgICAgIHF1aXJrcy5hZGQo VXNlckFnZW50UXVpcmtzOjpOZWVkc0xpbnV4RGVza3RvcFBsYXRmb3JtKTsKIAogICAgIHJldHVy biBxdWlya3M7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9Vc2VyQWdlbnRR dWlya3MuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1VzZXJBZ2VudFF1aXJrcy5oCmluZGV4 IDk4MmY4N2Y4YzFjNGFiOTBjN2NmYzBjYzg2ZjVjNGJmZTM2ZmFlZjMuLmYzYmE0NTI0MzcxNjRi ZjI4ZjE5ZDE2NWZhZDE3NzI2ZjRhMzJjY2MgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL1VzZXJBZ2VudFF1aXJrcy5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Vz ZXJBZ2VudFF1aXJrcy5oCkBAIC0yNSw2ICsyNSw3IEBACiAKICNwcmFnbWEgb25jZQogCisjaW5j bHVkZSAiVXNlckFnZW50LmgiCiAjaW5jbHVkZSA8d3RmL0Fzc2VydGlvbnMuaD4KICNpbmNsdWRl IDx3dGYvdGV4dC9XVEZTdHJpbmcuaD4KIApAQCAtNjIsNyArNjMsNyBAQCBwdWJsaWM6CiAKICAg ICBib29sIGlzRW1wdHkoKSBjb25zdCB7IHJldHVybiAhbV9xdWlya3M7IH0KIAotICAgIHN0YXRp YyBVc2VyQWdlbnRRdWlya3MgcXVpcmtzRm9yVVJMKGNvbnN0IFVSTCYpOworICAgIHN0YXRpYyBV c2VyQWdlbnRRdWlya3MgcXVpcmtzRm9yVVJMKGNvbnN0IFVSTCYsIENoYXNzaXNUeXBlKTsKIAog ICAgIHN0YXRpYyBTdHJpbmcgc3RyaW5nRm9yUXVpcmsoVXNlckFnZW50UXVpcmspOwogCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9nbGliL1VzZXJBZ2VudEdMaWIuY3BwIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ2xpYi9Vc2VyQWdlbnRHTGliLmNwcAppbmRleCAzZTE2 YzdhYWY3OTgxMjVjNGZmOGZlNzA3NGVjMjI3NDI4N2FkZTc5Li5iYTVkMWJlYjU0M2QyOTU4MzU3 OGE1MTMzNDIxM2FiZWY4MTMyZjgwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9nbGliL1VzZXJBZ2VudEdMaWIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2ds aWIvVXNlckFnZW50R0xpYi5jcHAKQEAgLTM3LDYgKzM3LDggQEAKICNpbmNsdWRlIDxzeXMvdXRz bmFtZS5oPgogI2VuZGlmCiAKKyNpbmNsdWRlIDxmc3RyZWFtPgorCiAvLyBXQVJOSU5HISBXQVJO SU5HISBXQVJOSU5HIQogLy8KIC8vIFRoZSB1c2VyIGFnZW50IGlzIGx1ZGljcm91c2x5IGZyYWdp bGUuIFRoZSBtb3N0IGlubm9jZW50IGNoYW5nZSBjYW4KQEAgLTQ1LDExICs0Nyw0MyBAQAogCiBu YW1lc3BhY2UgV2ViQ29yZSB7CiAKK3N0YXRpYyBDaGFzc2lzVHlwZSBnZXRDaGFzc2lzVHlwZSgp Cit7CisgICAgc3RhdGljIENoYXNzaXNUeXBlIGNoYXNzaXNUeXBlID0gQ2hhc3Npc1R5cGU6OkRl c2t0b3A7CisgICAgc3RhdGljIGJvb2wgZmlyc3RSdW4gPSB0cnVlOworCisgICAgaWYgKGZpcnN0 UnVuKSB7CisgICAgICAgIHN0ZDo6aWZzdHJlYW0gaW5mb0ZpbGUoIi9ldGMvbWFjaGluZS1pbmZv Iik7CisgICAgICAgIGlmIChpbmZvRmlsZS5pc19vcGVuKCkpIHsKKyAgICAgICAgICAgIHN0ZDo6 c3RyaW5nIGxpbmU7CisKKyAgICAgICAgICAgIHdoaWxlIChnZXRsaW5lKGluZm9GaWxlLCBsaW5l KSkgeworICAgICAgICAgICAgICAgIGlmIChsaW5lLmVtcHR5KCkpCisgICAgICAgICAgICAgICAg ICAgIGNvbnRpbnVlOworICAgICAgICAgICAgICAgIGF1dG8gZGVsaW1pdGVyUG9zID0gbGluZS5m aW5kKCI9Iik7CisgICAgICAgICAgICAgICAgYXV0byBuYW1lID0gbGluZS5zdWJzdHIoMCwgZGVs aW1pdGVyUG9zKTsKKworICAgICAgICAgICAgICAgIGlmICghbmFtZS5jb21wYXJlKCJDSEFTU0lT IikpIHsKKyAgICAgICAgICAgICAgICAgICAgYXV0byB2YWx1ZSA9IGxpbmUuc3Vic3RyKGRlbGlt aXRlclBvcyArIDEpOworCisgICAgICAgICAgICAgICAgICAgIGlmICghdmFsdWUuY29tcGFyZSgi dGFibGV0IikgfHwgIXZhbHVlLmNvbXBhcmUoImhhbmRzZXQiKSkKKyAgICAgICAgICAgICAgICAg ICAgICAgIGNoYXNzaXNUeXBlID0gQ2hhc3Npc1R5cGU6Ok1vYmlsZTsKKyAgICAgICAgICAgICAg ICB9CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICAgICAgZmlyc3RSdW4gPSBmYWxzZTsK KyAgICB9CisKKyAgICByZXR1cm4gY2hhc3Npc1R5cGU7Cit9CisKIHN0YXRpYyBjb25zdCBjaGFy KiBwbGF0Zm9ybUZvclVBU3RyaW5nKCkKIHsKICNpZiBPUyhNQUNfT1NfWCkKICAgICByZXR1cm4g Ik1hY2ludG9zaCI7CiAjZWxzZQorICAgIGlmIChnZXRDaGFzc2lzVHlwZSgpID09IENoYXNzaXNU eXBlOjpNb2JpbGUpCisgICAgICAgIHJldHVybiAiTGludXgiOwogICAgIHJldHVybiAiWDExIjsK ICNlbmRpZgogfQpAQCAtNTcsNiArOTEsOCBAQCBzdGF0aWMgY29uc3QgY2hhciogcGxhdGZvcm1G b3JVQVN0cmluZygpCiBzdGF0aWMgY29uc3QgU3RyaW5nIHBsYXRmb3JtVmVyc2lvbkZvclVBU3Ry aW5nKCkKIHsKICNpZiBPUyhVTklYKQorICAgIGlmIChnZXRDaGFzc2lzVHlwZSgpID09IENoYXNz aXNUeXBlOjpNb2JpbGUpCisgICAgICAgIHJldHVybiAibGlrZSBBbmRyb2lkIDQuNCI7CiAgICAg c3RydWN0IHV0c25hbWUgbmFtZTsKICAgICB1bmFtZSgmbmFtZSk7CiAgICAgc3RhdGljIE5ldmVy RGVzdHJveWVkPGNvbnN0IFN0cmluZz4gdWFPU1ZlcnNpb24obWFrZVN0cmluZyhuYW1lLnN5c25h bWUsICcgJywgbmFtZS5tYWNoaW5lKSk7CkBAIC0xMTMsNiArMTQ5LDkgQEAgc3RhdGljIFN0cmlu ZyBidWlsZFVzZXJBZ2VudFN0cmluZyhjb25zdCBVc2VyQWdlbnRRdWlya3MmIHF1aXJrcykKICAg ICAvLyBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTMzNDAzIGZvciBk ZXRhaWxzLgogICAgIH0gZWxzZQogICAgICAgICB1YVN0cmluZy5hcHBlbmRMaXRlcmFsKCJWZXJz aW9uLzEzLjAgIik7CisKKyAgICBpZiAoZ2V0Q2hhc3Npc1R5cGUoKSA9PSBDaGFzc2lzVHlwZTo6 TW9iaWxlKQorICAgICAgICB1YVN0cmluZy5hcHBlbmRMaXRlcmFsKCJNb2JpbGUgIik7CiAgICAg dWFTdHJpbmcuYXBwZW5kTGl0ZXJhbCgiU2FmYXJpLyIpOwogICAgIHVhU3RyaW5nLmFwcGVuZCh2 ZXJzaW9uRm9yVUFTdHJpbmcoKSk7CiAKQEAgLTE1OSw3ICsxOTgsNyBAQCBTdHJpbmcgc3RhbmRh cmRVc2VyQWdlbnQoY29uc3QgU3RyaW5nJiBhcHBsaWNhdGlvbk5hbWUsIGNvbnN0IFN0cmluZyYg YXBwbGljYXRpbwogCiBTdHJpbmcgc3RhbmRhcmRVc2VyQWdlbnRGb3JVUkwoY29uc3QgVVJMJiB1 cmwpCiB7Ci0gICAgYXV0byBxdWlya3MgPSBVc2VyQWdlbnRRdWlya3M6OnF1aXJrc0ZvclVSTCh1 cmwpOworICAgIGF1dG8gcXVpcmtzID0gVXNlckFnZW50UXVpcmtzOjpxdWlya3NGb3JVUkwodXJs LCBnZXRDaGFzc2lzVHlwZSgpKTsKICAgICAvLyBUaGUgbnVsbCBzdHJpbmcgbWVhbnMgd2UgZG9u J3QgbmVlZCBhIHNwZWNpZmljIFVBIGZvciB0aGUgZ2l2ZW4gVVJMLgogICAgIGlmIChxdWlya3Mu aXNFbXB0eSgpKQogICAgICAgICByZXR1cm4gU3RyaW5nKCk7Cg== 403492 2020-07-03 14:44:47 -0700 2020-07-04 01:37:47 -0700 Patch bug-149496-20200703234446.patch text/plain 9591 jan.brummer U3VidmVyc2lvbiBSZXZpc2lvbjogMjYzNjYzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggODc2MWFiMDQyYzc3MjNl M2ZiYTJmN2RlMmZmZTVjM2JjZmY3ZjU3Ni4uODNjZGJmYzU2NTZjZWExYTI2NDUyYTBmYjBlMjFj MDMyZGFiM2Y0NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI1IEBACisyMDIwLTA2LTI5ICBKYW4t TWljaGFlbCBCcnVtbWVyICA8amFuLmJydW1tZXJAdGFib3Mub3JnPgorCisgICAgICAgIFtHVEtd IFVzZSBtb2JpbGUgdXNlci1hZ2VudCBvbiB0YWJsZXQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE0OTQ5NgorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIE5vIG5ldyB0ZXN0cyAoT09QUyEpLgorCisgICAgICAg ICogcGxhdGZvcm0vVXNlckFnZW50UXVpcmtzLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OnVybFJl cXVpcmVzTWFjaW50b3NoUGxhdGZvcm0pOgorICAgICAgICAoV2ViQ29yZTo6dXJsUmVxdWlyZXNM aW51eERlc2t0b3BQbGF0Zm9ybSk6CisgICAgICAgIChXZWJDb3JlOjpVc2VyQWdlbnRRdWlya3M6 OnF1aXJrc0ZvclVSTCk6CisgICAgICAgICogcGxhdGZvcm0vVXNlckFnZW50UXVpcmtzLmg6Cisg ICAgICAgICogcGxhdGZvcm0vZ2xpYi9Vc2VyQWdlbnRHTGliLmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OmdldENoYXNzaXNUeXBlKToKKyAgICAgICAgKFdlYkNvcmU6OnBsYXRmb3JtRm9yVUFTdHJp bmcpOgorICAgICAgICAoV2ViQ29yZTo6cGxhdGZvcm1WZXJzaW9uRm9yVUFTdHJpbmcpOgorICAg ICAgICAoV2ViQ29yZTo6YnVpbGRVc2VyQWdlbnRTdHJpbmcpOgorICAgICAgICAoV2ViQ29yZTo6 c3RhbmRhcmRVc2VyQWdlbnQpOgorICAgICAgICAoV2ViQ29yZTo6c3RhbmRhcmRVc2VyQWdlbnRG b3JVUkwpOgorCiAyMDIwLTA2LTI5ICBDaHJpcyBEdW1leiAgPGNkdW1lekBhcHBsZS5jb20+CiAK ICAgICAgICAgT24gbG9hZCBmcm9tIGJhY2svZm9yd2FyZCBjYWNoZSwgY2FsbCBjaGVja0NvbXBs ZXRlZCgpIGZvciBBTEwgZnJhbWVzIGluc2lkZSBGcmFtZUxvYWRlcjo6Y29tbWl0UHJvdmlzaW9u YWxMb2FkKCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1VzZXJBZ2VudC5o IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVXNlckFnZW50LmgKaW5kZXggZWJjZGIxZGQwODEy NGZiZWJmNTM2ODdjMjk4YTg3ZjFlYTY1MWE0NS4uNDBjZWRjODQ4ODY3ZTQ2YmZhMGQ2NDFhYzcx NjVhNmM4YzI0NWVjOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVXNlckFn ZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVXNlckFnZW50LmgKQEAgLTM4LDYg KzM4LDEyIEBAIFdFQkNPUkVfRVhQT1JUIFN0cmluZyBvc05hbWVGb3JVc2VyQWdlbnQoKTsKIFdF QkNPUkVfRVhQT1JUIFN0cmluZyBzeXN0ZW1NYXJrZXRpbmdWZXJzaW9uRm9yVXNlckFnZW50U3Ry aW5nKCk7CiAjZWxzZQogCitlbnVtIGNsYXNzIENoYXNzaXNUeXBlIHsKKyAgICBVbmtub3duLAor ICAgIERlc2t0b3AsCisgICAgTW9iaWxlCit9OworCiBXRUJDT1JFX0VYUE9SVCBTdHJpbmcgc3Rh bmRhcmRVc2VyQWdlbnQoY29uc3QgU3RyaW5nJiBhcHBsaWNhdGlvbk5hbWUgPSBlbXB0eVN0cmlu ZygpLCBjb25zdCBTdHJpbmcmIGFwcGxpY2F0aW9uVmVyc2lvbiA9IGVtcHR5U3RyaW5nKCkpOwog V0VCQ09SRV9FWFBPUlQgU3RyaW5nIHN0YW5kYXJkVXNlckFnZW50Rm9yVVJMKGNvbnN0IFVSTCYp OwogI2VuZGlmCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9Vc2VyQWdlbnRR dWlya3MuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVXNlckFnZW50UXVpcmtzLmNwcApp bmRleCA0YWJkYjg2YjdkNzlkNTg5YzAxOGE3ZTJiMTA0ZTQ1OWVjYWZlZDQzLi42MGY5ZGJmZjE3 MjY0N2Q0ZjAyMmExMzRhNzYzYTRhOGFhMTk5NjQ4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9Vc2VyQWdlbnRRdWlya3MuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL1VzZXJBZ2VudFF1aXJrcy5jcHAKQEAgLTExMywxNyArMTEzLDE3IEBAIHN0YXRpYyBib29s IHVybFJlcXVpcmVzRmlyZWZveEJyb3dzZXIoY29uc3QgVVJMJiB1cmwpCiAgICAgcmV0dXJuIGZh bHNlOwogfQogCi1zdGF0aWMgYm9vbCB1cmxSZXF1aXJlc01hY2ludG9zaFBsYXRmb3JtKGNvbnN0 IFVSTCYgdXJsKQorc3RhdGljIGJvb2wgdXJsUmVxdWlyZXNNYWNpbnRvc2hQbGF0Zm9ybShjb25z dCBVUkwmIHVybCwgQ2hhc3Npc1R5cGUgY2hhc3Npc1R5cGUpCiB7CiAgICAgU3RyaW5nIGRvbWFp biA9IHVybC5ob3N0KCkudG9TdHJpbmcoKTsKICAgICBTdHJpbmcgYmFzZURvbWFpbiA9IHRvcFBy aXZhdGVseUNvbnRyb2xsZWREb21haW4oZG9tYWluKTsKIAogICAgIC8vIEF0IGxlYXN0IGZpbmFu Y2UueWFob28uY29tIGRpc3BsYXlzIGEgbW9iaWxlIHZlcnNpb24gd2l0aCBXZWJLaXRHVEsncyBz dGFuZGFyZCB1c2VyIGFnZW50LgotICAgIGlmIChiYXNlRG9tYWluID09ICJ5YWhvby5jb20iKQor ICAgIGlmIChjaGFzc2lzVHlwZSAhPSBDaGFzc2lzVHlwZTo6TW9iaWxlICYmIGJhc2VEb21haW4g PT0gInlhaG9vLmNvbSIpCiAgICAgICAgIHJldHVybiB0cnVlOwogCiAgICAgLy8gdGFvYmFvLmNv bSBkaXNwbGF5cyBhIG1vYmlsZSB2ZXJzaW9uIHdpdGggV2ViS2l0R1RLJ3Mgc3RhbmRhcmQgdXNl ciBhZ2VudC4KLSAgICBpZiAoYmFzZURvbWFpbiA9PSAidGFvYmFvLmNvbSIpCisgICAgaWYgKGNo YXNzaXNUeXBlICE9IENoYXNzaXNUeXBlOjpNb2JpbGUgJiYgYmFzZURvbWFpbiA9PSAidGFvYmFv LmNvbSIpCiAgICAgICAgIHJldHVybiB0cnVlOwogCiAgICAgLy8gd2ViLndoYXRzYXBwLmNvbSBj b21wbGV0ZWx5IGJsb2NrcyB1c2VycyB3aXRoIFdlYktpdEdUSydzIHN0YW5kYXJkIHVzZXIgYWdl bnQuCkBAIC0xNTAsMTIgKzE1MCwxMiBAQCBzdGF0aWMgYm9vbCB1cmxSZXF1aXJlc01hY2ludG9z aFBsYXRmb3JtKGNvbnN0IFVSTCYgdXJsKQogICAgIHJldHVybiBmYWxzZTsKIH0KIAotc3RhdGlj IGJvb2wgdXJsUmVxdWlyZXNMaW51eERlc2t0b3BQbGF0Zm9ybShjb25zdCBVUkwmIHVybCkKK3N0 YXRpYyBib29sIHVybFJlcXVpcmVzTGludXhEZXNrdG9wUGxhdGZvcm0oY29uc3QgVVJMJiB1cmws IENoYXNzaXNUeXBlIGNoYXNzaXNUeXBlKQogewotICAgIHJldHVybiBpc0dvb2dsZSh1cmwpOwor ICAgIHJldHVybiBpc0dvb2dsZSh1cmwpICYmIGNoYXNzaXNUeXBlICE9IENoYXNzaXNUeXBlOjpN b2JpbGU7CiB9CiAKLVVzZXJBZ2VudFF1aXJrcyBVc2VyQWdlbnRRdWlya3M6OnF1aXJrc0ZvclVS TChjb25zdCBVUkwmIHVybCkKK1VzZXJBZ2VudFF1aXJrcyBVc2VyQWdlbnRRdWlya3M6OnF1aXJr c0ZvclVSTChjb25zdCBVUkwmIHVybCwgQ2hhc3Npc1R5cGUgY2hhc3Npc1R5cGUpCiB7CiAgICAg QVNTRVJUKCF1cmwuaXNOdWxsKCkpOwogCkBAIC0xNjYsOSArMTY2LDkgQEAgVXNlckFnZW50UXVp cmtzIFVzZXJBZ2VudFF1aXJrczo6cXVpcmtzRm9yVVJMKGNvbnN0IFVSTCYgdXJsKQogICAgIGVs c2UgaWYgKHVybFJlcXVpcmVzRmlyZWZveEJyb3dzZXIodXJsKSkKICAgICAgICAgcXVpcmtzLmFk ZChVc2VyQWdlbnRRdWlya3M6Ok5lZWRzRmlyZWZveEJyb3dzZXIpOwogCi0gICAgaWYgKHVybFJl cXVpcmVzTWFjaW50b3NoUGxhdGZvcm0odXJsKSkKKyAgICBpZiAodXJsUmVxdWlyZXNNYWNpbnRv c2hQbGF0Zm9ybSh1cmwsIGNoYXNzaXNUeXBlKSkKICAgICAgICAgcXVpcmtzLmFkZChVc2VyQWdl bnRRdWlya3M6Ok5lZWRzTWFjaW50b3NoUGxhdGZvcm0pOwotICAgIGVsc2UgaWYgKHVybFJlcXVp cmVzTGludXhEZXNrdG9wUGxhdGZvcm0odXJsKSkKKyAgICBlbHNlIGlmICh1cmxSZXF1aXJlc0xp bnV4RGVza3RvcFBsYXRmb3JtKHVybCwgY2hhc3Npc1R5cGUpKQogICAgICAgICBxdWlya3MuYWRk KFVzZXJBZ2VudFF1aXJrczo6TmVlZHNMaW51eERlc2t0b3BQbGF0Zm9ybSk7CiAKICAgICByZXR1 cm4gcXVpcmtzOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVXNlckFnZW50 UXVpcmtzLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9Vc2VyQWdlbnRRdWlya3MuaAppbmRl eCA5ODJmODdmOGMxYzRhYjkwYzdjZmMwY2M4NmY1YzRiZmUzNmZhZWYzLi5mM2JhNDUyNDM3MTY0 YmYyOGYxOWQxNjVmYWQxNzcyNmY0YTMyY2NjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9Vc2VyQWdlbnRRdWlya3MuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9V c2VyQWdlbnRRdWlya3MuaApAQCAtMjUsNiArMjUsNyBAQAogCiAjcHJhZ21hIG9uY2UKIAorI2lu Y2x1ZGUgIlVzZXJBZ2VudC5oIgogI2luY2x1ZGUgPHd0Zi9Bc3NlcnRpb25zLmg+CiAjaW5jbHVk ZSA8d3RmL3RleHQvV1RGU3RyaW5nLmg+CiAKQEAgLTYyLDcgKzYzLDcgQEAgcHVibGljOgogCiAg ICAgYm9vbCBpc0VtcHR5KCkgY29uc3QgeyByZXR1cm4gIW1fcXVpcmtzOyB9CiAKLSAgICBzdGF0 aWMgVXNlckFnZW50UXVpcmtzIHF1aXJrc0ZvclVSTChjb25zdCBVUkwmKTsKKyAgICBzdGF0aWMg VXNlckFnZW50UXVpcmtzIHF1aXJrc0ZvclVSTChjb25zdCBVUkwmLCBDaGFzc2lzVHlwZSk7CiAK ICAgICBzdGF0aWMgU3RyaW5nIHN0cmluZ0ZvclF1aXJrKFVzZXJBZ2VudFF1aXJrKTsKIApkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ2xpYi9Vc2VyQWdlbnRHTGliLmNwcCBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dsaWIvVXNlckFnZW50R0xpYi5jcHAKaW5kZXggM2Ux NmM3YWFmNzk4MTI1YzRmZjhmZTcwNzRlYzIyNzQyODdhZGU3OS4uN2E1ODJiMDZlOGFkY2NlNjM4 MzcwZjE1YTg1NmY2NDBkOWU1NjZmMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ2xpYi9Vc2VyQWdlbnRHTGliLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n bGliL1VzZXJBZ2VudEdMaWIuY3BwCkBAIC0zMSw2ICszMSw3IEBACiAjaW5jbHVkZSAiVXNlckFn ZW50UXVpcmtzLmgiCiAjaW5jbHVkZSA8d3RmL05ldmVyRGVzdHJveWVkLmg+CiAjaW5jbHVkZSA8 d3RmL1VSTC5oPgorI2luY2x1ZGUgPHd0Zi9nbGliL0dVbmlxdWVQdHIuaD4KICNpbmNsdWRlIDx3 dGYvdGV4dC9TdHJpbmdCdWlsZGVyLmg+CiAKICNpZiBPUyhVTklYKQpAQCAtNDUsMTEgKzQ2LDEx OSBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKK3N0YXRpYyBDaGFzc2lzVHlwZSByZWFkTWFj aGluZUluZm8odm9pZCkKK3sKKyAgICBDaGFzc2lzVHlwZSB0eXBlID0gQ2hhc3Npc1R5cGU6OlVu a25vd247CisgICAgR1VuaXF1ZU91dFB0cjxHRXJyb3I+IGVycm9yOworICAgIGNoYXIqIGJ1ZmZl cjsKKyAgICBpZiAoIWdfZmlsZV9nZXRfY29udGVudHMoIi9ldGMvbWFjaGluZS1pbmZvIiwgJmJ1 ZmZlciwgTlVMTCwgJmVycm9yLm91dFB0cigpKSkgeworICAgICAgICBnX2RlYnVnKCJDb3VsZCBu b3Qgb3BlbiAvZXRjL21hY2hpbmUtaW5mbzogJXNcbiIsIGVycm9yLT5tZXNzYWdlKTsKKyAgICAg ICAgcmV0dXJuIHR5cGU7CisgICAgfQorCisgICAgR1N0cnYgc3BsaXQgPSBnX3N0cnNwbGl0KGJ1 ZmZlciwgIlxuIiwgLTEpOworICAgIGdfZnJlZShidWZmZXIpOworCisgICAgZm9yIChndWludCBp ID0gMDsgaSA8IGdfc3Rydl9sZW5ndGgoc3BsaXQpOyBpKyspIHsKKyAgICAgICAgaWYgKGdfc3Ry X2hhc19wcmVmaXgoc3BsaXRbaV0sICJDSEFTU0lTPSIpKSB7CisgICAgICAgICAgICBjaGFyKiBj aGFzc2lzID0gc3BsaXRbaV0gKyA4OworCisgICAgICAgICAgICBpZiAoIWdfc3RyY21wMChjaGFz c2lzLCAidGFibGV0IikgfHwgIWdfc3RyY21wMChjaGFzc2lzLCAiaGFuZHNldCIpKQorICAgICAg ICAgICAgICAgIHR5cGUgPSBDaGFzc2lzVHlwZTo6TW9iaWxlOworICAgICAgICAgICAgZWxzZQor ICAgICAgICAgICAgICAgIHR5cGUgPSBDaGFzc2lzVHlwZTo6RGVza3RvcDsKKworICAgICAgICAg ICAgYnJlYWs7CisgICAgICAgIH0KKyAgICB9CisKKyAgICByZXR1cm4gdHlwZTsKK30KKworc3Rh dGljIENoYXNzaXNUeXBlIHJlYWRGYWxsYmFja0NoYXNzaXModm9pZCkKK3sKKyAgICBHVW5pcXVl T3V0UHRyPEdFcnJvcj4gZXJyb3I7CisgICAgY2hhciogYnVmZmVyOworICAgIGludCB0OworCisg ICAgaWYgKCFnX2ZpbGVfZ2V0X2NvbnRlbnRzKCIvc3lzL2NsYXNzL2RtaS9pZC9jaGFzc2lzX3R5 cGUiLCAmYnVmZmVyLCBOVUxMLCAmZXJyb3Iub3V0UHRyKCkpKSB7CisgICAgICAgIGdfZGVidWco IkNvdWxkIG5vdCBvcGVuIC9zeXMvY2xhc3MvZG1pL2lkL2NoYXNzaXNfdHlwZTogJXNcbiIsIGVy cm9yLT5tZXNzYWdlKTsKKyAgICAgICAgZ290byB0cnlBQ1BJOworICAgIH0KKworICAgIHQgPSBh dG9pKGJ1ZmZlcik7CisgICAgZnJlZShidWZmZXIpOworCisgICAgc3dpdGNoICh0KSB7CisgICAg Y2FzZSAweDM6IC8qIERlc2t0b3AgKi8KKyAgICBjYXNlIDB4NDogLyogTG93IFByb2ZpbGUgRGVz a3RvcCAqLworICAgIGNhc2UgMHg2OiAvKiBNaW5pIFRvd2VyICovCisgICAgY2FzZSAweDc6IC8q IFRvd2VyICovCisgICAgY2FzZSAweDg6IC8qIFBvcnRhYmxlICovCisgICAgY2FzZSAweDk6IC8q IExhcHRvcCAqLworICAgIGNhc2UgMHhBOiAvKiBOb3RlYm9vayAqLworICAgIGNhc2UgMHhFOiAv KiBTdWIgTm90ZWJvb2sgKi8KKyAgICBjYXNlIDB4MTE6IC8qIE1haW4gU2VydmVyIENoYXNzaXMg Ki8KKyAgICBjYXNlIDB4MUM6IC8qIEJsYWRlICovCisgICAgY2FzZSAweDFEOiAvKiBCbGFkZSBF bmNsb3N1cmUgKi8KKyAgICBjYXNlIDB4MUY6IC8qIENvbnZlcnRpYmxlICovCisgICAgY2FzZSAw eDIwOiAvKiBEZXRhY2hhYmxlICovCisgICAgICAgIHJldHVybiBDaGFzc2lzVHlwZTo6RGVza3Rv cDsKKworICAgIGNhc2UgMHhCOiAvKiBIYW5kIEhlbGQgKi8KKyAgICBjYXNlIDB4MUU6IC8qIFRh YmxldCAqLworICAgICAgICByZXR1cm4gQ2hhc3Npc1R5cGU6Ok1vYmlsZTsKKyAgICB9CisKK3Ry eUFDUEk6CisgICAgaWYgKCFnX2ZpbGVfZ2V0X2NvbnRlbnRzKCIvc3lzL2Zpcm13YXJlL2FjcGkv cG1fcHJvZmlsZSIsICZidWZmZXIsIE5VTEwsICZlcnJvci5vdXRQdHIoKSkpIHsKKyAgICAgICAg Z19kZWJ1ZygiQ291bGQgbm90IG9wZW4gL3N5cy9maXJtd2FyZS9hY3BpL3BtX3Byb2ZpbGU6ICVz XG4iLCBlcnJvci0+bWVzc2FnZSk7CisgICAgICAgIHJldHVybiBDaGFzc2lzVHlwZTo6VW5rbm93 bjsKKyAgICB9CisKKyAgICB0ID0gYXRvaShidWZmZXIpOworICAgIGZyZWUoYnVmZmVyKTsKKwor ICAgIHN3aXRjaCAodCkgeworICAgIGNhc2UgMTogLyogRGVza3RvcCAqLworICAgIGNhc2UgMjog LyogTW9iaWxlICovCisgICAgY2FzZSAzOiAvKiBXb3Jrc3RhdGlvbiAqLworICAgIGNhc2UgNDog LyogRW50ZXJwcmlzZSBTZXJ2ZXIgKi8KKyAgICBjYXNlIDU6IC8qIFNPSE8gU2VydmVyICovCisg ICAgY2FzZSA2OiAvKiBBcHBsaWFuY2UgUEMgKi8KKyAgICBjYXNlIDc6IC8qIFBlcmZvcm1hbmNl IFNlcnZlciAqLworICAgICAgICByZXR1cm4gQ2hhc3Npc1R5cGU6OkRlc2t0b3A7CisKKyAgICBj YXNlIDg6IC8qIFRhYmxldCAqLworICAgICAgICByZXR1cm4gQ2hhc3Npc1R5cGU6Ok1vYmlsZTsK KyAgICB9CisKKyAgICByZXR1cm4gQ2hhc3Npc1R5cGU6OlVua25vd247Cit9CisKK3N0YXRpYyBD aGFzc2lzVHlwZSBnZXRDaGFzc2lzVHlwZSgpCit7CisgICAgc3RhdGljIENoYXNzaXNUeXBlIGNo YXNzaXNUeXBlID0gQ2hhc3Npc1R5cGU6OkRlc2t0b3A7CisgICAgc3RhdGljIGJvb2wgZmlyc3RS dW4gPSB0cnVlOworCisgICAgaWYgKGZpcnN0UnVuKSB7CisgICAgICAgIGNoYXNzaXNUeXBlID0g cmVhZE1hY2hpbmVJbmZvKCk7CisgICAgICAgIGlmIChjaGFzc2lzVHlwZSA9PSBDaGFzc2lzVHlw ZTo6VW5rbm93bikKKyAgICAgICAgICAgIGNoYXNzaXNUeXBlID0gcmVhZEZhbGxiYWNrQ2hhc3Np cygpOworCisgICAgICAgIGZpcnN0UnVuID0gZmFsc2U7CisgICAgfQorCisgICAgcmV0dXJuIGNo YXNzaXNUeXBlOworfQorCiBzdGF0aWMgY29uc3QgY2hhciogcGxhdGZvcm1Gb3JVQVN0cmluZygp CiB7CiAjaWYgT1MoTUFDX09TX1gpCiAgICAgcmV0dXJuICJNYWNpbnRvc2giOwogI2Vsc2UKKyAg ICBpZiAoZ2V0Q2hhc3Npc1R5cGUoKSA9PSBDaGFzc2lzVHlwZTo6TW9iaWxlKQorICAgICAgICBy ZXR1cm4gIkxpbnV4IjsKICAgICByZXR1cm4gIlgxMSI7CiAjZW5kaWYKIH0KQEAgLTU3LDYgKzE2 Niw4IEBAIHN0YXRpYyBjb25zdCBjaGFyKiBwbGF0Zm9ybUZvclVBU3RyaW5nKCkKIHN0YXRpYyBj b25zdCBTdHJpbmcgcGxhdGZvcm1WZXJzaW9uRm9yVUFTdHJpbmcoKQogewogI2lmIE9TKFVOSVgp CisgICAgaWYgKGdldENoYXNzaXNUeXBlKCkgPT0gQ2hhc3Npc1R5cGU6Ok1vYmlsZSkKKyAgICAg ICAgcmV0dXJuICJsaWtlIEFuZHJvaWQgNC40IjsKICAgICBzdHJ1Y3QgdXRzbmFtZSBuYW1lOwog ICAgIHVuYW1lKCZuYW1lKTsKICAgICBzdGF0aWMgTmV2ZXJEZXN0cm95ZWQ8Y29uc3QgU3RyaW5n PiB1YU9TVmVyc2lvbihtYWtlU3RyaW5nKG5hbWUuc3lzbmFtZSwgJyAnLCBuYW1lLm1hY2hpbmUp KTsKQEAgLTExMyw2ICsyMjQsOSBAQCBzdGF0aWMgU3RyaW5nIGJ1aWxkVXNlckFnZW50U3RyaW5n KGNvbnN0IFVzZXJBZ2VudFF1aXJrcyYgcXVpcmtzKQogICAgIC8vIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMzM0MDMgZm9yIGRldGFpbHMuCiAgICAgfSBlbHNlCiAg ICAgICAgIHVhU3RyaW5nLmFwcGVuZExpdGVyYWwoIlZlcnNpb24vMTMuMCAiKTsKKworICAgIGlm IChnZXRDaGFzc2lzVHlwZSgpID09IENoYXNzaXNUeXBlOjpNb2JpbGUpCisgICAgICAgIHVhU3Ry aW5nLmFwcGVuZExpdGVyYWwoIk1vYmlsZSAiKTsKICAgICB1YVN0cmluZy5hcHBlbmRMaXRlcmFs KCJTYWZhcmkvIik7CiAgICAgdWFTdHJpbmcuYXBwZW5kKHZlcnNpb25Gb3JVQVN0cmluZygpKTsK IApAQCAtMTU5LDcgKzI3Myw3IEBAIFN0cmluZyBzdGFuZGFyZFVzZXJBZ2VudChjb25zdCBTdHJp bmcmIGFwcGxpY2F0aW9uTmFtZSwgY29uc3QgU3RyaW5nJiBhcHBsaWNhdGlvCiAKIFN0cmluZyBz dGFuZGFyZFVzZXJBZ2VudEZvclVSTChjb25zdCBVUkwmIHVybCkKIHsKLSAgICBhdXRvIHF1aXJr cyA9IFVzZXJBZ2VudFF1aXJrczo6cXVpcmtzRm9yVVJMKHVybCk7CisgICAgYXV0byBxdWlya3Mg PSBVc2VyQWdlbnRRdWlya3M6OnF1aXJrc0ZvclVSTCh1cmwsIGdldENoYXNzaXNUeXBlKCkpOwog ICAgIC8vIFRoZSBudWxsIHN0cmluZyBtZWFucyB3ZSBkb24ndCBuZWVkIGEgc3BlY2lmaWMgVUEg Zm9yIHRoZSBnaXZlbiBVUkwuCiAgICAgaWYgKHF1aXJrcy5pc0VtcHR5KCkpCiAgICAgICAgIHJl dHVybiBTdHJpbmcoKTsK 403517 2020-07-04 01:38:00 -0700 2020-07-06 09:54:52 -0700 Patch bug-149496-20200704103759.patch text/plain 9561 jan.brummer U3VidmVyc2lvbiBSZXZpc2lvbjogMjYzNjYzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggODc2MWFiMDQyYzc3MjNl M2ZiYTJmN2RlMmZmZTVjM2JjZmY3ZjU3Ni4uODNjZGJmYzU2NTZjZWExYTI2NDUyYTBmYjBlMjFj MDMyZGFiM2Y0NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI1IEBACisyMDIwLTA2LTI5ICBKYW4t TWljaGFlbCBCcnVtbWVyICA8amFuLmJydW1tZXJAdGFib3Mub3JnPgorCisgICAgICAgIFtHVEtd IFVzZSBtb2JpbGUgdXNlci1hZ2VudCBvbiB0YWJsZXQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE0OTQ5NgorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIE5vIG5ldyB0ZXN0cyAoT09QUyEpLgorCisgICAgICAg ICogcGxhdGZvcm0vVXNlckFnZW50UXVpcmtzLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OnVybFJl cXVpcmVzTWFjaW50b3NoUGxhdGZvcm0pOgorICAgICAgICAoV2ViQ29yZTo6dXJsUmVxdWlyZXNM aW51eERlc2t0b3BQbGF0Zm9ybSk6CisgICAgICAgIChXZWJDb3JlOjpVc2VyQWdlbnRRdWlya3M6 OnF1aXJrc0ZvclVSTCk6CisgICAgICAgICogcGxhdGZvcm0vVXNlckFnZW50UXVpcmtzLmg6Cisg ICAgICAgICogcGxhdGZvcm0vZ2xpYi9Vc2VyQWdlbnRHTGliLmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OmdldENoYXNzaXNUeXBlKToKKyAgICAgICAgKFdlYkNvcmU6OnBsYXRmb3JtRm9yVUFTdHJp bmcpOgorICAgICAgICAoV2ViQ29yZTo6cGxhdGZvcm1WZXJzaW9uRm9yVUFTdHJpbmcpOgorICAg ICAgICAoV2ViQ29yZTo6YnVpbGRVc2VyQWdlbnRTdHJpbmcpOgorICAgICAgICAoV2ViQ29yZTo6 c3RhbmRhcmRVc2VyQWdlbnQpOgorICAgICAgICAoV2ViQ29yZTo6c3RhbmRhcmRVc2VyQWdlbnRG b3JVUkwpOgorCiAyMDIwLTA2LTI5ICBDaHJpcyBEdW1leiAgPGNkdW1lekBhcHBsZS5jb20+CiAK ICAgICAgICAgT24gbG9hZCBmcm9tIGJhY2svZm9yd2FyZCBjYWNoZSwgY2FsbCBjaGVja0NvbXBs ZXRlZCgpIGZvciBBTEwgZnJhbWVzIGluc2lkZSBGcmFtZUxvYWRlcjo6Y29tbWl0UHJvdmlzaW9u YWxMb2FkKCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1VzZXJBZ2VudC5o IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVXNlckFnZW50LmgKaW5kZXggZWJjZGIxZGQwODEy NGZiZWJmNTM2ODdjMjk4YTg3ZjFlYTY1MWE0NS4uNDBjZWRjODQ4ODY3ZTQ2YmZhMGQ2NDFhYzcx NjVhNmM4YzI0NWVjOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVXNlckFn ZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVXNlckFnZW50LmgKQEAgLTM4LDYg KzM4LDEyIEBAIFdFQkNPUkVfRVhQT1JUIFN0cmluZyBvc05hbWVGb3JVc2VyQWdlbnQoKTsKIFdF QkNPUkVfRVhQT1JUIFN0cmluZyBzeXN0ZW1NYXJrZXRpbmdWZXJzaW9uRm9yVXNlckFnZW50U3Ry aW5nKCk7CiAjZWxzZQogCitlbnVtIGNsYXNzIENoYXNzaXNUeXBlIHsKKyAgICBVbmtub3duLAor ICAgIERlc2t0b3AsCisgICAgTW9iaWxlCit9OworCiBXRUJDT1JFX0VYUE9SVCBTdHJpbmcgc3Rh bmRhcmRVc2VyQWdlbnQoY29uc3QgU3RyaW5nJiBhcHBsaWNhdGlvbk5hbWUgPSBlbXB0eVN0cmlu ZygpLCBjb25zdCBTdHJpbmcmIGFwcGxpY2F0aW9uVmVyc2lvbiA9IGVtcHR5U3RyaW5nKCkpOwog V0VCQ09SRV9FWFBPUlQgU3RyaW5nIHN0YW5kYXJkVXNlckFnZW50Rm9yVVJMKGNvbnN0IFVSTCYp OwogI2VuZGlmCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9Vc2VyQWdlbnRR dWlya3MuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVXNlckFnZW50UXVpcmtzLmNwcApp bmRleCA0YWJkYjg2YjdkNzlkNTg5YzAxOGE3ZTJiMTA0ZTQ1OWVjYWZlZDQzLi42MGY5ZGJmZjE3 MjY0N2Q0ZjAyMmExMzRhNzYzYTRhOGFhMTk5NjQ4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9Vc2VyQWdlbnRRdWlya3MuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL1VzZXJBZ2VudFF1aXJrcy5jcHAKQEAgLTExMywxNyArMTEzLDE3IEBAIHN0YXRpYyBib29s IHVybFJlcXVpcmVzRmlyZWZveEJyb3dzZXIoY29uc3QgVVJMJiB1cmwpCiAgICAgcmV0dXJuIGZh bHNlOwogfQogCi1zdGF0aWMgYm9vbCB1cmxSZXF1aXJlc01hY2ludG9zaFBsYXRmb3JtKGNvbnN0 IFVSTCYgdXJsKQorc3RhdGljIGJvb2wgdXJsUmVxdWlyZXNNYWNpbnRvc2hQbGF0Zm9ybShjb25z dCBVUkwmIHVybCwgQ2hhc3Npc1R5cGUgY2hhc3Npc1R5cGUpCiB7CiAgICAgU3RyaW5nIGRvbWFp biA9IHVybC5ob3N0KCkudG9TdHJpbmcoKTsKICAgICBTdHJpbmcgYmFzZURvbWFpbiA9IHRvcFBy aXZhdGVseUNvbnRyb2xsZWREb21haW4oZG9tYWluKTsKIAogICAgIC8vIEF0IGxlYXN0IGZpbmFu Y2UueWFob28uY29tIGRpc3BsYXlzIGEgbW9iaWxlIHZlcnNpb24gd2l0aCBXZWJLaXRHVEsncyBz dGFuZGFyZCB1c2VyIGFnZW50LgotICAgIGlmIChiYXNlRG9tYWluID09ICJ5YWhvby5jb20iKQor ICAgIGlmIChjaGFzc2lzVHlwZSAhPSBDaGFzc2lzVHlwZTo6TW9iaWxlICYmIGJhc2VEb21haW4g PT0gInlhaG9vLmNvbSIpCiAgICAgICAgIHJldHVybiB0cnVlOwogCiAgICAgLy8gdGFvYmFvLmNv bSBkaXNwbGF5cyBhIG1vYmlsZSB2ZXJzaW9uIHdpdGggV2ViS2l0R1RLJ3Mgc3RhbmRhcmQgdXNl ciBhZ2VudC4KLSAgICBpZiAoYmFzZURvbWFpbiA9PSAidGFvYmFvLmNvbSIpCisgICAgaWYgKGNo YXNzaXNUeXBlICE9IENoYXNzaXNUeXBlOjpNb2JpbGUgJiYgYmFzZURvbWFpbiA9PSAidGFvYmFv LmNvbSIpCiAgICAgICAgIHJldHVybiB0cnVlOwogCiAgICAgLy8gd2ViLndoYXRzYXBwLmNvbSBj b21wbGV0ZWx5IGJsb2NrcyB1c2VycyB3aXRoIFdlYktpdEdUSydzIHN0YW5kYXJkIHVzZXIgYWdl bnQuCkBAIC0xNTAsMTIgKzE1MCwxMiBAQCBzdGF0aWMgYm9vbCB1cmxSZXF1aXJlc01hY2ludG9z aFBsYXRmb3JtKGNvbnN0IFVSTCYgdXJsKQogICAgIHJldHVybiBmYWxzZTsKIH0KIAotc3RhdGlj IGJvb2wgdXJsUmVxdWlyZXNMaW51eERlc2t0b3BQbGF0Zm9ybShjb25zdCBVUkwmIHVybCkKK3N0 YXRpYyBib29sIHVybFJlcXVpcmVzTGludXhEZXNrdG9wUGxhdGZvcm0oY29uc3QgVVJMJiB1cmws IENoYXNzaXNUeXBlIGNoYXNzaXNUeXBlKQogewotICAgIHJldHVybiBpc0dvb2dsZSh1cmwpOwor ICAgIHJldHVybiBpc0dvb2dsZSh1cmwpICYmIGNoYXNzaXNUeXBlICE9IENoYXNzaXNUeXBlOjpN b2JpbGU7CiB9CiAKLVVzZXJBZ2VudFF1aXJrcyBVc2VyQWdlbnRRdWlya3M6OnF1aXJrc0ZvclVS TChjb25zdCBVUkwmIHVybCkKK1VzZXJBZ2VudFF1aXJrcyBVc2VyQWdlbnRRdWlya3M6OnF1aXJr c0ZvclVSTChjb25zdCBVUkwmIHVybCwgQ2hhc3Npc1R5cGUgY2hhc3Npc1R5cGUpCiB7CiAgICAg QVNTRVJUKCF1cmwuaXNOdWxsKCkpOwogCkBAIC0xNjYsOSArMTY2LDkgQEAgVXNlckFnZW50UXVp cmtzIFVzZXJBZ2VudFF1aXJrczo6cXVpcmtzRm9yVVJMKGNvbnN0IFVSTCYgdXJsKQogICAgIGVs c2UgaWYgKHVybFJlcXVpcmVzRmlyZWZveEJyb3dzZXIodXJsKSkKICAgICAgICAgcXVpcmtzLmFk ZChVc2VyQWdlbnRRdWlya3M6Ok5lZWRzRmlyZWZveEJyb3dzZXIpOwogCi0gICAgaWYgKHVybFJl cXVpcmVzTWFjaW50b3NoUGxhdGZvcm0odXJsKSkKKyAgICBpZiAodXJsUmVxdWlyZXNNYWNpbnRv c2hQbGF0Zm9ybSh1cmwsIGNoYXNzaXNUeXBlKSkKICAgICAgICAgcXVpcmtzLmFkZChVc2VyQWdl bnRRdWlya3M6Ok5lZWRzTWFjaW50b3NoUGxhdGZvcm0pOwotICAgIGVsc2UgaWYgKHVybFJlcXVp cmVzTGludXhEZXNrdG9wUGxhdGZvcm0odXJsKSkKKyAgICBlbHNlIGlmICh1cmxSZXF1aXJlc0xp bnV4RGVza3RvcFBsYXRmb3JtKHVybCwgY2hhc3Npc1R5cGUpKQogICAgICAgICBxdWlya3MuYWRk KFVzZXJBZ2VudFF1aXJrczo6TmVlZHNMaW51eERlc2t0b3BQbGF0Zm9ybSk7CiAKICAgICByZXR1 cm4gcXVpcmtzOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVXNlckFnZW50 UXVpcmtzLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9Vc2VyQWdlbnRRdWlya3MuaAppbmRl eCA5ODJmODdmOGMxYzRhYjkwYzdjZmMwY2M4NmY1YzRiZmUzNmZhZWYzLi5mM2JhNDUyNDM3MTY0 YmYyOGYxOWQxNjVmYWQxNzcyNmY0YTMyY2NjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9Vc2VyQWdlbnRRdWlya3MuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9V c2VyQWdlbnRRdWlya3MuaApAQCAtMjUsNiArMjUsNyBAQAogCiAjcHJhZ21hIG9uY2UKIAorI2lu Y2x1ZGUgIlVzZXJBZ2VudC5oIgogI2luY2x1ZGUgPHd0Zi9Bc3NlcnRpb25zLmg+CiAjaW5jbHVk ZSA8d3RmL3RleHQvV1RGU3RyaW5nLmg+CiAKQEAgLTYyLDcgKzYzLDcgQEAgcHVibGljOgogCiAg ICAgYm9vbCBpc0VtcHR5KCkgY29uc3QgeyByZXR1cm4gIW1fcXVpcmtzOyB9CiAKLSAgICBzdGF0 aWMgVXNlckFnZW50UXVpcmtzIHF1aXJrc0ZvclVSTChjb25zdCBVUkwmKTsKKyAgICBzdGF0aWMg VXNlckFnZW50UXVpcmtzIHF1aXJrc0ZvclVSTChjb25zdCBVUkwmLCBDaGFzc2lzVHlwZSk7CiAK ICAgICBzdGF0aWMgU3RyaW5nIHN0cmluZ0ZvclF1aXJrKFVzZXJBZ2VudFF1aXJrKTsKIApkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ2xpYi9Vc2VyQWdlbnRHTGliLmNwcCBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dsaWIvVXNlckFnZW50R0xpYi5jcHAKaW5kZXggM2Ux NmM3YWFmNzk4MTI1YzRmZjhmZTcwNzRlYzIyNzQyODdhZGU3OS4uYzVmMjVkN2VhNTY3NDEzNWUw OWEwM2FmMTE0MjNmN2I5YmVjMGRmNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ2xpYi9Vc2VyQWdlbnRHTGliLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n bGliL1VzZXJBZ2VudEdMaWIuY3BwCkBAIC0zMSw2ICszMSw3IEBACiAjaW5jbHVkZSAiVXNlckFn ZW50UXVpcmtzLmgiCiAjaW5jbHVkZSA8d3RmL05ldmVyRGVzdHJveWVkLmg+CiAjaW5jbHVkZSA8 d3RmL1VSTC5oPgorI2luY2x1ZGUgPHd0Zi9nbGliL0dVbmlxdWVQdHIuaD4KICNpbmNsdWRlIDx3 dGYvdGV4dC9TdHJpbmdCdWlsZGVyLmg+CiAKICNpZiBPUyhVTklYKQpAQCAtNDUsMTEgKzQ2LDEw OCBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKK3N0YXRpYyBDaGFzc2lzVHlwZSByZWFkTWFj aGluZUluZm9DaGFzc2lzVHlwZSgpCit7CisgICAgR1VuaXF1ZU91dFB0cjxjaGFyPiBidWZmZXI7 CisgICAgaWYgKCFnX2ZpbGVfZ2V0X2NvbnRlbnRzKCIvZXRjL21hY2hpbmUtaW5mbyIsICZidWZm ZXIub3V0UHRyKCksIG51bGxwdHIsIG51bGxwdHIpKQorICAgICAgICByZXR1cm4gQ2hhc3Npc1R5 cGU6OlVua25vd247CisKKyAgICBHVW5pcXVlUHRyPGNoYXIqPiBzcGxpdChnX3N0cnNwbGl0KGJ1 ZmZlci5nZXQoKSwgIlxuIiwgLTEpKTsKKyAgICBmb3IgKGludCBpID0gMDsgc3BsaXQuZ2V0KClb aV07ICsraSkgeworICAgICAgICBpZiAoZ19zdHJfaGFzX3ByZWZpeChzcGxpdC5nZXQoKVtpXSwg IkNIQVNTSVM9IikpIHsKKyAgICAgICAgICAgIGNoYXIqIGNoYXNzaXMgPSBzcGxpdC5nZXQoKVtp XSArIDg7CisgICAgICAgICAgICBpZiAoIXN0cmNtcChjaGFzc2lzLCAidGFibGV0IikgfHwgIXN0 cmNtcChjaGFzc2lzLCAiaGFuZHNldCIpKQorICAgICAgICAgICAgICAgIHJldHVybiBDaGFzc2lz VHlwZTo6TW9iaWxlOworCisgICAgICAgICAgICByZXR1cm4gQ2hhc3Npc1R5cGU6OkRlc2t0b3A7 CisgICAgICAgIH0KKyAgICB9CisKKyAgICByZXR1cm4gQ2hhc3Npc1R5cGU6OlVua25vd247Cit9 CisKK3N0YXRpYyBDaGFzc2lzVHlwZSByZWFkRE1JQ2hhc3Npc1R5cGUoKQoreworICAgIEdVbmlx dWVPdXRQdHI8Y2hhcj4gYnVmZmVyOworICAgIGlmIChnX2ZpbGVfZ2V0X2NvbnRlbnRzKCIvc3lz L2NsYXNzL2RtaS9pZC9jaGFzc2lzX3R5cGUiLCAmYnVmZmVyLm91dFB0cigpLCBudWxscHRyLCBu dWxscHRyKSkgeworICAgICAgICBpbnQgdCA9IGF0b2koYnVmZmVyLmdldCgpKTsKKworICAgICAg ICBzd2l0Y2ggKHQpIHsKKyAgICAgICAgY2FzZSAweDM6IC8qIERlc2t0b3AgKi8KKyAgICAgICAg Y2FzZSAweDQ6IC8qIExvdyBQcm9maWxlIERlc2t0b3AgKi8KKyAgICAgICAgY2FzZSAweDY6IC8q IE1pbmkgVG93ZXIgKi8KKyAgICAgICAgY2FzZSAweDc6IC8qIFRvd2VyICovCisgICAgICAgIGNh c2UgMHg4OiAvKiBQb3J0YWJsZSAqLworICAgICAgICBjYXNlIDB4OTogLyogTGFwdG9wICovCisg ICAgICAgIGNhc2UgMHhBOiAvKiBOb3RlYm9vayAqLworICAgICAgICBjYXNlIDB4RTogLyogU3Vi IE5vdGVib29rICovCisgICAgICAgIGNhc2UgMHgxMTogLyogTWFpbiBTZXJ2ZXIgQ2hhc3NpcyAq LworICAgICAgICBjYXNlIDB4MUM6IC8qIEJsYWRlICovCisgICAgICAgIGNhc2UgMHgxRDogLyog QmxhZGUgRW5jbG9zdXJlICovCisgICAgICAgIGNhc2UgMHgxRjogLyogQ29udmVydGlibGUgKi8K KyAgICAgICAgY2FzZSAweDIwOiAvKiBEZXRhY2hhYmxlICovCisgICAgICAgICAgICByZXR1cm4g Q2hhc3Npc1R5cGU6OkRlc2t0b3A7CisKKyAgICAgICAgY2FzZSAweEI6IC8qIEhhbmQgSGVsZCAq LworICAgICAgICBjYXNlIDB4MUU6IC8qIFRhYmxldCAqLworICAgICAgICAgICAgcmV0dXJuIENo YXNzaXNUeXBlOjpNb2JpbGU7CisgICAgICAgIH0KKyAgICB9CisKKyAgICByZXR1cm4gQ2hhc3Np c1R5cGU6OlVua25vd247Cit9CisKK3N0YXRpYyBDaGFzc2lzVHlwZSByZWFkQUNQSUNoYXNzaXNU eXBlKCkKK3sKKyAgICBHVW5pcXVlT3V0UHRyPGNoYXI+IGJ1ZmZlcjsKKyAgICBpZiAoZ19maWxl X2dldF9jb250ZW50cygiL3N5cy9maXJtd2FyZS9hY3BpL3BtX3Byb2ZpbGUiLCAmYnVmZmVyLm91 dFB0cigpLCBudWxscHRyLCBudWxscHRyKSkgeworICAgICAgICBpbnQgdCA9IGF0b2koYnVmZmVy LmdldCgpKTsKKworICAgICAgICBzd2l0Y2ggKHQpIHsKKyAgICAgICAgY2FzZSAxOiAvKiBEZXNr dG9wICovCisgICAgICAgIGNhc2UgMjogLyogTW9iaWxlICovCisgICAgICAgIGNhc2UgMzogLyog V29ya3N0YXRpb24gKi8KKyAgICAgICAgY2FzZSA0OiAvKiBFbnRlcnByaXNlIFNlcnZlciAqLwor ICAgICAgICBjYXNlIDU6IC8qIFNPSE8gU2VydmVyICovCisgICAgICAgIGNhc2UgNjogLyogQXBw bGlhbmNlIFBDICovCisgICAgICAgIGNhc2UgNzogLyogUGVyZm9ybWFuY2UgU2VydmVyICovCisg ICAgICAgICAgICByZXR1cm4gQ2hhc3Npc1R5cGU6OkRlc2t0b3A7CisKKyAgICAgICAgY2FzZSA4 OiAvKiBUYWJsZXQgKi8KKyAgICAgICAgICAgIHJldHVybiBDaGFzc2lzVHlwZTo6TW9iaWxlOwor ICAgICAgICB9CisgICAgfQorCisgICAgcmV0dXJuIENoYXNzaXNUeXBlOjpVbmtub3duOworfQor CitzdGF0aWMgQ2hhc3Npc1R5cGUgZ2V0Q2hhc3Npc1R5cGUoKQoreworICAgIHN0YXRpYyBDaGFz c2lzVHlwZSBjaGFzc2lzVHlwZTsKKyAgICBzdGF0aWMgYm9vbCBmaXJzdFJ1biA9IHRydWU7CisK KyAgICBpZiAoZmlyc3RSdW4pIHsKKyAgICAgICAgY2hhc3Npc1R5cGUgPSByZWFkTWFjaGluZUlu Zm9DaGFzc2lzVHlwZSgpOworICAgICAgICBpZiAoY2hhc3Npc1R5cGUgPT0gQ2hhc3Npc1R5cGU6 OlVua25vd24pCisgICAgICAgICAgICBjaGFzc2lzVHlwZSA9IHJlYWRETUlDaGFzc2lzVHlwZSgp OworICAgICAgICBpZiAoY2hhc3Npc1R5cGUgPT0gQ2hhc3Npc1R5cGU6OlVua25vd24pCisgICAg ICAgICAgICBjaGFzc2lzVHlwZSA9IHJlYWRBQ1BJQ2hhc3Npc1R5cGUoKTsKKyAgICAgICAgaWYg KGNoYXNzaXNUeXBlID09IENoYXNzaXNUeXBlOjpVbmtub3duKQorICAgICAgICAgICAgY2hhc3Np c1R5cGUgPSBDaGFzc2lzVHlwZTo6RGVza3RvcDsKKworICAgICAgICBmaXJzdFJ1biA9IGZhbHNl OworICAgIH0KKworICAgIHJldHVybiBjaGFzc2lzVHlwZTsKK30KKwogc3RhdGljIGNvbnN0IGNo YXIqIHBsYXRmb3JtRm9yVUFTdHJpbmcoKQogewogI2lmIE9TKE1BQ19PU19YKQogICAgIHJldHVy biAiTWFjaW50b3NoIjsKICNlbHNlCisgICAgaWYgKGdldENoYXNzaXNUeXBlKCkgPT0gQ2hhc3Np c1R5cGU6Ok1vYmlsZSkKKyAgICAgICAgcmV0dXJuICJMaW51eCI7CiAgICAgcmV0dXJuICJYMTEi OwogI2VuZGlmCiB9CkBAIC01Nyw2ICsxNTUsOSBAQCBzdGF0aWMgY29uc3QgY2hhciogcGxhdGZv cm1Gb3JVQVN0cmluZygpCiBzdGF0aWMgY29uc3QgU3RyaW5nIHBsYXRmb3JtVmVyc2lvbkZvclVB U3RyaW5nKCkKIHsKICNpZiBPUyhVTklYKQorICAgIGlmIChnZXRDaGFzc2lzVHlwZSgpID09IENo YXNzaXNUeXBlOjpNb2JpbGUpCisgICAgICAgIHJldHVybiAibGlrZSBBbmRyb2lkIDQuNCI7CisK ICAgICBzdHJ1Y3QgdXRzbmFtZSBuYW1lOwogICAgIHVuYW1lKCZuYW1lKTsKICAgICBzdGF0aWMg TmV2ZXJEZXN0cm95ZWQ8Y29uc3QgU3RyaW5nPiB1YU9TVmVyc2lvbihtYWtlU3RyaW5nKG5hbWUu c3lzbmFtZSwgJyAnLCBuYW1lLm1hY2hpbmUpKTsKQEAgLTExMyw2ICsyMTQsOSBAQCBzdGF0aWMg U3RyaW5nIGJ1aWxkVXNlckFnZW50U3RyaW5nKGNvbnN0IFVzZXJBZ2VudFF1aXJrcyYgcXVpcmtz KQogICAgIC8vIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMzM0MDMg Zm9yIGRldGFpbHMuCiAgICAgfSBlbHNlCiAgICAgICAgIHVhU3RyaW5nLmFwcGVuZExpdGVyYWwo IlZlcnNpb24vMTMuMCAiKTsKKworICAgIGlmIChnZXRDaGFzc2lzVHlwZSgpID09IENoYXNzaXNU eXBlOjpNb2JpbGUpCisgICAgICAgIHVhU3RyaW5nLmFwcGVuZExpdGVyYWwoIk1vYmlsZSAiKTsK ICAgICB1YVN0cmluZy5hcHBlbmRMaXRlcmFsKCJTYWZhcmkvIik7CiAgICAgdWFTdHJpbmcuYXBw ZW5kKHZlcnNpb25Gb3JVQVN0cmluZygpKTsKIApAQCAtMTU5LDcgKzI2Myw3IEBAIFN0cmluZyBz dGFuZGFyZFVzZXJBZ2VudChjb25zdCBTdHJpbmcmIGFwcGxpY2F0aW9uTmFtZSwgY29uc3QgU3Ry aW5nJiBhcHBsaWNhdGlvCiAKIFN0cmluZyBzdGFuZGFyZFVzZXJBZ2VudEZvclVSTChjb25zdCBV UkwmIHVybCkKIHsKLSAgICBhdXRvIHF1aXJrcyA9IFVzZXJBZ2VudFF1aXJrczo6cXVpcmtzRm9y VVJMKHVybCk7CisgICAgYXV0byBxdWlya3MgPSBVc2VyQWdlbnRRdWlya3M6OnF1aXJrc0ZvclVS TCh1cmwsIGdldENoYXNzaXNUeXBlKCkpOwogICAgIC8vIFRoZSBudWxsIHN0cmluZyBtZWFucyB3 ZSBkb24ndCBuZWVkIGEgc3BlY2lmaWMgVUEgZm9yIHRoZSBnaXZlbiBVUkwuCiAgICAgaWYgKHF1 aXJrcy5pc0VtcHR5KCkpCiAgICAgICAgIHJldHVybiBTdHJpbmcoKTsK 403599 2020-07-06 09:54:57 -0700 2020-07-08 06:22:46 -0700 Patch bug-149496-20200706185456.patch text/plain 10583 jan.brummer U3VidmVyc2lvbiBSZXZpc2lvbjogMjYzNjYzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggODc2MWFiMDQyYzc3MjNl M2ZiYTJmN2RlMmZmZTVjM2JjZmY3ZjU3Ni4uMGY1ZmZkOTdiNGM5ZmYyMjcxZWM0ZDljMzJkZGYy MDI3OTM4ODVjNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI1IEBACisyMDIwLTA2LTI5ICBKYW4t TWljaGFlbCBCcnVtbWVyICA8amFuLmJydW1tZXJAdGFib3Mub3JnPgorCisgICAgICAgIFtHVEtd W1dQRV0gVXNlIG1vYmlsZSB1c2VyLWFnZW50IG9uIHRhYmxldAorICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQ5NDk2CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzIChPT1BTISkuCisKKyAg ICAgICAgKiBwbGF0Zm9ybS9Vc2VyQWdlbnRRdWlya3MuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 dXJsUmVxdWlyZXNNYWNpbnRvc2hQbGF0Zm9ybSk6CisgICAgICAgIChXZWJDb3JlOjp1cmxSZXF1 aXJlc0xpbnV4RGVza3RvcFBsYXRmb3JtKToKKyAgICAgICAgKFdlYkNvcmU6OlVzZXJBZ2VudFF1 aXJrczo6cXVpcmtzRm9yVVJMKToKKyAgICAgICAgKiBwbGF0Zm9ybS9Vc2VyQWdlbnRRdWlya3Mu aDoKKyAgICAgICAgKiBwbGF0Zm9ybS9nbGliL1VzZXJBZ2VudEdMaWIuY3BwOgorICAgICAgICAo V2ViQ29yZTo6Z2V0Q2hhc3Npc1R5cGUpOgorICAgICAgICAoV2ViQ29yZTo6cGxhdGZvcm1Gb3JV QVN0cmluZyk6CisgICAgICAgIChXZWJDb3JlOjpwbGF0Zm9ybVZlcnNpb25Gb3JVQVN0cmluZyk6 CisgICAgICAgIChXZWJDb3JlOjpidWlsZFVzZXJBZ2VudFN0cmluZyk6CisgICAgICAgIChXZWJD b3JlOjpzdGFuZGFyZFVzZXJBZ2VudCk6CisgICAgICAgIChXZWJDb3JlOjpzdGFuZGFyZFVzZXJB Z2VudEZvclVSTCk6CisKIDIwMjAtMDYtMjkgIENocmlzIER1bWV6ICA8Y2R1bWV6QGFwcGxlLmNv bT4KIAogICAgICAgICBPbiBsb2FkIGZyb20gYmFjay9mb3J3YXJkIGNhY2hlLCBjYWxsIGNoZWNr Q29tcGxldGVkKCkgZm9yIEFMTCBmcmFtZXMgaW5zaWRlIEZyYW1lTG9hZGVyOjpjb21taXRQcm92 aXNpb25hbExvYWQoKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVXNlckFn ZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9Vc2VyQWdlbnQuaAppbmRleCBlYmNkYjFk ZDA4MTI0ZmJlYmY1MzY4N2MyOThhODdmMWVhNjUxYTQ1Li40MGNlZGM4NDg4NjdlNDZiZmEwZDY0 MWFjNzE2NWE2YzhjMjQ1ZWM4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9V c2VyQWdlbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9Vc2VyQWdlbnQuaApAQCAt MzgsNiArMzgsMTIgQEAgV0VCQ09SRV9FWFBPUlQgU3RyaW5nIG9zTmFtZUZvclVzZXJBZ2VudCgp OwogV0VCQ09SRV9FWFBPUlQgU3RyaW5nIHN5c3RlbU1hcmtldGluZ1ZlcnNpb25Gb3JVc2VyQWdl bnRTdHJpbmcoKTsKICNlbHNlCiAKK2VudW0gY2xhc3MgQ2hhc3Npc1R5cGUgeworICAgIFVua25v d24sCisgICAgRGVza3RvcCwKKyAgICBNb2JpbGUKK307CisKIFdFQkNPUkVfRVhQT1JUIFN0cmlu ZyBzdGFuZGFyZFVzZXJBZ2VudChjb25zdCBTdHJpbmcmIGFwcGxpY2F0aW9uTmFtZSA9IGVtcHR5 U3RyaW5nKCksIGNvbnN0IFN0cmluZyYgYXBwbGljYXRpb25WZXJzaW9uID0gZW1wdHlTdHJpbmco KSk7CiBXRUJDT1JFX0VYUE9SVCBTdHJpbmcgc3RhbmRhcmRVc2VyQWdlbnRGb3JVUkwoY29uc3Qg VVJMJik7CiAjZW5kaWYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1VzZXJB Z2VudFF1aXJrcy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9Vc2VyQWdlbnRRdWlya3Mu Y3BwCmluZGV4IDRhYmRiODZiN2Q3OWQ1ODljMDE4YTdlMmIxMDRlNDU5ZWNhZmVkNDMuLjYwZjlk YmZmMTcyNjQ3ZDRmMDIyYTEzNGE3NjNhNGE4YWExOTk2NDggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL1VzZXJBZ2VudFF1aXJrcy5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vVXNlckFnZW50UXVpcmtzLmNwcApAQCAtMTEzLDE3ICsxMTMsMTcgQEAgc3RhdGlj IGJvb2wgdXJsUmVxdWlyZXNGaXJlZm94QnJvd3Nlcihjb25zdCBVUkwmIHVybCkKICAgICByZXR1 cm4gZmFsc2U7CiB9CiAKLXN0YXRpYyBib29sIHVybFJlcXVpcmVzTWFjaW50b3NoUGxhdGZvcm0o Y29uc3QgVVJMJiB1cmwpCitzdGF0aWMgYm9vbCB1cmxSZXF1aXJlc01hY2ludG9zaFBsYXRmb3Jt KGNvbnN0IFVSTCYgdXJsLCBDaGFzc2lzVHlwZSBjaGFzc2lzVHlwZSkKIHsKICAgICBTdHJpbmcg ZG9tYWluID0gdXJsLmhvc3QoKS50b1N0cmluZygpOwogICAgIFN0cmluZyBiYXNlRG9tYWluID0g dG9wUHJpdmF0ZWx5Q29udHJvbGxlZERvbWFpbihkb21haW4pOwogCiAgICAgLy8gQXQgbGVhc3Qg ZmluYW5jZS55YWhvby5jb20gZGlzcGxheXMgYSBtb2JpbGUgdmVyc2lvbiB3aXRoIFdlYktpdEdU SydzIHN0YW5kYXJkIHVzZXIgYWdlbnQuCi0gICAgaWYgKGJhc2VEb21haW4gPT0gInlhaG9vLmNv bSIpCisgICAgaWYgKGNoYXNzaXNUeXBlICE9IENoYXNzaXNUeXBlOjpNb2JpbGUgJiYgYmFzZURv bWFpbiA9PSAieWFob28uY29tIikKICAgICAgICAgcmV0dXJuIHRydWU7CiAKICAgICAvLyB0YW9i YW8uY29tIGRpc3BsYXlzIGEgbW9iaWxlIHZlcnNpb24gd2l0aCBXZWJLaXRHVEsncyBzdGFuZGFy ZCB1c2VyIGFnZW50LgotICAgIGlmIChiYXNlRG9tYWluID09ICJ0YW9iYW8uY29tIikKKyAgICBp ZiAoY2hhc3Npc1R5cGUgIT0gQ2hhc3Npc1R5cGU6Ok1vYmlsZSAmJiBiYXNlRG9tYWluID09ICJ0 YW9iYW8uY29tIikKICAgICAgICAgcmV0dXJuIHRydWU7CiAKICAgICAvLyB3ZWIud2hhdHNhcHAu Y29tIGNvbXBsZXRlbHkgYmxvY2tzIHVzZXJzIHdpdGggV2ViS2l0R1RLJ3Mgc3RhbmRhcmQgdXNl ciBhZ2VudC4KQEAgLTE1MCwxMiArMTUwLDEyIEBAIHN0YXRpYyBib29sIHVybFJlcXVpcmVzTWFj aW50b3NoUGxhdGZvcm0oY29uc3QgVVJMJiB1cmwpCiAgICAgcmV0dXJuIGZhbHNlOwogfQogCi1z dGF0aWMgYm9vbCB1cmxSZXF1aXJlc0xpbnV4RGVza3RvcFBsYXRmb3JtKGNvbnN0IFVSTCYgdXJs KQorc3RhdGljIGJvb2wgdXJsUmVxdWlyZXNMaW51eERlc2t0b3BQbGF0Zm9ybShjb25zdCBVUkwm IHVybCwgQ2hhc3Npc1R5cGUgY2hhc3Npc1R5cGUpCiB7Ci0gICAgcmV0dXJuIGlzR29vZ2xlKHVy bCk7CisgICAgcmV0dXJuIGlzR29vZ2xlKHVybCkgJiYgY2hhc3Npc1R5cGUgIT0gQ2hhc3Npc1R5 cGU6Ok1vYmlsZTsKIH0KIAotVXNlckFnZW50UXVpcmtzIFVzZXJBZ2VudFF1aXJrczo6cXVpcmtz Rm9yVVJMKGNvbnN0IFVSTCYgdXJsKQorVXNlckFnZW50UXVpcmtzIFVzZXJBZ2VudFF1aXJrczo6 cXVpcmtzRm9yVVJMKGNvbnN0IFVSTCYgdXJsLCBDaGFzc2lzVHlwZSBjaGFzc2lzVHlwZSkKIHsK ICAgICBBU1NFUlQoIXVybC5pc051bGwoKSk7CiAKQEAgLTE2Niw5ICsxNjYsOSBAQCBVc2VyQWdl bnRRdWlya3MgVXNlckFnZW50UXVpcmtzOjpxdWlya3NGb3JVUkwoY29uc3QgVVJMJiB1cmwpCiAg ICAgZWxzZSBpZiAodXJsUmVxdWlyZXNGaXJlZm94QnJvd3Nlcih1cmwpKQogICAgICAgICBxdWly a3MuYWRkKFVzZXJBZ2VudFF1aXJrczo6TmVlZHNGaXJlZm94QnJvd3Nlcik7CiAKLSAgICBpZiAo dXJsUmVxdWlyZXNNYWNpbnRvc2hQbGF0Zm9ybSh1cmwpKQorICAgIGlmICh1cmxSZXF1aXJlc01h Y2ludG9zaFBsYXRmb3JtKHVybCwgY2hhc3Npc1R5cGUpKQogICAgICAgICBxdWlya3MuYWRkKFVz ZXJBZ2VudFF1aXJrczo6TmVlZHNNYWNpbnRvc2hQbGF0Zm9ybSk7Ci0gICAgZWxzZSBpZiAodXJs UmVxdWlyZXNMaW51eERlc2t0b3BQbGF0Zm9ybSh1cmwpKQorICAgIGVsc2UgaWYgKHVybFJlcXVp cmVzTGludXhEZXNrdG9wUGxhdGZvcm0odXJsLCBjaGFzc2lzVHlwZSkpCiAgICAgICAgIHF1aXJr cy5hZGQoVXNlckFnZW50UXVpcmtzOjpOZWVkc0xpbnV4RGVza3RvcFBsYXRmb3JtKTsKIAogICAg IHJldHVybiBxdWlya3M7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9Vc2Vy QWdlbnRRdWlya3MuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1VzZXJBZ2VudFF1aXJrcy5o CmluZGV4IDk4MmY4N2Y4YzFjNGFiOTBjN2NmYzBjYzg2ZjVjNGJmZTM2ZmFlZjMuLmYzYmE0NTI0 MzcxNjRiZjI4ZjE5ZDE2NWZhZDE3NzI2ZjRhMzJjY2MgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL1VzZXJBZ2VudFF1aXJrcy5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL1VzZXJBZ2VudFF1aXJrcy5oCkBAIC0yNSw2ICsyNSw3IEBACiAKICNwcmFnbWEgb25jZQog CisjaW5jbHVkZSAiVXNlckFnZW50LmgiCiAjaW5jbHVkZSA8d3RmL0Fzc2VydGlvbnMuaD4KICNp bmNsdWRlIDx3dGYvdGV4dC9XVEZTdHJpbmcuaD4KIApAQCAtNjIsNyArNjMsNyBAQCBwdWJsaWM6 CiAKICAgICBib29sIGlzRW1wdHkoKSBjb25zdCB7IHJldHVybiAhbV9xdWlya3M7IH0KIAotICAg IHN0YXRpYyBVc2VyQWdlbnRRdWlya3MgcXVpcmtzRm9yVVJMKGNvbnN0IFVSTCYpOworICAgIHN0 YXRpYyBVc2VyQWdlbnRRdWlya3MgcXVpcmtzRm9yVVJMKGNvbnN0IFVSTCYsIENoYXNzaXNUeXBl KTsKIAogICAgIHN0YXRpYyBTdHJpbmcgc3RyaW5nRm9yUXVpcmsoVXNlckFnZW50UXVpcmspOwog CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9nbGliL1VzZXJBZ2VudEdMaWIu Y3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ2xpYi9Vc2VyQWdlbnRHTGliLmNwcAppbmRl eCAzZTE2YzdhYWY3OTgxMjVjNGZmOGZlNzA3NGVjMjI3NDI4N2FkZTc5Li5jYWNiOGM4YTM0NWJk NWI0MzQyYzdkOWQ1ODVlNDliNmJmNmNiZDg4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9nbGliL1VzZXJBZ2VudEdMaWIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dsaWIvVXNlckFnZW50R0xpYi5jcHAKQEAgLTMxLDYgKzMxLDcgQEAKICNpbmNsdWRlICJV c2VyQWdlbnRRdWlya3MuaCIKICNpbmNsdWRlIDx3dGYvTmV2ZXJEZXN0cm95ZWQuaD4KICNpbmNs dWRlIDx3dGYvVVJMLmg+CisjaW5jbHVkZSA8d3RmL2dsaWIvR1VuaXF1ZVB0ci5oPgogI2luY2x1 ZGUgPHd0Zi90ZXh0L1N0cmluZ0J1aWxkZXIuaD4KIAogI2lmIE9TKFVOSVgpCkBAIC00NSwxMSAr NDYsMTI0IEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAorc3RhdGljIENoYXNzaXNUeXBlIHJl YWRNYWNoaW5lSW5mb0NoYXNzaXNUeXBlKCkKK3sKKyAgICBHVW5pcXVlT3V0UHRyPGNoYXI+IGJ1 ZmZlcjsKKyAgICBHVW5pcXVlT3V0UHRyPEdFcnJvcj4gZXJyb3I7CisgICAgaWYgKCFnX2ZpbGVf Z2V0X2NvbnRlbnRzKCIvZXRjL21hY2hpbmUtaW5mbyIsICZidWZmZXIub3V0UHRyKCksIG51bGxw dHIsICZlcnJvci5vdXRQdHIoKSkpIHsKKyAgICAgICAgaWYgKCFnX2Vycm9yX21hdGNoZXMoZXJy b3IuZ2V0KCksIEdfSU9fRVJST1IsIEdfSU9fRVJST1JfTk9UX0ZPVU5EKSkKKyAgICAgICAgICAg IGdfd2FybmluZygiQ291bGQgbm90IG9wZW4gL2V0Yy9tYWNoaW5lLWluZm86ICVzIiwgZXJyb3It Pm1lc3NhZ2UpOworICAgICAgICByZXR1cm4gQ2hhc3Npc1R5cGU6OlVua25vd247CisgICAgfQor CisgICAgR1VuaXF1ZVB0cjxjaGFyKj4gc3BsaXQoZ19zdHJzcGxpdChidWZmZXIuZ2V0KCksICJc biIsIC0xKSk7CisgICAgZm9yIChpbnQgaSA9IDA7IHNwbGl0LmdldCgpW2ldOyArK2kpIHsKKyAg ICAgICAgaWYgKGdfc3RyX2hhc19wcmVmaXgoc3BsaXQuZ2V0KClbaV0sICJDSEFTU0lTPSIpKSB7 CisgICAgICAgICAgICBjaGFyKiBjaGFzc2lzID0gc3BsaXQuZ2V0KClbaV0gKyA4OworICAgICAg ICAgICAgaWYgKCFzdHJjbXAoY2hhc3NpcywgInRhYmxldCIpIHx8ICFzdHJjbXAoY2hhc3Npcywg ImhhbmRzZXQiKSkKKyAgICAgICAgICAgICAgICByZXR1cm4gQ2hhc3Npc1R5cGU6Ok1vYmlsZTsK KworICAgICAgICAgICAgcmV0dXJuIENoYXNzaXNUeXBlOjpEZXNrdG9wOworICAgICAgICB9Cisg ICAgfQorCisgICAgcmV0dXJuIENoYXNzaXNUeXBlOjpVbmtub3duOworfQorCitzdGF0aWMgQ2hh c3Npc1R5cGUgcmVhZERNSUNoYXNzaXNUeXBlKCkKK3sKKyAgICBHVW5pcXVlT3V0UHRyPGNoYXI+ IGJ1ZmZlcjsKKyAgICBHVW5pcXVlT3V0UHRyPEdFcnJvcj4gZXJyb3I7CisgICAgaWYgKGdfZmls ZV9nZXRfY29udGVudHMoIi9zeXMvY2xhc3MvZG1pL2lkL2NoYXNzaXNfdHlwZSIsICZidWZmZXIu b3V0UHRyKCksIG51bGxwdHIsICZlcnJvci5vdXRQdHIoKSkpIHsKKyAgICAgICAgaW50IHR5cGUg PSBzdHJ0b2woYnVmZmVyLmdldCgpLCBudWxscHRyLCAxMCk7CisKKyAgICAgICAgLy8gU2VlIHRo ZSBTTUJJT1MgU3BlY2lmaWNhdGlvbiAzLjAgc2VjdGlvbiA3LjQuMSBmb3IgZGV0YWlscyBhYm91 dCB0aGUgdmFsdWVzIGxpc3RlZCBoZXJlOgorICAgICAgICAvLyBodHRwczovL3d3dy5kbXRmLm9y Zy9zaXRlcy9kZWZhdWx0L2ZpbGVzL3N0YW5kYXJkcy9kb2N1bWVudHMvRFNQMDEzNF8zLjAuMC5w ZGYKKyAgICAgICAgc3dpdGNoICh0eXBlKSB7CisgICAgICAgIGNhc2UgMHgzOiAvKiBEZXNrdG9w ICovCisgICAgICAgIGNhc2UgMHg0OiAvKiBMb3cgUHJvZmlsZSBEZXNrdG9wICovCisgICAgICAg IGNhc2UgMHg2OiAvKiBNaW5pIFRvd2VyICovCisgICAgICAgIGNhc2UgMHg3OiAvKiBUb3dlciAq LworICAgICAgICBjYXNlIDB4ODogLyogUG9ydGFibGUgKi8KKyAgICAgICAgY2FzZSAweDk6IC8q IExhcHRvcCAqLworICAgICAgICBjYXNlIDB4QTogLyogTm90ZWJvb2sgKi8KKyAgICAgICAgY2Fz ZSAweEU6IC8qIFN1YiBOb3RlYm9vayAqLworICAgICAgICBjYXNlIDB4MTE6IC8qIE1haW4gU2Vy dmVyIENoYXNzaXMgKi8KKyAgICAgICAgY2FzZSAweDFDOiAvKiBCbGFkZSAqLworICAgICAgICBj YXNlIDB4MUQ6IC8qIEJsYWRlIEVuY2xvc3VyZSAqLworICAgICAgICBjYXNlIDB4MUY6IC8qIENv bnZlcnRpYmxlICovCisgICAgICAgIGNhc2UgMHgyMDogLyogRGV0YWNoYWJsZSAqLworICAgICAg ICAgICAgcmV0dXJuIENoYXNzaXNUeXBlOjpEZXNrdG9wOworCisgICAgICAgIGNhc2UgMHhCOiAv KiBIYW5kIEhlbGQgKi8KKyAgICAgICAgY2FzZSAweDFFOiAvKiBUYWJsZXQgKi8KKyAgICAgICAg ICAgIHJldHVybiBDaGFzc2lzVHlwZTo6TW9iaWxlOworICAgICAgICB9CisgICAgfSBlbHNlIHsK KyAgICAgICAgaWYgKCFnX2Vycm9yX21hdGNoZXMoZXJyb3IuZ2V0KCksIEdfSU9fRVJST1IsIEdf SU9fRVJST1JfTk9UX0ZPVU5EKSkKKyAgICAgICAgICAgIGdfd2FybmluZygiQ291bGQgbm90IG9w ZW4gL3N5cy9jbGFzcy9kbWkvaWQvY2hhc3Npc190eXBlOiAlcyIsIGVycm9yLT5tZXNzYWdlKTsK KyAgICB9CisKKyAgICByZXR1cm4gQ2hhc3Npc1R5cGU6OlVua25vd247Cit9CisKK3N0YXRpYyBD aGFzc2lzVHlwZSByZWFkQUNQSUNoYXNzaXNUeXBlKCkKK3sKKyAgICBHVW5pcXVlT3V0UHRyPGNo YXI+IGJ1ZmZlcjsKKyAgICBHVW5pcXVlT3V0UHRyPEdFcnJvcj4gZXJyb3I7CisgICAgaWYgKGdf ZmlsZV9nZXRfY29udGVudHMoIi9zeXMvZmlybXdhcmUvYWNwaS9wbV9wcm9maWxlIiwgJmJ1ZmZl ci5vdXRQdHIoKSwgbnVsbHB0ciwgJmVycm9yLm91dFB0cigpKSkgeworICAgICAgICBpbnQgdHlw ZSA9IHN0cnRvbChidWZmZXIuZ2V0KCksIG51bGxwdHIsIDEwKTsKKworICAgICAgICAvLyBTZWUg dGhlIEFDUEkgNS4wIFNwZWMgU2VjdGlvbiA1LjIuOS4xIGZvciBkZXRhaWxzOgorICAgICAgICAv LyBodHRwOi8vd3d3LmFjcGkuaW5mby9ET1dOTE9BRFMvQUNQSXNwZWM1MC5wZGYKKyAgICAgICAg c3dpdGNoICh0eXBlKSB7CisgICAgICAgIGNhc2UgMTogLyogRGVza3RvcCAqLworICAgICAgICBj YXNlIDI6IC8qIE1vYmlsZSAqLworICAgICAgICBjYXNlIDM6IC8qIFdvcmtzdGF0aW9uICovCisg ICAgICAgIGNhc2UgNDogLyogRW50ZXJwcmlzZSBTZXJ2ZXIgKi8KKyAgICAgICAgY2FzZSA1OiAv KiBTT0hPIFNlcnZlciAqLworICAgICAgICBjYXNlIDY6IC8qIEFwcGxpYW5jZSBQQyAqLworICAg ICAgICBjYXNlIDc6IC8qIFBlcmZvcm1hbmNlIFNlcnZlciAqLworICAgICAgICAgICAgcmV0dXJu IENoYXNzaXNUeXBlOjpEZXNrdG9wOworCisgICAgICAgIGNhc2UgODogLyogVGFibGV0ICovCisg ICAgICAgICAgICByZXR1cm4gQ2hhc3Npc1R5cGU6Ok1vYmlsZTsKKyAgICAgICAgfQorICAgIH0g ZWxzZSB7CisgICAgICAgIGlmICghZ19lcnJvcl9tYXRjaGVzKGVycm9yLmdldCgpLCBHX0lPX0VS Uk9SLCBHX0lPX0VSUk9SX05PVF9GT1VORCkpCisgICAgICAgICAgICBnX3dhcm5pbmcoIkNvdWxk IG5vdCBvcGVuIC9zeXMvZmlybXdhcmUvYWNwaS9wbV9wcm9maWxlOiAlcyIsIGVycm9yLT5tZXNz YWdlKTsKKyAgICB9CisKKyAgICByZXR1cm4gQ2hhc3Npc1R5cGU6OlVua25vd247Cit9CisKK3N0 YXRpYyBDaGFzc2lzVHlwZSBnZXRDaGFzc2lzVHlwZSgpCit7CisgICAgc3RhdGljIENoYXNzaXNU eXBlIGNoYXNzaXNUeXBlOworICAgIHN0YXRpYyBib29sIGZpcnN0UnVuID0gdHJ1ZTsKKworICAg IGlmIChmaXJzdFJ1bikgeworICAgICAgICBjaGFzc2lzVHlwZSA9IHJlYWRNYWNoaW5lSW5mb0No YXNzaXNUeXBlKCk7CisgICAgICAgIGlmIChjaGFzc2lzVHlwZSA9PSBDaGFzc2lzVHlwZTo6VW5r bm93bikKKyAgICAgICAgICAgIGNoYXNzaXNUeXBlID0gcmVhZERNSUNoYXNzaXNUeXBlKCk7Cisg ICAgICAgIGlmIChjaGFzc2lzVHlwZSA9PSBDaGFzc2lzVHlwZTo6VW5rbm93bikKKyAgICAgICAg ICAgIGNoYXNzaXNUeXBlID0gcmVhZEFDUElDaGFzc2lzVHlwZSgpOworICAgICAgICBpZiAoY2hh c3Npc1R5cGUgPT0gQ2hhc3Npc1R5cGU6OlVua25vd24pCisgICAgICAgICAgICBjaGFzc2lzVHlw ZSA9IENoYXNzaXNUeXBlOjpEZXNrdG9wOworCisgICAgICAgIGZpcnN0UnVuID0gZmFsc2U7Cisg ICAgfQorCisgICAgcmV0dXJuIGNoYXNzaXNUeXBlOworfQorCiBzdGF0aWMgY29uc3QgY2hhciog cGxhdGZvcm1Gb3JVQVN0cmluZygpCiB7CiAjaWYgT1MoTUFDX09TX1gpCiAgICAgcmV0dXJuICJN YWNpbnRvc2giOwogI2Vsc2UKKyAgICBpZiAoZ2V0Q2hhc3Npc1R5cGUoKSA9PSBDaGFzc2lzVHlw ZTo6TW9iaWxlKQorICAgICAgICByZXR1cm4gIkxpbnV4IjsKICAgICByZXR1cm4gIlgxMSI7CiAj ZW5kaWYKIH0KQEAgLTU3LDYgKzE3MSw5IEBAIHN0YXRpYyBjb25zdCBjaGFyKiBwbGF0Zm9ybUZv clVBU3RyaW5nKCkKIHN0YXRpYyBjb25zdCBTdHJpbmcgcGxhdGZvcm1WZXJzaW9uRm9yVUFTdHJp bmcoKQogewogI2lmIE9TKFVOSVgpCisgICAgaWYgKGdldENoYXNzaXNUeXBlKCkgPT0gQ2hhc3Np c1R5cGU6Ok1vYmlsZSkKKyAgICAgICAgcmV0dXJuICJsaWtlIEFuZHJvaWQgNC40IjsKKwogICAg IHN0cnVjdCB1dHNuYW1lIG5hbWU7CiAgICAgdW5hbWUoJm5hbWUpOwogICAgIHN0YXRpYyBOZXZl ckRlc3Ryb3llZDxjb25zdCBTdHJpbmc+IHVhT1NWZXJzaW9uKG1ha2VTdHJpbmcobmFtZS5zeXNu YW1lLCAnICcsIG5hbWUubWFjaGluZSkpOwpAQCAtMTEzLDYgKzIzMCw5IEBAIHN0YXRpYyBTdHJp bmcgYnVpbGRVc2VyQWdlbnRTdHJpbmcoY29uc3QgVXNlckFnZW50UXVpcmtzJiBxdWlya3MpCiAg ICAgLy8gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEzMzQwMyBmb3Ig ZGV0YWlscy4KICAgICB9IGVsc2UKICAgICAgICAgdWFTdHJpbmcuYXBwZW5kTGl0ZXJhbCgiVmVy c2lvbi8xMy4wICIpOworCisgICAgaWYgKGdldENoYXNzaXNUeXBlKCkgPT0gQ2hhc3Npc1R5cGU6 Ok1vYmlsZSkKKyAgICAgICAgdWFTdHJpbmcuYXBwZW5kTGl0ZXJhbCgiTW9iaWxlICIpOwogICAg IHVhU3RyaW5nLmFwcGVuZExpdGVyYWwoIlNhZmFyaS8iKTsKICAgICB1YVN0cmluZy5hcHBlbmQo dmVyc2lvbkZvclVBU3RyaW5nKCkpOwogCkBAIC0xNTksNyArMjc5LDcgQEAgU3RyaW5nIHN0YW5k YXJkVXNlckFnZW50KGNvbnN0IFN0cmluZyYgYXBwbGljYXRpb25OYW1lLCBjb25zdCBTdHJpbmcm IGFwcGxpY2F0aW8KIAogU3RyaW5nIHN0YW5kYXJkVXNlckFnZW50Rm9yVVJMKGNvbnN0IFVSTCYg dXJsKQogewotICAgIGF1dG8gcXVpcmtzID0gVXNlckFnZW50UXVpcmtzOjpxdWlya3NGb3JVUkwo dXJsKTsKKyAgICBhdXRvIHF1aXJrcyA9IFVzZXJBZ2VudFF1aXJrczo6cXVpcmtzRm9yVVJMKHVy bCwgZ2V0Q2hhc3Npc1R5cGUoKSk7CiAgICAgLy8gVGhlIG51bGwgc3RyaW5nIG1lYW5zIHdlIGRv bid0IG5lZWQgYSBzcGVjaWZpYyBVQSBmb3IgdGhlIGdpdmVuIFVSTC4KICAgICBpZiAocXVpcmtz LmlzRW1wdHkoKSkKICAgICAgICAgcmV0dXJuIFN0cmluZygpOwo= 403775 2020-07-08 06:22:52 -0700 2020-07-08 06:32:09 -0700 Patch bug-149496-20200708152250.patch text/plain 11702 jan.brummer U3VidmVyc2lvbiBSZXZpc2lvbjogMjYzNjYzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggODc2MWFiMDQyYzc3MjNl M2ZiYTJmN2RlMmZmZTVjM2JjZmY3ZjU3Ni4uMGY1ZmZkOTdiNGM5ZmYyMjcxZWM0ZDljMzJkZGYy MDI3OTM4ODVjNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI1IEBACisyMDIwLTA2LTI5ICBKYW4t TWljaGFlbCBCcnVtbWVyICA8amFuLmJydW1tZXJAdGFib3Mub3JnPgorCisgICAgICAgIFtHVEtd W1dQRV0gVXNlIG1vYmlsZSB1c2VyLWFnZW50IG9uIHRhYmxldAorICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQ5NDk2CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzIChPT1BTISkuCisKKyAg ICAgICAgKiBwbGF0Zm9ybS9Vc2VyQWdlbnRRdWlya3MuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 dXJsUmVxdWlyZXNNYWNpbnRvc2hQbGF0Zm9ybSk6CisgICAgICAgIChXZWJDb3JlOjp1cmxSZXF1 aXJlc0xpbnV4RGVza3RvcFBsYXRmb3JtKToKKyAgICAgICAgKFdlYkNvcmU6OlVzZXJBZ2VudFF1 aXJrczo6cXVpcmtzRm9yVVJMKToKKyAgICAgICAgKiBwbGF0Zm9ybS9Vc2VyQWdlbnRRdWlya3Mu aDoKKyAgICAgICAgKiBwbGF0Zm9ybS9nbGliL1VzZXJBZ2VudEdMaWIuY3BwOgorICAgICAgICAo V2ViQ29yZTo6Z2V0Q2hhc3Npc1R5cGUpOgorICAgICAgICAoV2ViQ29yZTo6cGxhdGZvcm1Gb3JV QVN0cmluZyk6CisgICAgICAgIChXZWJDb3JlOjpwbGF0Zm9ybVZlcnNpb25Gb3JVQVN0cmluZyk6 CisgICAgICAgIChXZWJDb3JlOjpidWlsZFVzZXJBZ2VudFN0cmluZyk6CisgICAgICAgIChXZWJD b3JlOjpzdGFuZGFyZFVzZXJBZ2VudCk6CisgICAgICAgIChXZWJDb3JlOjpzdGFuZGFyZFVzZXJB Z2VudEZvclVSTCk6CisKIDIwMjAtMDYtMjkgIENocmlzIER1bWV6ICA8Y2R1bWV6QGFwcGxlLmNv bT4KIAogICAgICAgICBPbiBsb2FkIGZyb20gYmFjay9mb3J3YXJkIGNhY2hlLCBjYWxsIGNoZWNr Q29tcGxldGVkKCkgZm9yIEFMTCBmcmFtZXMgaW5zaWRlIEZyYW1lTG9hZGVyOjpjb21taXRQcm92 aXNpb25hbExvYWQoKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvUGxhdGZvcm1HVEsuY21h a2UgYi9Tb3VyY2UvV1RGL3d0Zi9QbGF0Zm9ybUdUSy5jbWFrZQppbmRleCBhMDRlMWQ4NWYxYThj NWUwZjk1MGI5OTJhYzkyMDIyZjU2NWQ2ZDdmLi40NWJiOWRkMTFiYTlkYWY0MzU5OWU1ZWIxZTI0 YmE0YzgwODA4MzMwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9QbGF0Zm9ybUdUSy5jbWFr ZQorKysgYi9Tb3VyY2UvV1RGL3d0Zi9QbGF0Zm9ybUdUSy5jbWFrZQpAQCAtMSw2ICsxLDcgQEAK IHNldChXVEZfT1VUUFVUX05BTUUgV1RGR1RLKQogCiBsaXN0KEFQUEVORCBXVEZfUFVCTElDX0hF QURFUlMKKyAgICBnbGliL0NoYXNzaXNUeXBlLmgKICAgICBnbGliL0dMaWJVdGlsaXRpZXMuaAog ICAgIGdsaWIvR011dGV4TG9ja2VyLmgKICAgICBnbGliL0dSZWZQdHIuaApAQCAtMjMsNiArMjQs NyBAQCBsaXN0KEFQUEVORCBXVEZfU09VUkNFUwogICAgIGdlbmVyaWMvTWFpblRocmVhZEdlbmVy aWMuY3BwCiAgICAgZ2VuZXJpYy9Xb3JrUXVldWVHZW5lcmljLmNwcAogCisgICAgZ2xpYi9DaGFz c2lzVHlwZS5jcHAKICAgICBnbGliL0ZpbGVTeXN0ZW1HbGliLmNwcAogICAgIGdsaWIvR0xpYlV0 aWxpdGllcy5jcHAKICAgICBnbGliL0dSZWZQdHIuY3BwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RG L3d0Zi9nbGliL0NoYXNzaXNUeXBlLmNwcCBiL1NvdXJjZS9XVEYvd3RmL2dsaWIvQ2hhc3Npc1R5 cGUuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAuLjU3Zjc3NThjN2EwNzY1MTJjNjIxN2ZiMjE0ZDBjNjQzN2NjM2Ew OTIKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9nbGliL0NoYXNzaXNUeXBlLmNw cApAQCAtMCwwICsxLDE0NCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAyMCBKYW4tTWljaGFl bCBCcnVtbWVyIDxqYW4uYnJ1bW1lckB0YWJvcy5vcmc+CisgKgorICogUmVkaXN0cmlidXRpb24g YW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNv ZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxp c3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVk aXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5 cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xs b3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVy IG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBT T0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBF WFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQg VE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklU TkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8g RVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1Ig QU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlks IE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8s CisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9G IFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9X RVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJ TiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdM SUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisg KiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9G IFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlIDx3dGYv Z2xpYi9DaGFzc2lzVHlwZS5oPgorCisjaW5jbHVkZSA8d3RmL2dsaWIvR1VuaXF1ZVB0ci5oPgor CituYW1lc3BhY2UgV1RGIHsKKworc3RhdGljIENoYXNzaXNUeXBlIHJlYWRNYWNoaW5lSW5mb0No YXNzaXNUeXBlKCkKK3sKKyAgICBHVW5pcXVlT3V0UHRyPGNoYXI+IGJ1ZmZlcjsKKyAgICBHVW5p cXVlT3V0UHRyPEdFcnJvcj4gZXJyb3I7CisgICAgaWYgKCFnX2ZpbGVfZ2V0X2NvbnRlbnRzKCIv ZXRjL21hY2hpbmUtaW5mbyIsICZidWZmZXIub3V0UHRyKCksIG51bGxwdHIsICZlcnJvci5vdXRQ dHIoKSkpIHsKKyAgICAgICAgaWYgKCFnX2Vycm9yX21hdGNoZXMoZXJyb3IuZ2V0KCksIEdfRklM RV9FUlJPUiwgR19GSUxFX0VSUk9SX05PRU5UKSkKKyAgICAgICAgICAgIGdfd2FybmluZygiQ291 bGQgbm90IG9wZW4gL2V0Yy9tYWNoaW5lLWluZm86ICVzIiwgZXJyb3ItPm1lc3NhZ2UpOworICAg ICAgICByZXR1cm4gQ2hhc3Npc1R5cGU6OlVua25vd247CisgICAgfQorCisgICAgR1VuaXF1ZVB0 cjxjaGFyKj4gc3BsaXQoZ19zdHJzcGxpdChidWZmZXIuZ2V0KCksICJcbiIsIC0xKSk7CisgICAg Zm9yIChpbnQgaSA9IDA7IHNwbGl0LmdldCgpW2ldOyArK2kpIHsKKyAgICAgICAgaWYgKGdfc3Ry X2hhc19wcmVmaXgoc3BsaXQuZ2V0KClbaV0sICJDSEFTU0lTPSIpKSB7CisgICAgICAgICAgICBj aGFyKiBjaGFzc2lzID0gc3BsaXQuZ2V0KClbaV0gKyA4OworICAgICAgICAgICAgaWYgKCFzdHJj bXAoY2hhc3NpcywgInRhYmxldCIpIHx8ICFzdHJjbXAoY2hhc3NpcywgImhhbmRzZXQiKSkKKyAg ICAgICAgICAgICAgICByZXR1cm4gQ2hhc3Npc1R5cGU6Ok1vYmlsZTsKKworICAgICAgICAgICAg cmV0dXJuIENoYXNzaXNUeXBlOjpEZXNrdG9wOworICAgICAgICB9CisgICAgfQorCisgICAgcmV0 dXJuIENoYXNzaXNUeXBlOjpVbmtub3duOworfQorCitzdGF0aWMgQ2hhc3Npc1R5cGUgcmVhZERN SUNoYXNzaXNUeXBlKCkKK3sKKyAgICBHVW5pcXVlT3V0UHRyPGNoYXI+IGJ1ZmZlcjsKKyAgICBH VW5pcXVlT3V0UHRyPEdFcnJvcj4gZXJyb3I7CisgICAgaWYgKGdfZmlsZV9nZXRfY29udGVudHMo Ii9zeXMvY2xhc3MvZG1pL2lkL2NoYXNzaXNfdHlwZSIsICZidWZmZXIub3V0UHRyKCksIG51bGxw dHIsICZlcnJvci5vdXRQdHIoKSkpIHsKKyAgICAgICAgaW50IHR5cGUgPSBzdHJ0b2woYnVmZmVy LmdldCgpLCBudWxscHRyLCAxMCk7CisKKyAgICAgICAgLy8gU2VlIHRoZSBTTUJJT1MgU3BlY2lm aWNhdGlvbiAzLjAgc2VjdGlvbiA3LjQuMSBmb3IgZGV0YWlscyBhYm91dCB0aGUgdmFsdWVzIGxp c3RlZCBoZXJlOgorICAgICAgICAvLyBodHRwczovL3d3dy5kbXRmLm9yZy9zaXRlcy9kZWZhdWx0 L2ZpbGVzL3N0YW5kYXJkcy9kb2N1bWVudHMvRFNQMDEzNF8zLjAuMC5wZGYKKyAgICAgICAgc3dp dGNoICh0eXBlKSB7CisgICAgICAgIGNhc2UgMHgzOiAvKiBEZXNrdG9wICovCisgICAgICAgIGNh c2UgMHg0OiAvKiBMb3cgUHJvZmlsZSBEZXNrdG9wICovCisgICAgICAgIGNhc2UgMHg2OiAvKiBN aW5pIFRvd2VyICovCisgICAgICAgIGNhc2UgMHg3OiAvKiBUb3dlciAqLworICAgICAgICBjYXNl IDB4ODogLyogUG9ydGFibGUgKi8KKyAgICAgICAgY2FzZSAweDk6IC8qIExhcHRvcCAqLworICAg ICAgICBjYXNlIDB4QTogLyogTm90ZWJvb2sgKi8KKyAgICAgICAgY2FzZSAweEU6IC8qIFN1YiBO b3RlYm9vayAqLworICAgICAgICBjYXNlIDB4MTE6IC8qIE1haW4gU2VydmVyIENoYXNzaXMgKi8K KyAgICAgICAgY2FzZSAweDFDOiAvKiBCbGFkZSAqLworICAgICAgICBjYXNlIDB4MUQ6IC8qIEJs YWRlIEVuY2xvc3VyZSAqLworICAgICAgICBjYXNlIDB4MUY6IC8qIENvbnZlcnRpYmxlICovCisg ICAgICAgIGNhc2UgMHgyMDogLyogRGV0YWNoYWJsZSAqLworICAgICAgICAgICAgcmV0dXJuIENo YXNzaXNUeXBlOjpEZXNrdG9wOworCisgICAgICAgIGNhc2UgMHhCOiAvKiBIYW5kIEhlbGQgKi8K KyAgICAgICAgY2FzZSAweDFFOiAvKiBUYWJsZXQgKi8KKyAgICAgICAgICAgIHJldHVybiBDaGFz c2lzVHlwZTo6TW9iaWxlOworICAgICAgICB9CisgICAgfSBlbHNlIHsKKyAgICAgICAgaWYgKCFn X2Vycm9yX21hdGNoZXMoZXJyb3IuZ2V0KCksIEdfRklMRV9FUlJPUiwgR19GSUxFX0VSUk9SX05P RU5UKSkKKyAgICAgICAgICAgIGdfd2FybmluZygiQ291bGQgbm90IG9wZW4gL3N5cy9jbGFzcy9k bWkvaWQvY2hhc3Npc190eXBlOiAlcyIsIGVycm9yLT5tZXNzYWdlKTsKKyAgICB9CisKKyAgICBy ZXR1cm4gQ2hhc3Npc1R5cGU6OlVua25vd247Cit9CisKK3N0YXRpYyBDaGFzc2lzVHlwZSByZWFk QUNQSUNoYXNzaXNUeXBlKCkKK3sKKyAgICBHVW5pcXVlT3V0UHRyPGNoYXI+IGJ1ZmZlcjsKKyAg ICBHVW5pcXVlT3V0UHRyPEdFcnJvcj4gZXJyb3I7CisgICAgaWYgKGdfZmlsZV9nZXRfY29udGVu dHMoIi9zeXMvZmlybXdhcmUvYWNwaS9wbV9wcm9maWxlIiwgJmJ1ZmZlci5vdXRQdHIoKSwgbnVs bHB0ciwgJmVycm9yLm91dFB0cigpKSkgeworICAgICAgICBpbnQgdHlwZSA9IHN0cnRvbChidWZm ZXIuZ2V0KCksIG51bGxwdHIsIDEwKTsKKworICAgICAgICAvLyBTZWUgdGhlIEFDUEkgNS4wIFNw ZWMgU2VjdGlvbiA1LjIuOS4xIGZvciBkZXRhaWxzOgorICAgICAgICAvLyBodHRwOi8vd3d3LmFj cGkuaW5mby9ET1dOTE9BRFMvQUNQSXNwZWM1MC5wZGYKKyAgICAgICAgc3dpdGNoICh0eXBlKSB7 CisgICAgICAgIGNhc2UgMTogLyogRGVza3RvcCAqLworICAgICAgICBjYXNlIDI6IC8qIE1vYmls ZSAqLworICAgICAgICBjYXNlIDM6IC8qIFdvcmtzdGF0aW9uICovCisgICAgICAgIGNhc2UgNDog LyogRW50ZXJwcmlzZSBTZXJ2ZXIgKi8KKyAgICAgICAgY2FzZSA1OiAvKiBTT0hPIFNlcnZlciAq LworICAgICAgICBjYXNlIDY6IC8qIEFwcGxpYW5jZSBQQyAqLworICAgICAgICBjYXNlIDc6IC8q IFBlcmZvcm1hbmNlIFNlcnZlciAqLworICAgICAgICAgICAgcmV0dXJuIENoYXNzaXNUeXBlOjpE ZXNrdG9wOworCisgICAgICAgIGNhc2UgODogLyogVGFibGV0ICovCisgICAgICAgICAgICByZXR1 cm4gQ2hhc3Npc1R5cGU6Ok1vYmlsZTsKKyAgICAgICAgfQorICAgIH0gZWxzZSB7CisgICAgICAg IGlmICghZ19lcnJvcl9tYXRjaGVzKGVycm9yLmdldCgpLCBHX0ZJTEVfRVJST1IsIEdfRklMRV9F UlJPUl9OT0VOVCkpCisgICAgICAgICAgICBnX3dhcm5pbmcoIkNvdWxkIG5vdCBvcGVuIC9zeXMv ZmlybXdhcmUvYWNwaS9wbV9wcm9maWxlOiAlcyIsIGVycm9yLT5tZXNzYWdlKTsKKyAgICB9CisK KyAgICByZXR1cm4gQ2hhc3Npc1R5cGU6OlVua25vd247Cit9CisKK0NoYXNzaXNUeXBlIGNoYXNz aXNUeXBlKCkKK3sKKyAgICBzdGF0aWMgQ2hhc3Npc1R5cGUgY2hhc3Npc1R5cGU7CisgICAgc3Rh dGljIGJvb2wgZmlyc3RSdW4gPSB0cnVlOworCisgICAgaWYgKGZpcnN0UnVuKSB7CisgICAgICAg IGNoYXNzaXNUeXBlID0gcmVhZE1hY2hpbmVJbmZvQ2hhc3Npc1R5cGUoKTsKKyAgICAgICAgaWYg KGNoYXNzaXNUeXBlID09IENoYXNzaXNUeXBlOjpVbmtub3duKQorICAgICAgICAgICAgY2hhc3Np c1R5cGUgPSByZWFkRE1JQ2hhc3Npc1R5cGUoKTsKKyAgICAgICAgaWYgKGNoYXNzaXNUeXBlID09 IENoYXNzaXNUeXBlOjpVbmtub3duKQorICAgICAgICAgICAgY2hhc3Npc1R5cGUgPSByZWFkQUNQ SUNoYXNzaXNUeXBlKCk7CisgICAgICAgIGlmIChjaGFzc2lzVHlwZSA9PSBDaGFzc2lzVHlwZTo6 VW5rbm93bikKKyAgICAgICAgICAgIGNoYXNzaXNUeXBlID0gQ2hhc3Npc1R5cGU6OkRlc2t0b3A7 CisKKyAgICAgICAgZmlyc3RSdW4gPSBmYWxzZTsKKyAgICB9CisKKyAgICByZXR1cm4gY2hhc3Np c1R5cGU7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdURgpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93 dGYvZ2xpYi9DaGFzc2lzVHlwZS5oIGIvU291cmNlL1dURi93dGYvZ2xpYi9DaGFzc2lzVHlwZS5o Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAuLjg2YjUwMzllZTk3MjE3OTdiZGUxN2YzY2Y1MjE2ODM0MjNmZmRhNTIKLS0t IC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9nbGliL0NoYXNzaXNUeXBlLmgKQEAgLTAs MCArMSwzNCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAyMCBKYW4tTWljaGFlbCBCcnVtbWVy IDxqYW4uYnJ1bW1lckB0YWJvcy5vcmc+CisgKgorICogIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNv ZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqICBtb2RpZnkgaXQgdW5k ZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYworICogIExpY2Vu c2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgor ICogIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0 ZXIgdmVyc2lvbi4KKyAqCisgKiAgVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBo b3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZ OyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqICBNRVJDSEFOVEFCSUxJ VFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICog IExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAq ICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5l cmFsIFB1YmxpYyBMaWNlbnNlCisgKiAgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUg ZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAqICB0aGUgRnJlZSBTb2Z0d2Fy ZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICog IEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgorICovCisKKyNwcmFnbWEgb25jZQorCituYW1l c3BhY2UgV1RGIHsKKworZW51bSBjbGFzcyBDaGFzc2lzVHlwZSB7CisgICAgVW5rbm93biwKKyAg ICBEZXNrdG9wLAorICAgIE1vYmlsZQorfTsKKworV1RGX0VYUE9SVF9QUklWQVRFIENoYXNzaXNU eXBlIGNoYXNzaXNUeXBlKCk7CisKK30gLy8gbmFtZXNwYWNlIFdURgorCit1c2luZyBXVEY6OmNo YXNzaXNUeXBlOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVXNlckFnZW50 UXVpcmtzLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1VzZXJBZ2VudFF1aXJrcy5jcHAK aW5kZXggNGFiZGI4NmI3ZDc5ZDU4OWMwMThhN2UyYjEwNGU0NTllY2FmZWQ0My4uMTA1M2E3YWE3 NTMwZjVhZThhODY3ZWI4OWVkNzBlOWRkZjYxNDAxOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vVXNlckFnZW50UXVpcmtzLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9Vc2VyQWdlbnRRdWlya3MuY3BwCkBAIC0yOCw2ICsyOCw3IEBACiAKICNpbmNsdWRlICJQ dWJsaWNTdWZmaXguaCIKICNpbmNsdWRlIDx3dGYvVVJMLmg+CisjaW5jbHVkZSA8d3RmL2dsaWIv Q2hhc3Npc1R5cGUuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCkBAIC0xMTksMTEgKzEyMCwx MSBAQCBzdGF0aWMgYm9vbCB1cmxSZXF1aXJlc01hY2ludG9zaFBsYXRmb3JtKGNvbnN0IFVSTCYg dXJsKQogICAgIFN0cmluZyBiYXNlRG9tYWluID0gdG9wUHJpdmF0ZWx5Q29udHJvbGxlZERvbWFp bihkb21haW4pOwogCiAgICAgLy8gQXQgbGVhc3QgZmluYW5jZS55YWhvby5jb20gZGlzcGxheXMg YSBtb2JpbGUgdmVyc2lvbiB3aXRoIFdlYktpdEdUSydzIHN0YW5kYXJkIHVzZXIgYWdlbnQuCi0g ICAgaWYgKGJhc2VEb21haW4gPT0gInlhaG9vLmNvbSIpCisgICAgaWYgKGNoYXNzaXNUeXBlKCkg IT0gV1RGOjpDaGFzc2lzVHlwZTo6TW9iaWxlICYmIGJhc2VEb21haW4gPT0gInlhaG9vLmNvbSIp CiAgICAgICAgIHJldHVybiB0cnVlOwogCiAgICAgLy8gdGFvYmFvLmNvbSBkaXNwbGF5cyBhIG1v YmlsZSB2ZXJzaW9uIHdpdGggV2ViS2l0R1RLJ3Mgc3RhbmRhcmQgdXNlciBhZ2VudC4KLSAgICBp ZiAoYmFzZURvbWFpbiA9PSAidGFvYmFvLmNvbSIpCisgICAgaWYgKGNoYXNzaXNUeXBlKCkgIT0g V1RGOjpDaGFzc2lzVHlwZTo6TW9iaWxlICYmIGJhc2VEb21haW4gPT0gInRhb2Jhby5jb20iKQog ICAgICAgICByZXR1cm4gdHJ1ZTsKIAogICAgIC8vIHdlYi53aGF0c2FwcC5jb20gY29tcGxldGVs eSBibG9ja3MgdXNlcnMgd2l0aCBXZWJLaXRHVEsncyBzdGFuZGFyZCB1c2VyIGFnZW50LgpAQCAt MTUyLDcgKzE1Myw3IEBAIHN0YXRpYyBib29sIHVybFJlcXVpcmVzTWFjaW50b3NoUGxhdGZvcm0o Y29uc3QgVVJMJiB1cmwpCiAKIHN0YXRpYyBib29sIHVybFJlcXVpcmVzTGludXhEZXNrdG9wUGxh dGZvcm0oY29uc3QgVVJMJiB1cmwpCiB7Ci0gICAgcmV0dXJuIGlzR29vZ2xlKHVybCk7CisgICAg cmV0dXJuIGlzR29vZ2xlKHVybCkgJiYgY2hhc3Npc1R5cGUoKSAhPSBXVEY6OkNoYXNzaXNUeXBl OjpNb2JpbGU7CiB9CiAKIFVzZXJBZ2VudFF1aXJrcyBVc2VyQWdlbnRRdWlya3M6OnF1aXJrc0Zv clVSTChjb25zdCBVUkwmIHVybCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dsaWIvVXNlckFnZW50R0xpYi5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9nbGliL1Vz ZXJBZ2VudEdMaWIuY3BwCmluZGV4IDNlMTZjN2FhZjc5ODEyNWM0ZmY4ZmU3MDc0ZWMyMjc0Mjg3 YWRlNzkuLmE1ODA4MWY0Y2IzYzY1YzA3MjBmZTkyNmY1NDk2MzA0MGFlYzE2ZDkgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dsaWIvVXNlckFnZW50R0xpYi5jcHAKKysrIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ2xpYi9Vc2VyQWdlbnRHTGliLmNwcApAQCAtMzEsNiAr MzEsNyBAQAogI2luY2x1ZGUgIlVzZXJBZ2VudFF1aXJrcy5oIgogI2luY2x1ZGUgPHd0Zi9OZXZl ckRlc3Ryb3llZC5oPgogI2luY2x1ZGUgPHd0Zi9VUkwuaD4KKyNpbmNsdWRlIDx3dGYvZ2xpYi9D aGFzc2lzVHlwZS5oPgogI2luY2x1ZGUgPHd0Zi90ZXh0L1N0cmluZ0J1aWxkZXIuaD4KIAogI2lm IE9TKFVOSVgpCkBAIC01MCw2ICs1MSw4IEBAIHN0YXRpYyBjb25zdCBjaGFyKiBwbGF0Zm9ybUZv clVBU3RyaW5nKCkKICNpZiBPUyhNQUNfT1NfWCkKICAgICByZXR1cm4gIk1hY2ludG9zaCI7CiAj ZWxzZQorICAgIGlmIChjaGFzc2lzVHlwZSgpID09IFdURjo6Q2hhc3Npc1R5cGU6Ok1vYmlsZSkK KyAgICAgICAgcmV0dXJuICJMaW51eCI7CiAgICAgcmV0dXJuICJYMTEiOwogI2VuZGlmCiB9CkBA IC01Nyw2ICs2MCw5IEBAIHN0YXRpYyBjb25zdCBjaGFyKiBwbGF0Zm9ybUZvclVBU3RyaW5nKCkK IHN0YXRpYyBjb25zdCBTdHJpbmcgcGxhdGZvcm1WZXJzaW9uRm9yVUFTdHJpbmcoKQogewogI2lm IE9TKFVOSVgpCisgICAgaWYgKGNoYXNzaXNUeXBlKCkgPT0gV1RGOjpDaGFzc2lzVHlwZTo6TW9i aWxlKQorICAgICAgICByZXR1cm4gImxpa2UgQW5kcm9pZCA0LjQiOworCiAgICAgc3RydWN0IHV0 c25hbWUgbmFtZTsKICAgICB1bmFtZSgmbmFtZSk7CiAgICAgc3RhdGljIE5ldmVyRGVzdHJveWVk PGNvbnN0IFN0cmluZz4gdWFPU1ZlcnNpb24obWFrZVN0cmluZyhuYW1lLnN5c25hbWUsICcgJywg bmFtZS5tYWNoaW5lKSk7CkBAIC0xMTMsNiArMTE5LDkgQEAgc3RhdGljIFN0cmluZyBidWlsZFVz ZXJBZ2VudFN0cmluZyhjb25zdCBVc2VyQWdlbnRRdWlya3MmIHF1aXJrcykKICAgICAvLyBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTMzNDAzIGZvciBkZXRhaWxzLgog ICAgIH0gZWxzZQogICAgICAgICB1YVN0cmluZy5hcHBlbmRMaXRlcmFsKCJWZXJzaW9uLzEzLjAg Iik7CisKKyAgICBpZiAoY2hhc3Npc1R5cGUoKSA9PSBXVEY6OkNoYXNzaXNUeXBlOjpNb2JpbGUp CisgICAgICAgIHVhU3RyaW5nLmFwcGVuZExpdGVyYWwoIk1vYmlsZSAiKTsKICAgICB1YVN0cmlu Zy5hcHBlbmRMaXRlcmFsKCJTYWZhcmkvIik7CiAgICAgdWFTdHJpbmcuYXBwZW5kKHZlcnNpb25G b3JVQVN0cmluZygpKTsKIAo= 403776 2020-07-08 06:32:15 -0700 2020-07-09 07:20:21 -0700 Patch bug-149496-20200708153214.patch text/plain 11726 jan.brummer U3VidmVyc2lvbiBSZXZpc2lvbjogMjYzNjYzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggODc2MWFiMDQyYzc3MjNl M2ZiYTJmN2RlMmZmZTVjM2JjZmY3ZjU3Ni4uMGY1ZmZkOTdiNGM5ZmYyMjcxZWM0ZDljMzJkZGYy MDI3OTM4ODVjNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI1IEBACisyMDIwLTA2LTI5ICBKYW4t TWljaGFlbCBCcnVtbWVyICA8amFuLmJydW1tZXJAdGFib3Mub3JnPgorCisgICAgICAgIFtHVEtd W1dQRV0gVXNlIG1vYmlsZSB1c2VyLWFnZW50IG9uIHRhYmxldAorICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQ5NDk2CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzIChPT1BTISkuCisKKyAg ICAgICAgKiBwbGF0Zm9ybS9Vc2VyQWdlbnRRdWlya3MuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 dXJsUmVxdWlyZXNNYWNpbnRvc2hQbGF0Zm9ybSk6CisgICAgICAgIChXZWJDb3JlOjp1cmxSZXF1 aXJlc0xpbnV4RGVza3RvcFBsYXRmb3JtKToKKyAgICAgICAgKFdlYkNvcmU6OlVzZXJBZ2VudFF1 aXJrczo6cXVpcmtzRm9yVVJMKToKKyAgICAgICAgKiBwbGF0Zm9ybS9Vc2VyQWdlbnRRdWlya3Mu aDoKKyAgICAgICAgKiBwbGF0Zm9ybS9nbGliL1VzZXJBZ2VudEdMaWIuY3BwOgorICAgICAgICAo V2ViQ29yZTo6Z2V0Q2hhc3Npc1R5cGUpOgorICAgICAgICAoV2ViQ29yZTo6cGxhdGZvcm1Gb3JV QVN0cmluZyk6CisgICAgICAgIChXZWJDb3JlOjpwbGF0Zm9ybVZlcnNpb25Gb3JVQVN0cmluZyk6 CisgICAgICAgIChXZWJDb3JlOjpidWlsZFVzZXJBZ2VudFN0cmluZyk6CisgICAgICAgIChXZWJD b3JlOjpzdGFuZGFyZFVzZXJBZ2VudCk6CisgICAgICAgIChXZWJDb3JlOjpzdGFuZGFyZFVzZXJB Z2VudEZvclVSTCk6CisKIDIwMjAtMDYtMjkgIENocmlzIER1bWV6ICA8Y2R1bWV6QGFwcGxlLmNv bT4KIAogICAgICAgICBPbiBsb2FkIGZyb20gYmFjay9mb3J3YXJkIGNhY2hlLCBjYWxsIGNoZWNr Q29tcGxldGVkKCkgZm9yIEFMTCBmcmFtZXMgaW5zaWRlIEZyYW1lTG9hZGVyOjpjb21taXRQcm92 aXNpb25hbExvYWQoKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvUGxhdGZvcm1HVEsuY21h a2UgYi9Tb3VyY2UvV1RGL3d0Zi9QbGF0Zm9ybUdUSy5jbWFrZQppbmRleCBhMDRlMWQ4NWYxYThj NWUwZjk1MGI5OTJhYzkyMDIyZjU2NWQ2ZDdmLi40NWJiOWRkMTFiYTlkYWY0MzU5OWU1ZWIxZTI0 YmE0YzgwODA4MzMwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9QbGF0Zm9ybUdUSy5jbWFr ZQorKysgYi9Tb3VyY2UvV1RGL3d0Zi9QbGF0Zm9ybUdUSy5jbWFrZQpAQCAtMSw2ICsxLDcgQEAK IHNldChXVEZfT1VUUFVUX05BTUUgV1RGR1RLKQogCiBsaXN0KEFQUEVORCBXVEZfUFVCTElDX0hF QURFUlMKKyAgICBnbGliL0NoYXNzaXNUeXBlLmgKICAgICBnbGliL0dMaWJVdGlsaXRpZXMuaAog ICAgIGdsaWIvR011dGV4TG9ja2VyLmgKICAgICBnbGliL0dSZWZQdHIuaApAQCAtMjMsNiArMjQs NyBAQCBsaXN0KEFQUEVORCBXVEZfU09VUkNFUwogICAgIGdlbmVyaWMvTWFpblRocmVhZEdlbmVy aWMuY3BwCiAgICAgZ2VuZXJpYy9Xb3JrUXVldWVHZW5lcmljLmNwcAogCisgICAgZ2xpYi9DaGFz c2lzVHlwZS5jcHAKICAgICBnbGliL0ZpbGVTeXN0ZW1HbGliLmNwcAogICAgIGdsaWIvR0xpYlV0 aWxpdGllcy5jcHAKICAgICBnbGliL0dSZWZQdHIuY3BwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RG L3d0Zi9nbGliL0NoYXNzaXNUeXBlLmNwcCBiL1NvdXJjZS9XVEYvd3RmL2dsaWIvQ2hhc3Npc1R5 cGUuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAuLjcyODBhN2Q4MDMyNDczNmE2MmQ4ZGZmODJlOTk2MDI0MDYwMWUw NGEKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9nbGliL0NoYXNzaXNUeXBlLmNw cApAQCAtMCwwICsxLDE0MiBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAyMCBKYW4tTWljaGFl bCBCcnVtbWVyIDxqYW4uYnJ1bW1lckB0YWJvcy5vcmc+CisgKgorICogUmVkaXN0cmlidXRpb24g YW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNv ZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxp c3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVk aXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5 cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xs b3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVy IG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBT T0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBF WFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQg VE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklU TkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8g RVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1Ig QU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlks IE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8s CisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9G IFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9X RVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJ TiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdM SUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisg KiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9G IFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlIDx3dGYv Z2xpYi9DaGFzc2lzVHlwZS5oPgorCisjaW5jbHVkZSA8bXV0ZXg+CisjaW5jbHVkZSA8d3RmL2ds aWIvR1VuaXF1ZVB0ci5oPgorCituYW1lc3BhY2UgV1RGIHsKKworc3RhdGljIENoYXNzaXNUeXBl IHJlYWRNYWNoaW5lSW5mb0NoYXNzaXNUeXBlKCkKK3sKKyAgICBHVW5pcXVlT3V0UHRyPGNoYXI+ IGJ1ZmZlcjsKKyAgICBHVW5pcXVlT3V0UHRyPEdFcnJvcj4gZXJyb3I7CisgICAgaWYgKCFnX2Zp bGVfZ2V0X2NvbnRlbnRzKCIvZXRjL21hY2hpbmUtaW5mbyIsICZidWZmZXIub3V0UHRyKCksIG51 bGxwdHIsICZlcnJvci5vdXRQdHIoKSkpIHsKKyAgICAgICAgaWYgKCFnX2Vycm9yX21hdGNoZXMo ZXJyb3IuZ2V0KCksIEdfRklMRV9FUlJPUiwgR19GSUxFX0VSUk9SX05PRU5UKSkKKyAgICAgICAg ICAgIGdfd2FybmluZygiQ291bGQgbm90IG9wZW4gL2V0Yy9tYWNoaW5lLWluZm86ICVzIiwgZXJy b3ItPm1lc3NhZ2UpOworICAgICAgICByZXR1cm4gQ2hhc3Npc1R5cGU6OlVua25vd247CisgICAg fQorCisgICAgR1VuaXF1ZVB0cjxjaGFyKj4gc3BsaXQoZ19zdHJzcGxpdChidWZmZXIuZ2V0KCks ICJcbiIsIC0xKSk7CisgICAgZm9yIChpbnQgaSA9IDA7IHNwbGl0LmdldCgpW2ldOyArK2kpIHsK KyAgICAgICAgaWYgKGdfc3RyX2hhc19wcmVmaXgoc3BsaXQuZ2V0KClbaV0sICJDSEFTU0lTPSIp KSB7CisgICAgICAgICAgICBjaGFyKiBjaGFzc2lzID0gc3BsaXQuZ2V0KClbaV0gKyA4OworICAg ICAgICAgICAgaWYgKCFzdHJjbXAoY2hhc3NpcywgInRhYmxldCIpIHx8ICFzdHJjbXAoY2hhc3Np cywgImhhbmRzZXQiKSkKKyAgICAgICAgICAgICAgICByZXR1cm4gQ2hhc3Npc1R5cGU6Ok1vYmls ZTsKKworICAgICAgICAgICAgcmV0dXJuIENoYXNzaXNUeXBlOjpEZXNrdG9wOworICAgICAgICB9 CisgICAgfQorCisgICAgcmV0dXJuIENoYXNzaXNUeXBlOjpVbmtub3duOworfQorCitzdGF0aWMg Q2hhc3Npc1R5cGUgcmVhZERNSUNoYXNzaXNUeXBlKCkKK3sKKyAgICBHVW5pcXVlT3V0UHRyPGNo YXI+IGJ1ZmZlcjsKKyAgICBHVW5pcXVlT3V0UHRyPEdFcnJvcj4gZXJyb3I7CisgICAgaWYgKGdf ZmlsZV9nZXRfY29udGVudHMoIi9zeXMvY2xhc3MvZG1pL2lkL2NoYXNzaXNfdHlwZSIsICZidWZm ZXIub3V0UHRyKCksIG51bGxwdHIsICZlcnJvci5vdXRQdHIoKSkpIHsKKyAgICAgICAgaW50IHR5 cGUgPSBzdHJ0b2woYnVmZmVyLmdldCgpLCBudWxscHRyLCAxMCk7CisKKyAgICAgICAgLy8gU2Vl IHRoZSBTTUJJT1MgU3BlY2lmaWNhdGlvbiAzLjAgc2VjdGlvbiA3LjQuMSBmb3IgZGV0YWlscyBh Ym91dCB0aGUgdmFsdWVzIGxpc3RlZCBoZXJlOgorICAgICAgICAvLyBodHRwczovL3d3dy5kbXRm Lm9yZy9zaXRlcy9kZWZhdWx0L2ZpbGVzL3N0YW5kYXJkcy9kb2N1bWVudHMvRFNQMDEzNF8zLjAu MC5wZGYKKyAgICAgICAgc3dpdGNoICh0eXBlKSB7CisgICAgICAgIGNhc2UgMHgzOiAvKiBEZXNr dG9wICovCisgICAgICAgIGNhc2UgMHg0OiAvKiBMb3cgUHJvZmlsZSBEZXNrdG9wICovCisgICAg ICAgIGNhc2UgMHg2OiAvKiBNaW5pIFRvd2VyICovCisgICAgICAgIGNhc2UgMHg3OiAvKiBUb3dl ciAqLworICAgICAgICBjYXNlIDB4ODogLyogUG9ydGFibGUgKi8KKyAgICAgICAgY2FzZSAweDk6 IC8qIExhcHRvcCAqLworICAgICAgICBjYXNlIDB4QTogLyogTm90ZWJvb2sgKi8KKyAgICAgICAg Y2FzZSAweEU6IC8qIFN1YiBOb3RlYm9vayAqLworICAgICAgICBjYXNlIDB4MTE6IC8qIE1haW4g U2VydmVyIENoYXNzaXMgKi8KKyAgICAgICAgY2FzZSAweDFDOiAvKiBCbGFkZSAqLworICAgICAg ICBjYXNlIDB4MUQ6IC8qIEJsYWRlIEVuY2xvc3VyZSAqLworICAgICAgICBjYXNlIDB4MUY6IC8q IENvbnZlcnRpYmxlICovCisgICAgICAgIGNhc2UgMHgyMDogLyogRGV0YWNoYWJsZSAqLworICAg ICAgICAgICAgcmV0dXJuIENoYXNzaXNUeXBlOjpEZXNrdG9wOworCisgICAgICAgIGNhc2UgMHhC OiAvKiBIYW5kIEhlbGQgKi8KKyAgICAgICAgY2FzZSAweDFFOiAvKiBUYWJsZXQgKi8KKyAgICAg ICAgICAgIHJldHVybiBDaGFzc2lzVHlwZTo6TW9iaWxlOworICAgICAgICB9CisgICAgfSBlbHNl IHsKKyAgICAgICAgaWYgKCFnX2Vycm9yX21hdGNoZXMoZXJyb3IuZ2V0KCksIEdfRklMRV9FUlJP UiwgR19GSUxFX0VSUk9SX05PRU5UKSkKKyAgICAgICAgICAgIGdfd2FybmluZygiQ291bGQgbm90 IG9wZW4gL3N5cy9jbGFzcy9kbWkvaWQvY2hhc3Npc190eXBlOiAlcyIsIGVycm9yLT5tZXNzYWdl KTsKKyAgICB9CisKKyAgICByZXR1cm4gQ2hhc3Npc1R5cGU6OlVua25vd247Cit9CisKK3N0YXRp YyBDaGFzc2lzVHlwZSByZWFkQUNQSUNoYXNzaXNUeXBlKCkKK3sKKyAgICBHVW5pcXVlT3V0UHRy PGNoYXI+IGJ1ZmZlcjsKKyAgICBHVW5pcXVlT3V0UHRyPEdFcnJvcj4gZXJyb3I7CisgICAgaWYg KGdfZmlsZV9nZXRfY29udGVudHMoIi9zeXMvZmlybXdhcmUvYWNwaS9wbV9wcm9maWxlIiwgJmJ1 ZmZlci5vdXRQdHIoKSwgbnVsbHB0ciwgJmVycm9yLm91dFB0cigpKSkgeworICAgICAgICBpbnQg dHlwZSA9IHN0cnRvbChidWZmZXIuZ2V0KCksIG51bGxwdHIsIDEwKTsKKworICAgICAgICAvLyBT ZWUgdGhlIEFDUEkgNS4wIFNwZWMgU2VjdGlvbiA1LjIuOS4xIGZvciBkZXRhaWxzOgorICAgICAg ICAvLyBodHRwOi8vd3d3LmFjcGkuaW5mby9ET1dOTE9BRFMvQUNQSXNwZWM1MC5wZGYKKyAgICAg ICAgc3dpdGNoICh0eXBlKSB7CisgICAgICAgIGNhc2UgMTogLyogRGVza3RvcCAqLworICAgICAg ICBjYXNlIDI6IC8qIE1vYmlsZSAqLworICAgICAgICBjYXNlIDM6IC8qIFdvcmtzdGF0aW9uICov CisgICAgICAgIGNhc2UgNDogLyogRW50ZXJwcmlzZSBTZXJ2ZXIgKi8KKyAgICAgICAgY2FzZSA1 OiAvKiBTT0hPIFNlcnZlciAqLworICAgICAgICBjYXNlIDY6IC8qIEFwcGxpYW5jZSBQQyAqLwor ICAgICAgICBjYXNlIDc6IC8qIFBlcmZvcm1hbmNlIFNlcnZlciAqLworICAgICAgICAgICAgcmV0 dXJuIENoYXNzaXNUeXBlOjpEZXNrdG9wOworCisgICAgICAgIGNhc2UgODogLyogVGFibGV0ICov CisgICAgICAgICAgICByZXR1cm4gQ2hhc3Npc1R5cGU6Ok1vYmlsZTsKKyAgICAgICAgfQorICAg IH0gZWxzZSB7CisgICAgICAgIGlmICghZ19lcnJvcl9tYXRjaGVzKGVycm9yLmdldCgpLCBHX0ZJ TEVfRVJST1IsIEdfRklMRV9FUlJPUl9OT0VOVCkpCisgICAgICAgICAgICBnX3dhcm5pbmcoIkNv dWxkIG5vdCBvcGVuIC9zeXMvZmlybXdhcmUvYWNwaS9wbV9wcm9maWxlOiAlcyIsIGVycm9yLT5t ZXNzYWdlKTsKKyAgICB9CisKKyAgICByZXR1cm4gQ2hhc3Npc1R5cGU6OlVua25vd247Cit9CisK K0NoYXNzaXNUeXBlIGNoYXNzaXNUeXBlKCkKK3sKKyAgICBzdGF0aWMgQ2hhc3Npc1R5cGUgY2hh c3Npc1R5cGU7CisgICAgc3RhdGljIHN0ZDo6b25jZV9mbGFnIGluaXRpYWxpemVDaGFzc2lzOwor ICAgIHN0ZDo6Y2FsbF9vbmNlKGluaXRpYWxpemVDaGFzc2lzLCBbXSB7CisgICAgICAgIGNoYXNz aXNUeXBlID0gcmVhZE1hY2hpbmVJbmZvQ2hhc3Npc1R5cGUoKTsKKyAgICAgICAgaWYgKGNoYXNz aXNUeXBlID09IENoYXNzaXNUeXBlOjpVbmtub3duKQorICAgICAgICAgICAgY2hhc3Npc1R5cGUg PSByZWFkRE1JQ2hhc3Npc1R5cGUoKTsKKyAgICAgICAgaWYgKGNoYXNzaXNUeXBlID09IENoYXNz aXNUeXBlOjpVbmtub3duKQorICAgICAgICAgICAgY2hhc3Npc1R5cGUgPSByZWFkQUNQSUNoYXNz aXNUeXBlKCk7CisgICAgICAgIGlmIChjaGFzc2lzVHlwZSA9PSBDaGFzc2lzVHlwZTo6VW5rbm93 bikKKyAgICAgICAgICAgIGNoYXNzaXNUeXBlID0gQ2hhc3Npc1R5cGU6OkRlc2t0b3A7CisgICAg fSk7CisKKyAgICByZXR1cm4gY2hhc3Npc1R5cGU7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdURgpk aWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvZ2xpYi9DaGFzc2lzVHlwZS5oIGIvU291cmNlL1dU Ri93dGYvZ2xpYi9DaGFzc2lzVHlwZS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjg2YjUwMzllZTk3MjE3OTdiZGUx N2YzY2Y1MjE2ODM0MjNmZmRhNTIKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9n bGliL0NoYXNzaXNUeXBlLmgKQEAgLTAsMCArMSwzNCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykg MjAyMCBKYW4tTWljaGFlbCBCcnVtbWVyIDxqYW4uYnJ1bW1lckB0YWJvcy5vcmc+CisgKgorICog IFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBh bmQvb3IKKyAqICBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBH ZW5lcmFsIFB1YmxpYworICogIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3 YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3Ig KGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiAgVGhpcyBsaWJyYXJ5 IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiAg YnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFu dHkgb2YKKyAqICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBV UlBPU0UuICBTZWUgdGhlIEdOVQorICogIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBm b3IgbW9yZSBkZXRhaWxzLgorICoKKyAqICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5 IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiAgYWxvbmcgd2l0 aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUg dG8KKyAqICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBT dHJlZXQsIEZpZnRoIEZsb29yLAorICogIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgorICov CisKKyNwcmFnbWEgb25jZQorCituYW1lc3BhY2UgV1RGIHsKKworZW51bSBjbGFzcyBDaGFzc2lz VHlwZSB7CisgICAgVW5rbm93biwKKyAgICBEZXNrdG9wLAorICAgIE1vYmlsZQorfTsKKworV1RG X0VYUE9SVF9QUklWQVRFIENoYXNzaXNUeXBlIGNoYXNzaXNUeXBlKCk7CisKK30gLy8gbmFtZXNw YWNlIFdURgorCit1c2luZyBXVEY6OmNoYXNzaXNUeXBlOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vVXNlckFnZW50UXVpcmtzLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL1VzZXJBZ2VudFF1aXJrcy5jcHAKaW5kZXggNGFiZGI4NmI3ZDc5ZDU4OWMwMThhN2UyYjEw NGU0NTllY2FmZWQ0My4uMTA1M2E3YWE3NTMwZjVhZThhODY3ZWI4OWVkNzBlOWRkZjYxNDAxOSAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVXNlckFnZW50UXVpcmtzLmNwcAor KysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9Vc2VyQWdlbnRRdWlya3MuY3BwCkBAIC0yOCw2 ICsyOCw3IEBACiAKICNpbmNsdWRlICJQdWJsaWNTdWZmaXguaCIKICNpbmNsdWRlIDx3dGYvVVJM Lmg+CisjaW5jbHVkZSA8d3RmL2dsaWIvQ2hhc3Npc1R5cGUuaD4KIAogbmFtZXNwYWNlIFdlYkNv cmUgewogCkBAIC0xMTksMTEgKzEyMCwxMSBAQCBzdGF0aWMgYm9vbCB1cmxSZXF1aXJlc01hY2lu dG9zaFBsYXRmb3JtKGNvbnN0IFVSTCYgdXJsKQogICAgIFN0cmluZyBiYXNlRG9tYWluID0gdG9w UHJpdmF0ZWx5Q29udHJvbGxlZERvbWFpbihkb21haW4pOwogCiAgICAgLy8gQXQgbGVhc3QgZmlu YW5jZS55YWhvby5jb20gZGlzcGxheXMgYSBtb2JpbGUgdmVyc2lvbiB3aXRoIFdlYktpdEdUSydz IHN0YW5kYXJkIHVzZXIgYWdlbnQuCi0gICAgaWYgKGJhc2VEb21haW4gPT0gInlhaG9vLmNvbSIp CisgICAgaWYgKGNoYXNzaXNUeXBlKCkgIT0gV1RGOjpDaGFzc2lzVHlwZTo6TW9iaWxlICYmIGJh c2VEb21haW4gPT0gInlhaG9vLmNvbSIpCiAgICAgICAgIHJldHVybiB0cnVlOwogCiAgICAgLy8g dGFvYmFvLmNvbSBkaXNwbGF5cyBhIG1vYmlsZSB2ZXJzaW9uIHdpdGggV2ViS2l0R1RLJ3Mgc3Rh bmRhcmQgdXNlciBhZ2VudC4KLSAgICBpZiAoYmFzZURvbWFpbiA9PSAidGFvYmFvLmNvbSIpCisg ICAgaWYgKGNoYXNzaXNUeXBlKCkgIT0gV1RGOjpDaGFzc2lzVHlwZTo6TW9iaWxlICYmIGJhc2VE b21haW4gPT0gInRhb2Jhby5jb20iKQogICAgICAgICByZXR1cm4gdHJ1ZTsKIAogICAgIC8vIHdl Yi53aGF0c2FwcC5jb20gY29tcGxldGVseSBibG9ja3MgdXNlcnMgd2l0aCBXZWJLaXRHVEsncyBz dGFuZGFyZCB1c2VyIGFnZW50LgpAQCAtMTUyLDcgKzE1Myw3IEBAIHN0YXRpYyBib29sIHVybFJl cXVpcmVzTWFjaW50b3NoUGxhdGZvcm0oY29uc3QgVVJMJiB1cmwpCiAKIHN0YXRpYyBib29sIHVy bFJlcXVpcmVzTGludXhEZXNrdG9wUGxhdGZvcm0oY29uc3QgVVJMJiB1cmwpCiB7Ci0gICAgcmV0 dXJuIGlzR29vZ2xlKHVybCk7CisgICAgcmV0dXJuIGlzR29vZ2xlKHVybCkgJiYgY2hhc3Npc1R5 cGUoKSAhPSBXVEY6OkNoYXNzaXNUeXBlOjpNb2JpbGU7CiB9CiAKIFVzZXJBZ2VudFF1aXJrcyBV c2VyQWdlbnRRdWlya3M6OnF1aXJrc0ZvclVSTChjb25zdCBVUkwmIHVybCkKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dsaWIvVXNlckFnZW50R0xpYi5jcHAgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9nbGliL1VzZXJBZ2VudEdMaWIuY3BwCmluZGV4IDNlMTZjN2FhZjc5 ODEyNWM0ZmY4ZmU3MDc0ZWMyMjc0Mjg3YWRlNzkuLmE1ODA4MWY0Y2IzYzY1YzA3MjBmZTkyNmY1 NDk2MzA0MGFlYzE2ZDkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dsaWIv VXNlckFnZW50R0xpYi5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ2xpYi9Vc2Vy QWdlbnRHTGliLmNwcApAQCAtMzEsNiArMzEsNyBAQAogI2luY2x1ZGUgIlVzZXJBZ2VudFF1aXJr cy5oIgogI2luY2x1ZGUgPHd0Zi9OZXZlckRlc3Ryb3llZC5oPgogI2luY2x1ZGUgPHd0Zi9VUkwu aD4KKyNpbmNsdWRlIDx3dGYvZ2xpYi9DaGFzc2lzVHlwZS5oPgogI2luY2x1ZGUgPHd0Zi90ZXh0 L1N0cmluZ0J1aWxkZXIuaD4KIAogI2lmIE9TKFVOSVgpCkBAIC01MCw2ICs1MSw4IEBAIHN0YXRp YyBjb25zdCBjaGFyKiBwbGF0Zm9ybUZvclVBU3RyaW5nKCkKICNpZiBPUyhNQUNfT1NfWCkKICAg ICByZXR1cm4gIk1hY2ludG9zaCI7CiAjZWxzZQorICAgIGlmIChjaGFzc2lzVHlwZSgpID09IFdU Rjo6Q2hhc3Npc1R5cGU6Ok1vYmlsZSkKKyAgICAgICAgcmV0dXJuICJMaW51eCI7CiAgICAgcmV0 dXJuICJYMTEiOwogI2VuZGlmCiB9CkBAIC01Nyw2ICs2MCw5IEBAIHN0YXRpYyBjb25zdCBjaGFy KiBwbGF0Zm9ybUZvclVBU3RyaW5nKCkKIHN0YXRpYyBjb25zdCBTdHJpbmcgcGxhdGZvcm1WZXJz aW9uRm9yVUFTdHJpbmcoKQogewogI2lmIE9TKFVOSVgpCisgICAgaWYgKGNoYXNzaXNUeXBlKCkg PT0gV1RGOjpDaGFzc2lzVHlwZTo6TW9iaWxlKQorICAgICAgICByZXR1cm4gImxpa2UgQW5kcm9p ZCA0LjQiOworCiAgICAgc3RydWN0IHV0c25hbWUgbmFtZTsKICAgICB1bmFtZSgmbmFtZSk7CiAg ICAgc3RhdGljIE5ldmVyRGVzdHJveWVkPGNvbnN0IFN0cmluZz4gdWFPU1ZlcnNpb24obWFrZVN0 cmluZyhuYW1lLnN5c25hbWUsICcgJywgbmFtZS5tYWNoaW5lKSk7CkBAIC0xMTMsNiArMTE5LDkg QEAgc3RhdGljIFN0cmluZyBidWlsZFVzZXJBZ2VudFN0cmluZyhjb25zdCBVc2VyQWdlbnRRdWly a3MmIHF1aXJrcykKICAgICAvLyBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MTMzNDAzIGZvciBkZXRhaWxzLgogICAgIH0gZWxzZQogICAgICAgICB1YVN0cmluZy5hcHBl bmRMaXRlcmFsKCJWZXJzaW9uLzEzLjAgIik7CisKKyAgICBpZiAoY2hhc3Npc1R5cGUoKSA9PSBX VEY6OkNoYXNzaXNUeXBlOjpNb2JpbGUpCisgICAgICAgIHVhU3RyaW5nLmFwcGVuZExpdGVyYWwo Ik1vYmlsZSAiKTsKICAgICB1YVN0cmluZy5hcHBlbmRMaXRlcmFsKCJTYWZhcmkvIik7CiAgICAg dWFTdHJpbmcuYXBwZW5kKHZlcnNpb25Gb3JVQVN0cmluZygpKTsKIAo= 403863 2020-07-09 07:20:28 -0700 2020-07-09 08:17:57 -0700 Patch bug-149496-20200709162026.patch text/plain 12322 jan.brummer U3VidmVyc2lvbiBSZXZpc2lvbjogMjYzNjYzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggODc2MWFiMDQyYzc3MjNl M2ZiYTJmN2RlMmZmZTVjM2JjZmY3ZjU3Ni4uMGY1ZmZkOTdiNGM5ZmYyMjcxZWM0ZDljMzJkZGYy MDI3OTM4ODVjNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI1IEBACisyMDIwLTA2LTI5ICBKYW4t TWljaGFlbCBCcnVtbWVyICA8amFuLmJydW1tZXJAdGFib3Mub3JnPgorCisgICAgICAgIFtHVEtd W1dQRV0gVXNlIG1vYmlsZSB1c2VyLWFnZW50IG9uIHRhYmxldAorICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQ5NDk2CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzIChPT1BTISkuCisKKyAg ICAgICAgKiBwbGF0Zm9ybS9Vc2VyQWdlbnRRdWlya3MuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 dXJsUmVxdWlyZXNNYWNpbnRvc2hQbGF0Zm9ybSk6CisgICAgICAgIChXZWJDb3JlOjp1cmxSZXF1 aXJlc0xpbnV4RGVza3RvcFBsYXRmb3JtKToKKyAgICAgICAgKFdlYkNvcmU6OlVzZXJBZ2VudFF1 aXJrczo6cXVpcmtzRm9yVVJMKToKKyAgICAgICAgKiBwbGF0Zm9ybS9Vc2VyQWdlbnRRdWlya3Mu aDoKKyAgICAgICAgKiBwbGF0Zm9ybS9nbGliL1VzZXJBZ2VudEdMaWIuY3BwOgorICAgICAgICAo V2ViQ29yZTo6Z2V0Q2hhc3Npc1R5cGUpOgorICAgICAgICAoV2ViQ29yZTo6cGxhdGZvcm1Gb3JV QVN0cmluZyk6CisgICAgICAgIChXZWJDb3JlOjpwbGF0Zm9ybVZlcnNpb25Gb3JVQVN0cmluZyk6 CisgICAgICAgIChXZWJDb3JlOjpidWlsZFVzZXJBZ2VudFN0cmluZyk6CisgICAgICAgIChXZWJD b3JlOjpzdGFuZGFyZFVzZXJBZ2VudCk6CisgICAgICAgIChXZWJDb3JlOjpzdGFuZGFyZFVzZXJB Z2VudEZvclVSTCk6CisKIDIwMjAtMDYtMjkgIENocmlzIER1bWV6ICA8Y2R1bWV6QGFwcGxlLmNv bT4KIAogICAgICAgICBPbiBsb2FkIGZyb20gYmFjay9mb3J3YXJkIGNhY2hlLCBjYWxsIGNoZWNr Q29tcGxldGVkKCkgZm9yIEFMTCBmcmFtZXMgaW5zaWRlIEZyYW1lTG9hZGVyOjpjb21taXRQcm92 aXNpb25hbExvYWQoKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvUGxhdGZvcm1HVEsuY21h a2UgYi9Tb3VyY2UvV1RGL3d0Zi9QbGF0Zm9ybUdUSy5jbWFrZQppbmRleCBhMDRlMWQ4NWYxYThj NWUwZjk1MGI5OTJhYzkyMDIyZjU2NWQ2ZDdmLi40NWJiOWRkMTFiYTlkYWY0MzU5OWU1ZWIxZTI0 YmE0YzgwODA4MzMwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9QbGF0Zm9ybUdUSy5jbWFr ZQorKysgYi9Tb3VyY2UvV1RGL3d0Zi9QbGF0Zm9ybUdUSy5jbWFrZQpAQCAtMSw2ICsxLDcgQEAK IHNldChXVEZfT1VUUFVUX05BTUUgV1RGR1RLKQogCiBsaXN0KEFQUEVORCBXVEZfUFVCTElDX0hF QURFUlMKKyAgICBnbGliL0NoYXNzaXNUeXBlLmgKICAgICBnbGliL0dMaWJVdGlsaXRpZXMuaAog ICAgIGdsaWIvR011dGV4TG9ja2VyLmgKICAgICBnbGliL0dSZWZQdHIuaApAQCAtMjMsNiArMjQs NyBAQCBsaXN0KEFQUEVORCBXVEZfU09VUkNFUwogICAgIGdlbmVyaWMvTWFpblRocmVhZEdlbmVy aWMuY3BwCiAgICAgZ2VuZXJpYy9Xb3JrUXVldWVHZW5lcmljLmNwcAogCisgICAgZ2xpYi9DaGFz c2lzVHlwZS5jcHAKICAgICBnbGliL0ZpbGVTeXN0ZW1HbGliLmNwcAogICAgIGdsaWIvR0xpYlV0 aWxpdGllcy5jcHAKICAgICBnbGliL0dSZWZQdHIuY3BwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RG L3d0Zi9QbGF0Zm9ybVdQRS5jbWFrZSBiL1NvdXJjZS9XVEYvd3RmL1BsYXRmb3JtV1BFLmNtYWtl CmluZGV4IDc1OTVhMjc3MDg0NDEzNTdkYWViZjk1YWU2ZjE3YTgwM2Q2NTFlNjguLjQ2MTQ4Zjhi NTRiMDYyYmQ3ZjhkNmMzZmQ3NmMxODk4M2Q2YmUyOGYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYv d3RmL1BsYXRmb3JtV1BFLmNtYWtlCisrKyBiL1NvdXJjZS9XVEYvd3RmL1BsYXRmb3JtV1BFLmNt YWtlCkBAIC0xLDQgKzEsNSBAQAogbGlzdChBUFBFTkQgV1RGX1BVQkxJQ19IRUFERVJTCisgICAg Z2xpYi9DaGFzc2lzVHlwZS5oCiAgICAgZ2xpYi9HTGliVXRpbGl0aWVzLmgKICAgICBnbGliL0dN dXRleExvY2tlci5oCiAgICAgZ2xpYi9HUmVmUHRyLmgKQEAgLTE4LDYgKzE5LDcgQEAgbGlzdChB UFBFTkQgV1RGX1NPVVJDRVMKICAgICBnZW5lcmljL01lbW9yeUZvb3RwcmludEdlbmVyaWMuY3Bw CiAgICAgZ2VuZXJpYy9Xb3JrUXVldWVHZW5lcmljLmNwcAogCisgICAgZ2xpYi9DaGFzc2lzVHlw ZS5jcHAKICAgICBnbGliL0ZpbGVTeXN0ZW1HbGliLmNwcAogICAgIGdsaWIvR0xpYlV0aWxpdGll cy5jcHAKICAgICBnbGliL0dSZWZQdHIuY3BwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9n bGliL0NoYXNzaXNUeXBlLmNwcCBiL1NvdXJjZS9XVEYvd3RmL2dsaWIvQ2hhc3Npc1R5cGUuY3Bw Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAuLmExOTg4MTFmMjlmYWNiMDEzNmY1ZDcyYzAwM2YzNmYwODA1ZjhlMzkKLS0t IC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9nbGliL0NoYXNzaXNUeXBlLmNwcApAQCAt MCwwICsxLDEzOCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAyMCBKYW4tTWljaGFlbCBCcnVt bWVyIDxqYW4uYnJ1bW1lckB0YWJvcy5vcmc+CisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVz ZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmlj YXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlv bnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVz dCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmli dXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVy aWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FS RSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNT IE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRI RQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBG T1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQg U0hBTEwgQVBQTEUgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJ UkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENP TlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQ Uk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwg REFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBD QVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05U UkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNF IE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBU SElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0gg REFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlIDx3dGYvZ2xpYi9D aGFzc2lzVHlwZS5oPgorCisjaW5jbHVkZSA8bXV0ZXg+CisjaW5jbHVkZSA8d3RmL2dsaWIvR1Vu aXF1ZVB0ci5oPgorCituYW1lc3BhY2UgV1RGIHsKKworc3RhdGljIE9wdGlvbmFsPENoYXNzaXNU eXBlPiByZWFkTWFjaGluZUluZm9DaGFzc2lzVHlwZSgpCit7CisgICAgR1VuaXF1ZU91dFB0cjxj aGFyPiBidWZmZXI7CisgICAgR1VuaXF1ZU91dFB0cjxHRXJyb3I+IGVycm9yOworICAgIGlmICgh Z19maWxlX2dldF9jb250ZW50cygiL2V0Yy9tYWNoaW5lLWluZm8iLCAmYnVmZmVyLm91dFB0cigp LCBudWxscHRyLCAmZXJyb3Iub3V0UHRyKCkpKSB7CisgICAgICAgIGlmICghZ19lcnJvcl9tYXRj aGVzKGVycm9yLmdldCgpLCBHX0ZJTEVfRVJST1IsIEdfRklMRV9FUlJPUl9OT0VOVCkpCisgICAg ICAgICAgICBnX3dhcm5pbmcoIkNvdWxkIG5vdCBvcGVuIC9ldGMvbWFjaGluZS1pbmZvOiAlcyIs IGVycm9yLT5tZXNzYWdlKTsKKyAgICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKKyAgICB9CisK KyAgICBHVW5pcXVlUHRyPGNoYXIqPiBzcGxpdChnX3N0cnNwbGl0KGJ1ZmZlci5nZXQoKSwgIlxu IiwgLTEpKTsKKyAgICBmb3IgKGludCBpID0gMDsgc3BsaXQuZ2V0KClbaV07ICsraSkgeworICAg ICAgICBpZiAoZ19zdHJfaGFzX3ByZWZpeChzcGxpdC5nZXQoKVtpXSwgIkNIQVNTSVM9IikpIHsK KyAgICAgICAgICAgIGNoYXIqIGNoYXNzaXMgPSBzcGxpdC5nZXQoKVtpXSArIDg7CisgICAgICAg ICAgICBpZiAoIXN0cmNtcChjaGFzc2lzLCAidGFibGV0IikgfHwgIXN0cmNtcChjaGFzc2lzLCAi aGFuZHNldCIpKQorICAgICAgICAgICAgICAgIHJldHVybiBDaGFzc2lzVHlwZTo6TW9iaWxlOwor CisgICAgICAgICAgICByZXR1cm4gQ2hhc3Npc1R5cGU6OkRlc2t0b3A7CisgICAgICAgIH0KKyAg ICB9CisKKyAgICByZXR1cm4gV1RGOjpudWxsb3B0OworfQorCitzdGF0aWMgT3B0aW9uYWw8Q2hh c3Npc1R5cGU+IHJlYWRETUlDaGFzc2lzVHlwZSgpCit7CisgICAgR1VuaXF1ZU91dFB0cjxjaGFy PiBidWZmZXI7CisgICAgR1VuaXF1ZU91dFB0cjxHRXJyb3I+IGVycm9yOworICAgIGlmIChnX2Zp bGVfZ2V0X2NvbnRlbnRzKCIvc3lzL2NsYXNzL2RtaS9pZC9jaGFzc2lzX3R5cGUiLCAmYnVmZmVy Lm91dFB0cigpLCBudWxscHRyLCAmZXJyb3Iub3V0UHRyKCkpKSB7CisgICAgICAgIGludCB0eXBl ID0gc3RydG9sKGJ1ZmZlci5nZXQoKSwgbnVsbHB0ciwgMTApOworCisgICAgICAgIC8vIFNlZSB0 aGUgU01CSU9TIFNwZWNpZmljYXRpb24gMy4wIHNlY3Rpb24gNy40LjEgZm9yIGRldGFpbHMgYWJv dXQgdGhlIHZhbHVlcyBsaXN0ZWQgaGVyZToKKyAgICAgICAgLy8gaHR0cHM6Ly93d3cuZG10Zi5v cmcvc2l0ZXMvZGVmYXVsdC9maWxlcy9zdGFuZGFyZHMvZG9jdW1lbnRzL0RTUDAxMzRfMy4wLjAu cGRmCisgICAgICAgIHN3aXRjaCAodHlwZSkgeworICAgICAgICBjYXNlIDB4MzogLyogRGVza3Rv cCAqLworICAgICAgICBjYXNlIDB4NDogLyogTG93IFByb2ZpbGUgRGVza3RvcCAqLworICAgICAg ICBjYXNlIDB4NjogLyogTWluaSBUb3dlciAqLworICAgICAgICBjYXNlIDB4NzogLyogVG93ZXIg Ki8KKyAgICAgICAgY2FzZSAweDg6IC8qIFBvcnRhYmxlICovCisgICAgICAgIGNhc2UgMHg5OiAv KiBMYXB0b3AgKi8KKyAgICAgICAgY2FzZSAweEE6IC8qIE5vdGVib29rICovCisgICAgICAgIGNh c2UgMHhFOiAvKiBTdWIgTm90ZWJvb2sgKi8KKyAgICAgICAgY2FzZSAweDExOiAvKiBNYWluIFNl cnZlciBDaGFzc2lzICovCisgICAgICAgIGNhc2UgMHgxQzogLyogQmxhZGUgKi8KKyAgICAgICAg Y2FzZSAweDFEOiAvKiBCbGFkZSBFbmNsb3N1cmUgKi8KKyAgICAgICAgY2FzZSAweDFGOiAvKiBD b252ZXJ0aWJsZSAqLworICAgICAgICBjYXNlIDB4MjA6IC8qIERldGFjaGFibGUgKi8KKyAgICAg ICAgICAgIHJldHVybiBDaGFzc2lzVHlwZTo6RGVza3RvcDsKKworICAgICAgICBjYXNlIDB4Qjog LyogSGFuZCBIZWxkICovCisgICAgICAgIGNhc2UgMHgxRTogLyogVGFibGV0ICovCisgICAgICAg ICAgICByZXR1cm4gQ2hhc3Npc1R5cGU6Ok1vYmlsZTsKKyAgICAgICAgfQorICAgIH0gZWxzZSBp ZiAoIWdfZXJyb3JfbWF0Y2hlcyhlcnJvci5nZXQoKSwgR19GSUxFX0VSUk9SLCBHX0ZJTEVfRVJS T1JfTk9FTlQpKQorICAgICAgICBnX3dhcm5pbmcoIkNvdWxkIG5vdCBvcGVuIC9zeXMvY2xhc3Mv ZG1pL2lkL2NoYXNzaXNfdHlwZTogJXMiLCBlcnJvci0+bWVzc2FnZSk7CisKKyAgICByZXR1cm4g V1RGOjpudWxsb3B0OworfQorCitzdGF0aWMgT3B0aW9uYWw8Q2hhc3Npc1R5cGU+IHJlYWRBQ1BJ Q2hhc3Npc1R5cGUoKQoreworICAgIEdVbmlxdWVPdXRQdHI8Y2hhcj4gYnVmZmVyOworICAgIEdV bmlxdWVPdXRQdHI8R0Vycm9yPiBlcnJvcjsKKyAgICBpZiAoZ19maWxlX2dldF9jb250ZW50cygi L3N5cy9maXJtd2FyZS9hY3BpL3BtX3Byb2ZpbGUiLCAmYnVmZmVyLm91dFB0cigpLCBudWxscHRy LCAmZXJyb3Iub3V0UHRyKCkpKSB7CisgICAgICAgIGludCB0eXBlID0gc3RydG9sKGJ1ZmZlci5n ZXQoKSwgbnVsbHB0ciwgMTApOworCisgICAgICAgIC8vIFNlZSB0aGUgQUNQSSA1LjAgU3BlYyBT ZWN0aW9uIDUuMi45LjEgZm9yIGRldGFpbHM6CisgICAgICAgIC8vIGh0dHA6Ly93d3cuYWNwaS5p bmZvL0RPV05MT0FEUy9BQ1BJc3BlYzUwLnBkZgorICAgICAgICBzd2l0Y2ggKHR5cGUpIHsKKyAg ICAgICAgY2FzZSAxOiAvKiBEZXNrdG9wICovCisgICAgICAgIGNhc2UgMjogLyogTW9iaWxlICov CisgICAgICAgIGNhc2UgMzogLyogV29ya3N0YXRpb24gKi8KKyAgICAgICAgY2FzZSA0OiAvKiBF bnRlcnByaXNlIFNlcnZlciAqLworICAgICAgICBjYXNlIDU6IC8qIFNPSE8gU2VydmVyICovCisg ICAgICAgIGNhc2UgNjogLyogQXBwbGlhbmNlIFBDICovCisgICAgICAgIGNhc2UgNzogLyogUGVy Zm9ybWFuY2UgU2VydmVyICovCisgICAgICAgICAgICByZXR1cm4gQ2hhc3Npc1R5cGU6OkRlc2t0 b3A7CisKKyAgICAgICAgY2FzZSA4OiAvKiBUYWJsZXQgKi8KKyAgICAgICAgICAgIHJldHVybiBD aGFzc2lzVHlwZTo6TW9iaWxlOworICAgICAgICB9CisgICAgfSBlbHNlIGlmICghZ19lcnJvcl9t YXRjaGVzKGVycm9yLmdldCgpLCBHX0ZJTEVfRVJST1IsIEdfRklMRV9FUlJPUl9OT0VOVCkpCisg ICAgICAgIGdfd2FybmluZygiQ291bGQgbm90IG9wZW4gL3N5cy9maXJtd2FyZS9hY3BpL3BtX3By b2ZpbGU6ICVzIiwgZXJyb3ItPm1lc3NhZ2UpOworCisgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsK K30KKworT3B0aW9uYWw8Q2hhc3Npc1R5cGU+IGNoYXNzaXNUeXBlKCkKK3sKKyAgICBzdGF0aWMg T3B0aW9uYWw8Q2hhc3Npc1R5cGU+IGNoYXNzaXNUeXBlOworICAgIHN0YXRpYyBzdGQ6Om9uY2Vf ZmxhZyBpbml0aWFsaXplQ2hhc3NpczsKKyAgICBzdGQ6OmNhbGxfb25jZShpbml0aWFsaXplQ2hh c3NpcywgW10geworICAgICAgICBjaGFzc2lzVHlwZSA9IHJlYWRNYWNoaW5lSW5mb0NoYXNzaXNU eXBlKCk7CisgICAgICAgIGlmIChjaGFzc2lzVHlwZSA9PSBXVEY6Om51bGxvcHQpCisgICAgICAg ICAgICBjaGFzc2lzVHlwZSA9IHJlYWRETUlDaGFzc2lzVHlwZSgpOworICAgICAgICBpZiAoY2hh c3Npc1R5cGUgPT0gV1RGOjpudWxsb3B0KQorICAgICAgICAgICAgY2hhc3Npc1R5cGUgPSByZWFk QUNQSUNoYXNzaXNUeXBlKCk7CisgICAgICAgIGlmIChjaGFzc2lzVHlwZSA9PSBXVEY6Om51bGxv cHQpCisgICAgICAgICAgICBjaGFzc2lzVHlwZSA9IENoYXNzaXNUeXBlOjpEZXNrdG9wOworICAg IH0pOworCisgICAgcmV0dXJuIGNoYXNzaXNUeXBlOworfQorCit9IC8vIG5hbWVzcGFjZSBXVEYK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL2dsaWIvQ2hhc3Npc1R5cGUuaCBiL1NvdXJjZS9X VEYvd3RmL2dsaWIvQ2hhc3Npc1R5cGUuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi41OGVjMjljNmVlNDFhZTFkMDJk OThhNGJjZTc5M2I1M2JhMTdiMzZlCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dURi93dGYv Z2xpYi9DaGFzc2lzVHlwZS5oCkBAIC0wLDAgKzEsMzUgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMp IDIwMjAgSmFuLU1pY2hhZWwgQnJ1bW1lciA8amFuLmJydW1tZXJAdGFib3Mub3JnPgorICoKKyAq ICBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQg YW5kL29yCisgKiAgbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkg R2VuZXJhbCBQdWJsaWMKKyAqICBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0 d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqICB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9y IChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogIFRoaXMgbGlicmFy eSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICog IGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJh bnR5IG9mCisgKiAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQ VVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqICBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2Ug Zm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29w eSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogIGFsb25nIHdp dGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRl IHRvCisgKiAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4g U3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqICBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAq LworCisjcHJhZ21hIG9uY2UKKworI2luY2x1ZGUgPHd0Zi9PcHRpb25hbC5oPgorCituYW1lc3Bh Y2UgV1RGIHsKKworZW51bSBjbGFzcyBDaGFzc2lzVHlwZSB7CisgICAgRGVza3RvcCwKKyAgICBN b2JpbGUKK307CisKK1dURl9FWFBPUlRfUFJJVkFURSBPcHRpb25hbDxDaGFzc2lzVHlwZT4gY2hh c3Npc1R5cGUoKTsKKworfSAvLyBuYW1lc3BhY2UgV1RGCisKK3VzaW5nIFdURjo6Y2hhc3Npc1R5 cGU7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9Vc2VyQWdlbnRRdWlya3Mu Y3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVXNlckFnZW50UXVpcmtzLmNwcAppbmRleCA0 YWJkYjg2YjdkNzlkNTg5YzAxOGE3ZTJiMTA0ZTQ1OWVjYWZlZDQzLi4xMDUzYTdhYTc1MzBmNWFl OGE4NjdlYjg5ZWQ3MGU5ZGRmNjE0MDE5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9Vc2VyQWdlbnRRdWlya3MuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Vz ZXJBZ2VudFF1aXJrcy5jcHAKQEAgLTI4LDYgKzI4LDcgQEAKIAogI2luY2x1ZGUgIlB1YmxpY1N1 ZmZpeC5oIgogI2luY2x1ZGUgPHd0Zi9VUkwuaD4KKyNpbmNsdWRlIDx3dGYvZ2xpYi9DaGFzc2lz VHlwZS5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKQEAgLTExOSwxMSArMTIwLDExIEBAIHN0 YXRpYyBib29sIHVybFJlcXVpcmVzTWFjaW50b3NoUGxhdGZvcm0oY29uc3QgVVJMJiB1cmwpCiAg ICAgU3RyaW5nIGJhc2VEb21haW4gPSB0b3BQcml2YXRlbHlDb250cm9sbGVkRG9tYWluKGRvbWFp bik7CiAKICAgICAvLyBBdCBsZWFzdCBmaW5hbmNlLnlhaG9vLmNvbSBkaXNwbGF5cyBhIG1vYmls ZSB2ZXJzaW9uIHdpdGggV2ViS2l0R1RLJ3Mgc3RhbmRhcmQgdXNlciBhZ2VudC4KLSAgICBpZiAo YmFzZURvbWFpbiA9PSAieWFob28uY29tIikKKyAgICBpZiAoY2hhc3Npc1R5cGUoKSAhPSBXVEY6 OkNoYXNzaXNUeXBlOjpNb2JpbGUgJiYgYmFzZURvbWFpbiA9PSAieWFob28uY29tIikKICAgICAg ICAgcmV0dXJuIHRydWU7CiAKICAgICAvLyB0YW9iYW8uY29tIGRpc3BsYXlzIGEgbW9iaWxlIHZl cnNpb24gd2l0aCBXZWJLaXRHVEsncyBzdGFuZGFyZCB1c2VyIGFnZW50LgotICAgIGlmIChiYXNl RG9tYWluID09ICJ0YW9iYW8uY29tIikKKyAgICBpZiAoY2hhc3Npc1R5cGUoKSAhPSBXVEY6OkNo YXNzaXNUeXBlOjpNb2JpbGUgJiYgYmFzZURvbWFpbiA9PSAidGFvYmFvLmNvbSIpCiAgICAgICAg IHJldHVybiB0cnVlOwogCiAgICAgLy8gd2ViLndoYXRzYXBwLmNvbSBjb21wbGV0ZWx5IGJsb2Nr cyB1c2VycyB3aXRoIFdlYktpdEdUSydzIHN0YW5kYXJkIHVzZXIgYWdlbnQuCkBAIC0xNTIsNyAr MTUzLDcgQEAgc3RhdGljIGJvb2wgdXJsUmVxdWlyZXNNYWNpbnRvc2hQbGF0Zm9ybShjb25zdCBV UkwmIHVybCkKIAogc3RhdGljIGJvb2wgdXJsUmVxdWlyZXNMaW51eERlc2t0b3BQbGF0Zm9ybShj b25zdCBVUkwmIHVybCkKIHsKLSAgICByZXR1cm4gaXNHb29nbGUodXJsKTsKKyAgICByZXR1cm4g aXNHb29nbGUodXJsKSAmJiBjaGFzc2lzVHlwZSgpICE9IFdURjo6Q2hhc3Npc1R5cGU6Ok1vYmls ZTsKIH0KIAogVXNlckFnZW50UXVpcmtzIFVzZXJBZ2VudFF1aXJrczo6cXVpcmtzRm9yVVJMKGNv bnN0IFVSTCYgdXJsKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ2xpYi9V c2VyQWdlbnRHTGliLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dsaWIvVXNlckFnZW50 R0xpYi5jcHAKaW5kZXggM2UxNmM3YWFmNzk4MTI1YzRmZjhmZTcwNzRlYzIyNzQyODdhZGU3OS4u YTU4MDgxZjRjYjNjNjVjMDcyMGZlOTI2ZjU0OTYzMDQwYWVjMTZkOSAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ2xpYi9Vc2VyQWdlbnRHTGliLmNwcAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9nbGliL1VzZXJBZ2VudEdMaWIuY3BwCkBAIC0zMSw2ICszMSw3IEBA CiAjaW5jbHVkZSAiVXNlckFnZW50UXVpcmtzLmgiCiAjaW5jbHVkZSA8d3RmL05ldmVyRGVzdHJv eWVkLmg+CiAjaW5jbHVkZSA8d3RmL1VSTC5oPgorI2luY2x1ZGUgPHd0Zi9nbGliL0NoYXNzaXNU eXBlLmg+CiAjaW5jbHVkZSA8d3RmL3RleHQvU3RyaW5nQnVpbGRlci5oPgogCiAjaWYgT1MoVU5J WCkKQEAgLTUwLDYgKzUxLDggQEAgc3RhdGljIGNvbnN0IGNoYXIqIHBsYXRmb3JtRm9yVUFTdHJp bmcoKQogI2lmIE9TKE1BQ19PU19YKQogICAgIHJldHVybiAiTWFjaW50b3NoIjsKICNlbHNlCisg ICAgaWYgKGNoYXNzaXNUeXBlKCkgPT0gV1RGOjpDaGFzc2lzVHlwZTo6TW9iaWxlKQorICAgICAg ICByZXR1cm4gIkxpbnV4IjsKICAgICByZXR1cm4gIlgxMSI7CiAjZW5kaWYKIH0KQEAgLTU3LDYg KzYwLDkgQEAgc3RhdGljIGNvbnN0IGNoYXIqIHBsYXRmb3JtRm9yVUFTdHJpbmcoKQogc3RhdGlj IGNvbnN0IFN0cmluZyBwbGF0Zm9ybVZlcnNpb25Gb3JVQVN0cmluZygpCiB7CiAjaWYgT1MoVU5J WCkKKyAgICBpZiAoY2hhc3Npc1R5cGUoKSA9PSBXVEY6OkNoYXNzaXNUeXBlOjpNb2JpbGUpCisg ICAgICAgIHJldHVybiAibGlrZSBBbmRyb2lkIDQuNCI7CisKICAgICBzdHJ1Y3QgdXRzbmFtZSBu YW1lOwogICAgIHVuYW1lKCZuYW1lKTsKICAgICBzdGF0aWMgTmV2ZXJEZXN0cm95ZWQ8Y29uc3Qg U3RyaW5nPiB1YU9TVmVyc2lvbihtYWtlU3RyaW5nKG5hbWUuc3lzbmFtZSwgJyAnLCBuYW1lLm1h Y2hpbmUpKTsKQEAgLTExMyw2ICsxMTksOSBAQCBzdGF0aWMgU3RyaW5nIGJ1aWxkVXNlckFnZW50 U3RyaW5nKGNvbnN0IFVzZXJBZ2VudFF1aXJrcyYgcXVpcmtzKQogICAgIC8vIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMzM0MDMgZm9yIGRldGFpbHMuCiAgICAgfSBl bHNlCiAgICAgICAgIHVhU3RyaW5nLmFwcGVuZExpdGVyYWwoIlZlcnNpb24vMTMuMCAiKTsKKwor ICAgIGlmIChjaGFzc2lzVHlwZSgpID09IFdURjo6Q2hhc3Npc1R5cGU6Ok1vYmlsZSkKKyAgICAg ICAgdWFTdHJpbmcuYXBwZW5kTGl0ZXJhbCgiTW9iaWxlICIpOwogICAgIHVhU3RyaW5nLmFwcGVu ZExpdGVyYWwoIlNhZmFyaS8iKTsKICAgICB1YVN0cmluZy5hcHBlbmQodmVyc2lvbkZvclVBU3Ry aW5nKCkpOwogCg== 403865 2020-07-09 08:18:04 -0700 2020-07-10 00:18:49 -0700 Patch bug-149496-20200709171803.patch text/plain 12274 jan.brummer U3VidmVyc2lvbiBSZXZpc2lvbjogMjYzNjYzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggODc2MWFiMDQyYzc3MjNl M2ZiYTJmN2RlMmZmZTVjM2JjZmY3ZjU3Ni4uOTE2M2JiNzhmODliYzMyMTY2Zjk4ZjdhNzE0MTll MjhlMzlhMjY3OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIzIEBACisyMDIwLTA2LTI5ICBKYW4t TWljaGFlbCBCcnVtbWVyICA8amFuLmJydW1tZXJAdGFib3Mub3JnPgorCisgICAgICAgIFtHVEtd W1dQRV0gVXNlIG1vYmlsZSB1c2VyLWFnZW50IG9uIHRhYmxldAorICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQ5NDk2CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9Vc2VyQWdlbnRRdWlya3Mu Y3BwOgorICAgICAgICAoV2ViQ29yZTo6dXJsUmVxdWlyZXNNYWNpbnRvc2hQbGF0Zm9ybSk6Cisg ICAgICAgIChXZWJDb3JlOjp1cmxSZXF1aXJlc0xpbnV4RGVza3RvcFBsYXRmb3JtKToKKyAgICAg ICAgKFdlYkNvcmU6OlVzZXJBZ2VudFF1aXJrczo6cXVpcmtzRm9yVVJMKToKKyAgICAgICAgKiBw bGF0Zm9ybS9Vc2VyQWdlbnRRdWlya3MuaDoKKyAgICAgICAgKiBwbGF0Zm9ybS9nbGliL1VzZXJB Z2VudEdMaWIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Z2V0Q2hhc3Npc1R5cGUpOgorICAgICAg ICAoV2ViQ29yZTo6cGxhdGZvcm1Gb3JVQVN0cmluZyk6CisgICAgICAgIChXZWJDb3JlOjpwbGF0 Zm9ybVZlcnNpb25Gb3JVQVN0cmluZyk6CisgICAgICAgIChXZWJDb3JlOjpidWlsZFVzZXJBZ2Vu dFN0cmluZyk6CisgICAgICAgIChXZWJDb3JlOjpzdGFuZGFyZFVzZXJBZ2VudCk6CisgICAgICAg IChXZWJDb3JlOjpzdGFuZGFyZFVzZXJBZ2VudEZvclVSTCk6CisKIDIwMjAtMDYtMjkgIENocmlz IER1bWV6ICA8Y2R1bWV6QGFwcGxlLmNvbT4KIAogICAgICAgICBPbiBsb2FkIGZyb20gYmFjay9m b3J3YXJkIGNhY2hlLCBjYWxsIGNoZWNrQ29tcGxldGVkKCkgZm9yIEFMTCBmcmFtZXMgaW5zaWRl IEZyYW1lTG9hZGVyOjpjb21taXRQcm92aXNpb25hbExvYWQoKQpkaWZmIC0tZ2l0IGEvU291cmNl L1dURi93dGYvUGxhdGZvcm1HVEsuY21ha2UgYi9Tb3VyY2UvV1RGL3d0Zi9QbGF0Zm9ybUdUSy5j bWFrZQppbmRleCBhMDRlMWQ4NWYxYThjNWUwZjk1MGI5OTJhYzkyMDIyZjU2NWQ2ZDdmLi40NWJi OWRkMTFiYTlkYWY0MzU5OWU1ZWIxZTI0YmE0YzgwODA4MzMwIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V1RGL3d0Zi9QbGF0Zm9ybUdUSy5jbWFrZQorKysgYi9Tb3VyY2UvV1RGL3d0Zi9QbGF0Zm9ybUdU Sy5jbWFrZQpAQCAtMSw2ICsxLDcgQEAKIHNldChXVEZfT1VUUFVUX05BTUUgV1RGR1RLKQogCiBs aXN0KEFQUEVORCBXVEZfUFVCTElDX0hFQURFUlMKKyAgICBnbGliL0NoYXNzaXNUeXBlLmgKICAg ICBnbGliL0dMaWJVdGlsaXRpZXMuaAogICAgIGdsaWIvR011dGV4TG9ja2VyLmgKICAgICBnbGli L0dSZWZQdHIuaApAQCAtMjMsNiArMjQsNyBAQCBsaXN0KEFQUEVORCBXVEZfU09VUkNFUwogICAg IGdlbmVyaWMvTWFpblRocmVhZEdlbmVyaWMuY3BwCiAgICAgZ2VuZXJpYy9Xb3JrUXVldWVHZW5l cmljLmNwcAogCisgICAgZ2xpYi9DaGFzc2lzVHlwZS5jcHAKICAgICBnbGliL0ZpbGVTeXN0ZW1H bGliLmNwcAogICAgIGdsaWIvR0xpYlV0aWxpdGllcy5jcHAKICAgICBnbGliL0dSZWZQdHIuY3Bw CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9QbGF0Zm9ybVdQRS5jbWFrZSBiL1NvdXJjZS9X VEYvd3RmL1BsYXRmb3JtV1BFLmNtYWtlCmluZGV4IDc1OTVhMjc3MDg0NDEzNTdkYWViZjk1YWU2 ZjE3YTgwM2Q2NTFlNjguLjQ2MTQ4ZjhiNTRiMDYyYmQ3ZjhkNmMzZmQ3NmMxODk4M2Q2YmUyOGYg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL1BsYXRmb3JtV1BFLmNtYWtlCisrKyBiL1NvdXJj ZS9XVEYvd3RmL1BsYXRmb3JtV1BFLmNtYWtlCkBAIC0xLDQgKzEsNSBAQAogbGlzdChBUFBFTkQg V1RGX1BVQkxJQ19IRUFERVJTCisgICAgZ2xpYi9DaGFzc2lzVHlwZS5oCiAgICAgZ2xpYi9HTGli VXRpbGl0aWVzLmgKICAgICBnbGliL0dNdXRleExvY2tlci5oCiAgICAgZ2xpYi9HUmVmUHRyLmgK QEAgLTE4LDYgKzE5LDcgQEAgbGlzdChBUFBFTkQgV1RGX1NPVVJDRVMKICAgICBnZW5lcmljL01l bW9yeUZvb3RwcmludEdlbmVyaWMuY3BwCiAgICAgZ2VuZXJpYy9Xb3JrUXVldWVHZW5lcmljLmNw cAogCisgICAgZ2xpYi9DaGFzc2lzVHlwZS5jcHAKICAgICBnbGliL0ZpbGVTeXN0ZW1HbGliLmNw cAogICAgIGdsaWIvR0xpYlV0aWxpdGllcy5jcHAKICAgICBnbGliL0dSZWZQdHIuY3BwCmRpZmYg LS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9nbGliL0NoYXNzaXNUeXBlLmNwcCBiL1NvdXJjZS9XVEYv d3RmL2dsaWIvQ2hhc3Npc1R5cGUuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjM4YmYyOGM2NzI2YTMxNzYxZTI1 ZGNhZTY1NDMwNzdhOWEzMmUzOGQKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9n bGliL0NoYXNzaXNUeXBlLmNwcApAQCAtMCwwICsxLDEzNyBAQAorLyoKKyAqIENvcHlyaWdodCAo QykgMjAyMCBKYW4tTWljaGFlbCBCcnVtbWVyIDxqYW4uYnJ1bW1lckB0YWJvcy5vcmc+CisgKgor ICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0 aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhh dCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1 dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICog ICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9k dWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50 YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRp b24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIGBgQVMg SVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5H LCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNI QU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBE SVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUgorICogQ09OVFJJQlVU T1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJ QUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBC VVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9S IFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNT IElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJ QUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAor ICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZ IE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0Yg VEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcu aCIKKyNpbmNsdWRlIDx3dGYvZ2xpYi9DaGFzc2lzVHlwZS5oPgorCisjaW5jbHVkZSA8bXV0ZXg+ CisjaW5jbHVkZSA8d3RmL2dsaWIvR1VuaXF1ZVB0ci5oPgorCituYW1lc3BhY2UgV1RGIHsKKwor c3RhdGljIE9wdGlvbmFsPENoYXNzaXNUeXBlPiByZWFkTWFjaGluZUluZm9DaGFzc2lzVHlwZSgp Cit7CisgICAgR1VuaXF1ZU91dFB0cjxjaGFyPiBidWZmZXI7CisgICAgR1VuaXF1ZU91dFB0cjxH RXJyb3I+IGVycm9yOworICAgIGlmICghZ19maWxlX2dldF9jb250ZW50cygiL2V0Yy9tYWNoaW5l LWluZm8iLCAmYnVmZmVyLm91dFB0cigpLCBudWxscHRyLCAmZXJyb3Iub3V0UHRyKCkpKSB7Cisg ICAgICAgIGlmICghZ19lcnJvcl9tYXRjaGVzKGVycm9yLmdldCgpLCBHX0ZJTEVfRVJST1IsIEdf RklMRV9FUlJPUl9OT0VOVCkpCisgICAgICAgICAgICBnX3dhcm5pbmcoIkNvdWxkIG5vdCBvcGVu IC9ldGMvbWFjaGluZS1pbmZvOiAlcyIsIGVycm9yLT5tZXNzYWdlKTsKKyAgICAgICAgcmV0dXJu IFdURjo6bnVsbG9wdDsKKyAgICB9CisKKyAgICBHVW5pcXVlUHRyPGNoYXIqPiBzcGxpdChnX3N0 cnNwbGl0KGJ1ZmZlci5nZXQoKSwgIlxuIiwgLTEpKTsKKyAgICBmb3IgKGludCBpID0gMDsgc3Bs aXQuZ2V0KClbaV07ICsraSkgeworICAgICAgICBpZiAoZ19zdHJfaGFzX3ByZWZpeChzcGxpdC5n ZXQoKVtpXSwgIkNIQVNTSVM9IikpIHsKKyAgICAgICAgICAgIGNoYXIqIGNoYXNzaXMgPSBzcGxp dC5nZXQoKVtpXSArIDg7CisgICAgICAgICAgICBpZiAoIXN0cmNtcChjaGFzc2lzLCAidGFibGV0 IikgfHwgIXN0cmNtcChjaGFzc2lzLCAiaGFuZHNldCIpKQorICAgICAgICAgICAgICAgIHJldHVy biBDaGFzc2lzVHlwZTo6TW9iaWxlOworCisgICAgICAgICAgICByZXR1cm4gQ2hhc3Npc1R5cGU6 OkRlc2t0b3A7CisgICAgICAgIH0KKyAgICB9CisKKyAgICByZXR1cm4gV1RGOjpudWxsb3B0Owor fQorCitzdGF0aWMgT3B0aW9uYWw8Q2hhc3Npc1R5cGU+IHJlYWRETUlDaGFzc2lzVHlwZSgpCit7 CisgICAgR1VuaXF1ZU91dFB0cjxjaGFyPiBidWZmZXI7CisgICAgR1VuaXF1ZU91dFB0cjxHRXJy b3I+IGVycm9yOworICAgIGlmIChnX2ZpbGVfZ2V0X2NvbnRlbnRzKCIvc3lzL2NsYXNzL2RtaS9p ZC9jaGFzc2lzX3R5cGUiLCAmYnVmZmVyLm91dFB0cigpLCBudWxscHRyLCAmZXJyb3Iub3V0UHRy KCkpKSB7CisgICAgICAgIGludCB0eXBlID0gc3RydG9sKGJ1ZmZlci5nZXQoKSwgbnVsbHB0ciwg MTApOworCisgICAgICAgIC8vIFNlZSB0aGUgU01CSU9TIFNwZWNpZmljYXRpb24gMy4wIHNlY3Rp b24gNy40LjEgZm9yIGRldGFpbHMgYWJvdXQgdGhlIHZhbHVlcyBsaXN0ZWQgaGVyZToKKyAgICAg ICAgLy8gaHR0cHM6Ly93d3cuZG10Zi5vcmcvc2l0ZXMvZGVmYXVsdC9maWxlcy9zdGFuZGFyZHMv ZG9jdW1lbnRzL0RTUDAxMzRfMy4wLjAucGRmCisgICAgICAgIHN3aXRjaCAodHlwZSkgeworICAg ICAgICBjYXNlIDB4MzogLyogRGVza3RvcCAqLworICAgICAgICBjYXNlIDB4NDogLyogTG93IFBy b2ZpbGUgRGVza3RvcCAqLworICAgICAgICBjYXNlIDB4NjogLyogTWluaSBUb3dlciAqLworICAg ICAgICBjYXNlIDB4NzogLyogVG93ZXIgKi8KKyAgICAgICAgY2FzZSAweDg6IC8qIFBvcnRhYmxl ICovCisgICAgICAgIGNhc2UgMHg5OiAvKiBMYXB0b3AgKi8KKyAgICAgICAgY2FzZSAweEE6IC8q IE5vdGVib29rICovCisgICAgICAgIGNhc2UgMHhFOiAvKiBTdWIgTm90ZWJvb2sgKi8KKyAgICAg ICAgY2FzZSAweDExOiAvKiBNYWluIFNlcnZlciBDaGFzc2lzICovCisgICAgICAgIGNhc2UgMHgx QzogLyogQmxhZGUgKi8KKyAgICAgICAgY2FzZSAweDFEOiAvKiBCbGFkZSBFbmNsb3N1cmUgKi8K KyAgICAgICAgY2FzZSAweDFGOiAvKiBDb252ZXJ0aWJsZSAqLworICAgICAgICBjYXNlIDB4MjA6 IC8qIERldGFjaGFibGUgKi8KKyAgICAgICAgICAgIHJldHVybiBDaGFzc2lzVHlwZTo6RGVza3Rv cDsKKworICAgICAgICBjYXNlIDB4QjogLyogSGFuZCBIZWxkICovCisgICAgICAgIGNhc2UgMHgx RTogLyogVGFibGV0ICovCisgICAgICAgICAgICByZXR1cm4gQ2hhc3Npc1R5cGU6Ok1vYmlsZTsK KyAgICAgICAgfQorICAgIH0gZWxzZSBpZiAoIWdfZXJyb3JfbWF0Y2hlcyhlcnJvci5nZXQoKSwg R19GSUxFX0VSUk9SLCBHX0ZJTEVfRVJST1JfTk9FTlQpKQorICAgICAgICBnX3dhcm5pbmcoIkNv dWxkIG5vdCBvcGVuIC9zeXMvY2xhc3MvZG1pL2lkL2NoYXNzaXNfdHlwZTogJXMiLCBlcnJvci0+ bWVzc2FnZSk7CisKKyAgICByZXR1cm4gV1RGOjpudWxsb3B0OworfQorCitzdGF0aWMgT3B0aW9u YWw8Q2hhc3Npc1R5cGU+IHJlYWRBQ1BJQ2hhc3Npc1R5cGUoKQoreworICAgIEdVbmlxdWVPdXRQ dHI8Y2hhcj4gYnVmZmVyOworICAgIEdVbmlxdWVPdXRQdHI8R0Vycm9yPiBlcnJvcjsKKyAgICBp ZiAoZ19maWxlX2dldF9jb250ZW50cygiL3N5cy9maXJtd2FyZS9hY3BpL3BtX3Byb2ZpbGUiLCAm YnVmZmVyLm91dFB0cigpLCBudWxscHRyLCAmZXJyb3Iub3V0UHRyKCkpKSB7CisgICAgICAgIGlu dCB0eXBlID0gc3RydG9sKGJ1ZmZlci5nZXQoKSwgbnVsbHB0ciwgMTApOworCisgICAgICAgIC8v IFNlZSB0aGUgQUNQSSA1LjAgU3BlYyBTZWN0aW9uIDUuMi45LjEgZm9yIGRldGFpbHM6CisgICAg ICAgIC8vIGh0dHA6Ly93d3cuYWNwaS5pbmZvL0RPV05MT0FEUy9BQ1BJc3BlYzUwLnBkZgorICAg ICAgICBzd2l0Y2ggKHR5cGUpIHsKKyAgICAgICAgY2FzZSAxOiAvKiBEZXNrdG9wICovCisgICAg ICAgIGNhc2UgMjogLyogTW9iaWxlICovCisgICAgICAgIGNhc2UgMzogLyogV29ya3N0YXRpb24g Ki8KKyAgICAgICAgY2FzZSA0OiAvKiBFbnRlcnByaXNlIFNlcnZlciAqLworICAgICAgICBjYXNl IDU6IC8qIFNPSE8gU2VydmVyICovCisgICAgICAgIGNhc2UgNjogLyogQXBwbGlhbmNlIFBDICov CisgICAgICAgIGNhc2UgNzogLyogUGVyZm9ybWFuY2UgU2VydmVyICovCisgICAgICAgICAgICBy ZXR1cm4gQ2hhc3Npc1R5cGU6OkRlc2t0b3A7CisKKyAgICAgICAgY2FzZSA4OiAvKiBUYWJsZXQg Ki8KKyAgICAgICAgICAgIHJldHVybiBDaGFzc2lzVHlwZTo6TW9iaWxlOworICAgICAgICB9Cisg ICAgfSBlbHNlIGlmICghZ19lcnJvcl9tYXRjaGVzKGVycm9yLmdldCgpLCBHX0ZJTEVfRVJST1Is IEdfRklMRV9FUlJPUl9OT0VOVCkpCisgICAgICAgIGdfd2FybmluZygiQ291bGQgbm90IG9wZW4g L3N5cy9maXJtd2FyZS9hY3BpL3BtX3Byb2ZpbGU6ICVzIiwgZXJyb3ItPm1lc3NhZ2UpOworCisg ICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKK30KKworQ2hhc3Npc1R5cGUgY2hhc3Npc1R5cGUoKQor eworICAgIHN0YXRpYyBDaGFzc2lzVHlwZSBjaGFzc2lzVHlwZTsKKyAgICBzdGF0aWMgc3RkOjpv bmNlX2ZsYWcgaW5pdGlhbGl6ZUNoYXNzaXM7CisgICAgc3RkOjpjYWxsX29uY2UoaW5pdGlhbGl6 ZUNoYXNzaXMsIFtdIHsKKyAgICAgICAgT3B0aW9uYWw8Q2hhc3Npc1R5cGU+IG9wdGlvbmFsQ2hh c3Npc1R5cGUgPSByZWFkTWFjaGluZUluZm9DaGFzc2lzVHlwZSgpOworICAgICAgICBpZiAoIW9w dGlvbmFsQ2hhc3Npc1R5cGUpCisgICAgICAgICAgICBvcHRpb25hbENoYXNzaXNUeXBlID0gcmVh ZERNSUNoYXNzaXNUeXBlKCk7CisgICAgICAgIGlmICghb3B0aW9uYWxDaGFzc2lzVHlwZSkKKyAg ICAgICAgICAgIG9wdGlvbmFsQ2hhc3Npc1R5cGUgPSByZWFkQUNQSUNoYXNzaXNUeXBlKCk7Cisg ICAgICAgIGNoYXNzaXNUeXBlID0gb3B0aW9uYWxDaGFzc2lzVHlwZS52YWx1ZU9yKENoYXNzaXNU eXBlOjpEZXNrdG9wKTsKKyAgICB9KTsKKworICAgIHJldHVybiBjaGFzc2lzVHlwZTsKK30KKwor fSAvLyBuYW1lc3BhY2UgV1RGCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9nbGliL0NoYXNz aXNUeXBlLmggYi9Tb3VyY2UvV1RGL3d0Zi9nbGliL0NoYXNzaXNUeXBlLmgKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4u NWM4NGE0NWUzMDlkMGY0ZjcxN2Q2MjE2N2IwZjdjNjI4MWY4M2FkMwotLS0gL2Rldi9udWxsCisr KyBiL1NvdXJjZS9XVEYvd3RmL2dsaWIvQ2hhc3Npc1R5cGUuaApAQCAtMCwwICsxLDM1IEBACisv KgorICogQ29weXJpZ2h0IChDKSAyMDIwIEphbi1NaWNoYWVsIEJydW1tZXIgPGphbi5icnVtbWVy QHRhYm9zLm9yZz4KKyAqCisgKiAgVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBj YW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMg b2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisgKiAgTGljZW5zZSBhcyBwdWJsaXNo ZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiAgdmVyc2lvbiAy IG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgor ICoKKyAqICBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3 aWxsIGJlIHVzZWZ1bCwKKyAqICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZl biB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNT IEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiAgTGlicmFyeSBHZW5l cmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogIFlvdSBzaG91bGQg aGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExp Y2Vuc2UKKyAqICBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcu TElCLiAgSWYgbm90LCB3cml0ZSB0bworICogIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24s IEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiAgQm9zdG9uLCBNQSAw MjExMC0xMzAxLCBVU0EuCisgKi8KKworI3ByYWdtYSBvbmNlCisKKyNpbmNsdWRlIDx3dGYvT3B0 aW9uYWwuaD4KKworbmFtZXNwYWNlIFdURiB7CisKK2VudW0gY2xhc3MgQ2hhc3Npc1R5cGUgewor ICAgIERlc2t0b3AsCisgICAgTW9iaWxlCit9OworCitXVEZfRVhQT1JUX1BSSVZBVEUgQ2hhc3Np c1R5cGUgY2hhc3Npc1R5cGUoKTsKKworfSAvLyBuYW1lc3BhY2UgV1RGCisKK3VzaW5nIFdURjo6 Y2hhc3Npc1R5cGU7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9Vc2VyQWdl bnRRdWlya3MuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVXNlckFnZW50UXVpcmtzLmNw cAppbmRleCA0YWJkYjg2YjdkNzlkNTg5YzAxOGE3ZTJiMTA0ZTQ1OWVjYWZlZDQzLi4xMDUzYTdh YTc1MzBmNWFlOGE4NjdlYjg5ZWQ3MGU5ZGRmNjE0MDE5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9Vc2VyQWdlbnRRdWlya3MuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL1VzZXJBZ2VudFF1aXJrcy5jcHAKQEAgLTI4LDYgKzI4LDcgQEAKIAogI2luY2x1ZGUg IlB1YmxpY1N1ZmZpeC5oIgogI2luY2x1ZGUgPHd0Zi9VUkwuaD4KKyNpbmNsdWRlIDx3dGYvZ2xp Yi9DaGFzc2lzVHlwZS5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKQEAgLTExOSwxMSArMTIw LDExIEBAIHN0YXRpYyBib29sIHVybFJlcXVpcmVzTWFjaW50b3NoUGxhdGZvcm0oY29uc3QgVVJM JiB1cmwpCiAgICAgU3RyaW5nIGJhc2VEb21haW4gPSB0b3BQcml2YXRlbHlDb250cm9sbGVkRG9t YWluKGRvbWFpbik7CiAKICAgICAvLyBBdCBsZWFzdCBmaW5hbmNlLnlhaG9vLmNvbSBkaXNwbGF5 cyBhIG1vYmlsZSB2ZXJzaW9uIHdpdGggV2ViS2l0R1RLJ3Mgc3RhbmRhcmQgdXNlciBhZ2VudC4K LSAgICBpZiAoYmFzZURvbWFpbiA9PSAieWFob28uY29tIikKKyAgICBpZiAoY2hhc3Npc1R5cGUo KSAhPSBXVEY6OkNoYXNzaXNUeXBlOjpNb2JpbGUgJiYgYmFzZURvbWFpbiA9PSAieWFob28uY29t IikKICAgICAgICAgcmV0dXJuIHRydWU7CiAKICAgICAvLyB0YW9iYW8uY29tIGRpc3BsYXlzIGEg bW9iaWxlIHZlcnNpb24gd2l0aCBXZWJLaXRHVEsncyBzdGFuZGFyZCB1c2VyIGFnZW50LgotICAg IGlmIChiYXNlRG9tYWluID09ICJ0YW9iYW8uY29tIikKKyAgICBpZiAoY2hhc3Npc1R5cGUoKSAh PSBXVEY6OkNoYXNzaXNUeXBlOjpNb2JpbGUgJiYgYmFzZURvbWFpbiA9PSAidGFvYmFvLmNvbSIp CiAgICAgICAgIHJldHVybiB0cnVlOwogCiAgICAgLy8gd2ViLndoYXRzYXBwLmNvbSBjb21wbGV0 ZWx5IGJsb2NrcyB1c2VycyB3aXRoIFdlYktpdEdUSydzIHN0YW5kYXJkIHVzZXIgYWdlbnQuCkBA IC0xNTIsNyArMTUzLDcgQEAgc3RhdGljIGJvb2wgdXJsUmVxdWlyZXNNYWNpbnRvc2hQbGF0Zm9y bShjb25zdCBVUkwmIHVybCkKIAogc3RhdGljIGJvb2wgdXJsUmVxdWlyZXNMaW51eERlc2t0b3BQ bGF0Zm9ybShjb25zdCBVUkwmIHVybCkKIHsKLSAgICByZXR1cm4gaXNHb29nbGUodXJsKTsKKyAg ICByZXR1cm4gaXNHb29nbGUodXJsKSAmJiBjaGFzc2lzVHlwZSgpICE9IFdURjo6Q2hhc3Npc1R5 cGU6Ok1vYmlsZTsKIH0KIAogVXNlckFnZW50UXVpcmtzIFVzZXJBZ2VudFF1aXJrczo6cXVpcmtz Rm9yVVJMKGNvbnN0IFVSTCYgdXJsKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ2xpYi9Vc2VyQWdlbnRHTGliLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dsaWIv VXNlckFnZW50R0xpYi5jcHAKaW5kZXggM2UxNmM3YWFmNzk4MTI1YzRmZjhmZTcwNzRlYzIyNzQy ODdhZGU3OS4uYTU4MDgxZjRjYjNjNjVjMDcyMGZlOTI2ZjU0OTYzMDQwYWVjMTZkOSAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ2xpYi9Vc2VyQWdlbnRHTGliLmNwcAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9nbGliL1VzZXJBZ2VudEdMaWIuY3BwCkBAIC0zMSw2 ICszMSw3IEBACiAjaW5jbHVkZSAiVXNlckFnZW50UXVpcmtzLmgiCiAjaW5jbHVkZSA8d3RmL05l dmVyRGVzdHJveWVkLmg+CiAjaW5jbHVkZSA8d3RmL1VSTC5oPgorI2luY2x1ZGUgPHd0Zi9nbGli L0NoYXNzaXNUeXBlLmg+CiAjaW5jbHVkZSA8d3RmL3RleHQvU3RyaW5nQnVpbGRlci5oPgogCiAj aWYgT1MoVU5JWCkKQEAgLTUwLDYgKzUxLDggQEAgc3RhdGljIGNvbnN0IGNoYXIqIHBsYXRmb3Jt Rm9yVUFTdHJpbmcoKQogI2lmIE9TKE1BQ19PU19YKQogICAgIHJldHVybiAiTWFjaW50b3NoIjsK ICNlbHNlCisgICAgaWYgKGNoYXNzaXNUeXBlKCkgPT0gV1RGOjpDaGFzc2lzVHlwZTo6TW9iaWxl KQorICAgICAgICByZXR1cm4gIkxpbnV4IjsKICAgICByZXR1cm4gIlgxMSI7CiAjZW5kaWYKIH0K QEAgLTU3LDYgKzYwLDkgQEAgc3RhdGljIGNvbnN0IGNoYXIqIHBsYXRmb3JtRm9yVUFTdHJpbmco KQogc3RhdGljIGNvbnN0IFN0cmluZyBwbGF0Zm9ybVZlcnNpb25Gb3JVQVN0cmluZygpCiB7CiAj aWYgT1MoVU5JWCkKKyAgICBpZiAoY2hhc3Npc1R5cGUoKSA9PSBXVEY6OkNoYXNzaXNUeXBlOjpN b2JpbGUpCisgICAgICAgIHJldHVybiAibGlrZSBBbmRyb2lkIDQuNCI7CisKICAgICBzdHJ1Y3Qg dXRzbmFtZSBuYW1lOwogICAgIHVuYW1lKCZuYW1lKTsKICAgICBzdGF0aWMgTmV2ZXJEZXN0cm95 ZWQ8Y29uc3QgU3RyaW5nPiB1YU9TVmVyc2lvbihtYWtlU3RyaW5nKG5hbWUuc3lzbmFtZSwgJyAn LCBuYW1lLm1hY2hpbmUpKTsKQEAgLTExMyw2ICsxMTksOSBAQCBzdGF0aWMgU3RyaW5nIGJ1aWxk VXNlckFnZW50U3RyaW5nKGNvbnN0IFVzZXJBZ2VudFF1aXJrcyYgcXVpcmtzKQogICAgIC8vIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMzM0MDMgZm9yIGRldGFpbHMu CiAgICAgfSBlbHNlCiAgICAgICAgIHVhU3RyaW5nLmFwcGVuZExpdGVyYWwoIlZlcnNpb24vMTMu MCAiKTsKKworICAgIGlmIChjaGFzc2lzVHlwZSgpID09IFdURjo6Q2hhc3Npc1R5cGU6Ok1vYmls ZSkKKyAgICAgICAgdWFTdHJpbmcuYXBwZW5kTGl0ZXJhbCgiTW9iaWxlICIpOwogICAgIHVhU3Ry aW5nLmFwcGVuZExpdGVyYWwoIlNhZmFyaS8iKTsKICAgICB1YVN0cmluZy5hcHBlbmQodmVyc2lv bkZvclVBU3RyaW5nKCkpOwogCg== 403949 2020-07-10 00:18:55 -0700 2020-07-10 02:16:24 -0700 Patch bug-149496-20200710091854.patch text/plain 12272 jan.brummer U3VidmVyc2lvbiBSZXZpc2lvbjogMjYzNjYzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggODc2MWFiMDQyYzc3MjNl M2ZiYTJmN2RlMmZmZTVjM2JjZmY3ZjU3Ni4uOTE2M2JiNzhmODliYzMyMTY2Zjk4ZjdhNzE0MTll MjhlMzlhMjY3OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIzIEBACisyMDIwLTA2LTI5ICBKYW4t TWljaGFlbCBCcnVtbWVyICA8amFuLmJydW1tZXJAdGFib3Mub3JnPgorCisgICAgICAgIFtHVEtd W1dQRV0gVXNlIG1vYmlsZSB1c2VyLWFnZW50IG9uIHRhYmxldAorICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQ5NDk2CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9Vc2VyQWdlbnRRdWlya3Mu Y3BwOgorICAgICAgICAoV2ViQ29yZTo6dXJsUmVxdWlyZXNNYWNpbnRvc2hQbGF0Zm9ybSk6Cisg ICAgICAgIChXZWJDb3JlOjp1cmxSZXF1aXJlc0xpbnV4RGVza3RvcFBsYXRmb3JtKToKKyAgICAg ICAgKFdlYkNvcmU6OlVzZXJBZ2VudFF1aXJrczo6cXVpcmtzRm9yVVJMKToKKyAgICAgICAgKiBw bGF0Zm9ybS9Vc2VyQWdlbnRRdWlya3MuaDoKKyAgICAgICAgKiBwbGF0Zm9ybS9nbGliL1VzZXJB Z2VudEdMaWIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Z2V0Q2hhc3Npc1R5cGUpOgorICAgICAg ICAoV2ViQ29yZTo6cGxhdGZvcm1Gb3JVQVN0cmluZyk6CisgICAgICAgIChXZWJDb3JlOjpwbGF0 Zm9ybVZlcnNpb25Gb3JVQVN0cmluZyk6CisgICAgICAgIChXZWJDb3JlOjpidWlsZFVzZXJBZ2Vu dFN0cmluZyk6CisgICAgICAgIChXZWJDb3JlOjpzdGFuZGFyZFVzZXJBZ2VudCk6CisgICAgICAg IChXZWJDb3JlOjpzdGFuZGFyZFVzZXJBZ2VudEZvclVSTCk6CisKIDIwMjAtMDYtMjkgIENocmlz IER1bWV6ICA8Y2R1bWV6QGFwcGxlLmNvbT4KIAogICAgICAgICBPbiBsb2FkIGZyb20gYmFjay9m b3J3YXJkIGNhY2hlLCBjYWxsIGNoZWNrQ29tcGxldGVkKCkgZm9yIEFMTCBmcmFtZXMgaW5zaWRl IEZyYW1lTG9hZGVyOjpjb21taXRQcm92aXNpb25hbExvYWQoKQpkaWZmIC0tZ2l0IGEvU291cmNl L1dURi93dGYvUGxhdGZvcm1HVEsuY21ha2UgYi9Tb3VyY2UvV1RGL3d0Zi9QbGF0Zm9ybUdUSy5j bWFrZQppbmRleCBhMDRlMWQ4NWYxYThjNWUwZjk1MGI5OTJhYzkyMDIyZjU2NWQ2ZDdmLi40NWJi OWRkMTFiYTlkYWY0MzU5OWU1ZWIxZTI0YmE0YzgwODA4MzMwIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V1RGL3d0Zi9QbGF0Zm9ybUdUSy5jbWFrZQorKysgYi9Tb3VyY2UvV1RGL3d0Zi9QbGF0Zm9ybUdU Sy5jbWFrZQpAQCAtMSw2ICsxLDcgQEAKIHNldChXVEZfT1VUUFVUX05BTUUgV1RGR1RLKQogCiBs aXN0KEFQUEVORCBXVEZfUFVCTElDX0hFQURFUlMKKyAgICBnbGliL0NoYXNzaXNUeXBlLmgKICAg ICBnbGliL0dMaWJVdGlsaXRpZXMuaAogICAgIGdsaWIvR011dGV4TG9ja2VyLmgKICAgICBnbGli L0dSZWZQdHIuaApAQCAtMjMsNiArMjQsNyBAQCBsaXN0KEFQUEVORCBXVEZfU09VUkNFUwogICAg IGdlbmVyaWMvTWFpblRocmVhZEdlbmVyaWMuY3BwCiAgICAgZ2VuZXJpYy9Xb3JrUXVldWVHZW5l cmljLmNwcAogCisgICAgZ2xpYi9DaGFzc2lzVHlwZS5jcHAKICAgICBnbGliL0ZpbGVTeXN0ZW1H bGliLmNwcAogICAgIGdsaWIvR0xpYlV0aWxpdGllcy5jcHAKICAgICBnbGliL0dSZWZQdHIuY3Bw CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9QbGF0Zm9ybVdQRS5jbWFrZSBiL1NvdXJjZS9X VEYvd3RmL1BsYXRmb3JtV1BFLmNtYWtlCmluZGV4IDc1OTVhMjc3MDg0NDEzNTdkYWViZjk1YWU2 ZjE3YTgwM2Q2NTFlNjguLjQ2MTQ4ZjhiNTRiMDYyYmQ3ZjhkNmMzZmQ3NmMxODk4M2Q2YmUyOGYg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL1BsYXRmb3JtV1BFLmNtYWtlCisrKyBiL1NvdXJj ZS9XVEYvd3RmL1BsYXRmb3JtV1BFLmNtYWtlCkBAIC0xLDQgKzEsNSBAQAogbGlzdChBUFBFTkQg V1RGX1BVQkxJQ19IRUFERVJTCisgICAgZ2xpYi9DaGFzc2lzVHlwZS5oCiAgICAgZ2xpYi9HTGli VXRpbGl0aWVzLmgKICAgICBnbGliL0dNdXRleExvY2tlci5oCiAgICAgZ2xpYi9HUmVmUHRyLmgK QEAgLTE4LDYgKzE5LDcgQEAgbGlzdChBUFBFTkQgV1RGX1NPVVJDRVMKICAgICBnZW5lcmljL01l bW9yeUZvb3RwcmludEdlbmVyaWMuY3BwCiAgICAgZ2VuZXJpYy9Xb3JrUXVldWVHZW5lcmljLmNw cAogCisgICAgZ2xpYi9DaGFzc2lzVHlwZS5jcHAKICAgICBnbGliL0ZpbGVTeXN0ZW1HbGliLmNw cAogICAgIGdsaWIvR0xpYlV0aWxpdGllcy5jcHAKICAgICBnbGliL0dSZWZQdHIuY3BwCmRpZmYg LS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9nbGliL0NoYXNzaXNUeXBlLmNwcCBiL1NvdXJjZS9XVEYv d3RmL2dsaWIvQ2hhc3Npc1R5cGUuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjNmYzMyNmUzYmFjMzE3NTg1Y2Ix NzEyZTgxYTM3MDc1M2I0ZDBmMzcKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9n bGliL0NoYXNzaXNUeXBlLmNwcApAQCAtMCwwICsxLDEzOCBAQAorLyoKKyAqIENvcHlyaWdodCAo QykgMjAyMCBKYW4tTWljaGFlbCBCcnVtbWVyIDxqYW4uYnJ1bW1lckB0YWJvcy5vcmc+CisgKgor ICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0 aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhh dCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1 dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICog ICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9k dWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50 YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRp b24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIGBgQVMg SVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5H LCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNI QU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBE SVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUgorICogQ09OVFJJQlVU T1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJ QUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBC VVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9S IFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNT IElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJ QUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAor ICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZ IE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0Yg VEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcu aCIKKyNpbmNsdWRlIDx3dGYvZ2xpYi9DaGFzc2lzVHlwZS5oPgorCisjaW5jbHVkZSA8bXV0ZXg+ CisjaW5jbHVkZSA8d3RmL09wdGlvbmFsLmg+CisjaW5jbHVkZSA8d3RmL2dsaWIvR1VuaXF1ZVB0 ci5oPgorCituYW1lc3BhY2UgV1RGIHsKKworc3RhdGljIE9wdGlvbmFsPENoYXNzaXNUeXBlPiBy ZWFkTWFjaGluZUluZm9DaGFzc2lzVHlwZSgpCit7CisgICAgR1VuaXF1ZU91dFB0cjxjaGFyPiBi dWZmZXI7CisgICAgR1VuaXF1ZU91dFB0cjxHRXJyb3I+IGVycm9yOworICAgIGlmICghZ19maWxl X2dldF9jb250ZW50cygiL2V0Yy9tYWNoaW5lLWluZm8iLCAmYnVmZmVyLm91dFB0cigpLCBudWxs cHRyLCAmZXJyb3Iub3V0UHRyKCkpKSB7CisgICAgICAgIGlmICghZ19lcnJvcl9tYXRjaGVzKGVy cm9yLmdldCgpLCBHX0ZJTEVfRVJST1IsIEdfRklMRV9FUlJPUl9OT0VOVCkpCisgICAgICAgICAg ICBnX3dhcm5pbmcoIkNvdWxkIG5vdCBvcGVuIC9ldGMvbWFjaGluZS1pbmZvOiAlcyIsIGVycm9y LT5tZXNzYWdlKTsKKyAgICAgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKKyAgICB9CisKKyAgICBH VW5pcXVlUHRyPGNoYXIqPiBzcGxpdChnX3N0cnNwbGl0KGJ1ZmZlci5nZXQoKSwgIlxuIiwgLTEp KTsKKyAgICBmb3IgKGludCBpID0gMDsgc3BsaXQuZ2V0KClbaV07ICsraSkgeworICAgICAgICBp ZiAoZ19zdHJfaGFzX3ByZWZpeChzcGxpdC5nZXQoKVtpXSwgIkNIQVNTSVM9IikpIHsKKyAgICAg ICAgICAgIGNoYXIqIGNoYXNzaXMgPSBzcGxpdC5nZXQoKVtpXSArIDg7CisgICAgICAgICAgICBp ZiAoIXN0cmNtcChjaGFzc2lzLCAidGFibGV0IikgfHwgIXN0cmNtcChjaGFzc2lzLCAiaGFuZHNl dCIpKQorICAgICAgICAgICAgICAgIHJldHVybiBDaGFzc2lzVHlwZTo6TW9iaWxlOworCisgICAg ICAgICAgICByZXR1cm4gQ2hhc3Npc1R5cGU6OkRlc2t0b3A7CisgICAgICAgIH0KKyAgICB9CisK KyAgICByZXR1cm4gV1RGOjpudWxsb3B0OworfQorCitzdGF0aWMgT3B0aW9uYWw8Q2hhc3Npc1R5 cGU+IHJlYWRETUlDaGFzc2lzVHlwZSgpCit7CisgICAgR1VuaXF1ZU91dFB0cjxjaGFyPiBidWZm ZXI7CisgICAgR1VuaXF1ZU91dFB0cjxHRXJyb3I+IGVycm9yOworICAgIGlmIChnX2ZpbGVfZ2V0 X2NvbnRlbnRzKCIvc3lzL2NsYXNzL2RtaS9pZC9jaGFzc2lzX3R5cGUiLCAmYnVmZmVyLm91dFB0 cigpLCBudWxscHRyLCAmZXJyb3Iub3V0UHRyKCkpKSB7CisgICAgICAgIGludCB0eXBlID0gc3Ry dG9sKGJ1ZmZlci5nZXQoKSwgbnVsbHB0ciwgMTApOworCisgICAgICAgIC8vIFNlZSB0aGUgU01C SU9TIFNwZWNpZmljYXRpb24gMy4wIHNlY3Rpb24gNy40LjEgZm9yIGRldGFpbHMgYWJvdXQgdGhl IHZhbHVlcyBsaXN0ZWQgaGVyZToKKyAgICAgICAgLy8gaHR0cHM6Ly93d3cuZG10Zi5vcmcvc2l0 ZXMvZGVmYXVsdC9maWxlcy9zdGFuZGFyZHMvZG9jdW1lbnRzL0RTUDAxMzRfMy4wLjAucGRmCisg ICAgICAgIHN3aXRjaCAodHlwZSkgeworICAgICAgICBjYXNlIDB4MzogLyogRGVza3RvcCAqLwor ICAgICAgICBjYXNlIDB4NDogLyogTG93IFByb2ZpbGUgRGVza3RvcCAqLworICAgICAgICBjYXNl IDB4NjogLyogTWluaSBUb3dlciAqLworICAgICAgICBjYXNlIDB4NzogLyogVG93ZXIgKi8KKyAg ICAgICAgY2FzZSAweDg6IC8qIFBvcnRhYmxlICovCisgICAgICAgIGNhc2UgMHg5OiAvKiBMYXB0 b3AgKi8KKyAgICAgICAgY2FzZSAweEE6IC8qIE5vdGVib29rICovCisgICAgICAgIGNhc2UgMHhF OiAvKiBTdWIgTm90ZWJvb2sgKi8KKyAgICAgICAgY2FzZSAweDExOiAvKiBNYWluIFNlcnZlciBD aGFzc2lzICovCisgICAgICAgIGNhc2UgMHgxQzogLyogQmxhZGUgKi8KKyAgICAgICAgY2FzZSAw eDFEOiAvKiBCbGFkZSBFbmNsb3N1cmUgKi8KKyAgICAgICAgY2FzZSAweDFGOiAvKiBDb252ZXJ0 aWJsZSAqLworICAgICAgICBjYXNlIDB4MjA6IC8qIERldGFjaGFibGUgKi8KKyAgICAgICAgICAg IHJldHVybiBDaGFzc2lzVHlwZTo6RGVza3RvcDsKKworICAgICAgICBjYXNlIDB4QjogLyogSGFu ZCBIZWxkICovCisgICAgICAgIGNhc2UgMHgxRTogLyogVGFibGV0ICovCisgICAgICAgICAgICBy ZXR1cm4gQ2hhc3Npc1R5cGU6Ok1vYmlsZTsKKyAgICAgICAgfQorICAgIH0gZWxzZSBpZiAoIWdf ZXJyb3JfbWF0Y2hlcyhlcnJvci5nZXQoKSwgR19GSUxFX0VSUk9SLCBHX0ZJTEVfRVJST1JfTk9F TlQpKQorICAgICAgICBnX3dhcm5pbmcoIkNvdWxkIG5vdCBvcGVuIC9zeXMvY2xhc3MvZG1pL2lk L2NoYXNzaXNfdHlwZTogJXMiLCBlcnJvci0+bWVzc2FnZSk7CisKKyAgICByZXR1cm4gV1RGOjpu dWxsb3B0OworfQorCitzdGF0aWMgT3B0aW9uYWw8Q2hhc3Npc1R5cGU+IHJlYWRBQ1BJQ2hhc3Np c1R5cGUoKQoreworICAgIEdVbmlxdWVPdXRQdHI8Y2hhcj4gYnVmZmVyOworICAgIEdVbmlxdWVP dXRQdHI8R0Vycm9yPiBlcnJvcjsKKyAgICBpZiAoZ19maWxlX2dldF9jb250ZW50cygiL3N5cy9m aXJtd2FyZS9hY3BpL3BtX3Byb2ZpbGUiLCAmYnVmZmVyLm91dFB0cigpLCBudWxscHRyLCAmZXJy b3Iub3V0UHRyKCkpKSB7CisgICAgICAgIGludCB0eXBlID0gc3RydG9sKGJ1ZmZlci5nZXQoKSwg bnVsbHB0ciwgMTApOworCisgICAgICAgIC8vIFNlZSB0aGUgQUNQSSA1LjAgU3BlYyBTZWN0aW9u IDUuMi45LjEgZm9yIGRldGFpbHM6CisgICAgICAgIC8vIGh0dHA6Ly93d3cuYWNwaS5pbmZvL0RP V05MT0FEUy9BQ1BJc3BlYzUwLnBkZgorICAgICAgICBzd2l0Y2ggKHR5cGUpIHsKKyAgICAgICAg Y2FzZSAxOiAvKiBEZXNrdG9wICovCisgICAgICAgIGNhc2UgMjogLyogTW9iaWxlICovCisgICAg ICAgIGNhc2UgMzogLyogV29ya3N0YXRpb24gKi8KKyAgICAgICAgY2FzZSA0OiAvKiBFbnRlcnBy aXNlIFNlcnZlciAqLworICAgICAgICBjYXNlIDU6IC8qIFNPSE8gU2VydmVyICovCisgICAgICAg IGNhc2UgNjogLyogQXBwbGlhbmNlIFBDICovCisgICAgICAgIGNhc2UgNzogLyogUGVyZm9ybWFu Y2UgU2VydmVyICovCisgICAgICAgICAgICByZXR1cm4gQ2hhc3Npc1R5cGU6OkRlc2t0b3A7CisK KyAgICAgICAgY2FzZSA4OiAvKiBUYWJsZXQgKi8KKyAgICAgICAgICAgIHJldHVybiBDaGFzc2lz VHlwZTo6TW9iaWxlOworICAgICAgICB9CisgICAgfSBlbHNlIGlmICghZ19lcnJvcl9tYXRjaGVz KGVycm9yLmdldCgpLCBHX0ZJTEVfRVJST1IsIEdfRklMRV9FUlJPUl9OT0VOVCkpCisgICAgICAg IGdfd2FybmluZygiQ291bGQgbm90IG9wZW4gL3N5cy9maXJtd2FyZS9hY3BpL3BtX3Byb2ZpbGU6 ICVzIiwgZXJyb3ItPm1lc3NhZ2UpOworCisgICAgcmV0dXJuIFdURjo6bnVsbG9wdDsKK30KKwor Q2hhc3Npc1R5cGUgY2hhc3Npc1R5cGUoKQoreworICAgIHN0YXRpYyBDaGFzc2lzVHlwZSBjaGFz c2lzVHlwZTsKKyAgICBzdGF0aWMgc3RkOjpvbmNlX2ZsYWcgaW5pdGlhbGl6ZUNoYXNzaXM7Cisg ICAgc3RkOjpjYWxsX29uY2UoaW5pdGlhbGl6ZUNoYXNzaXMsIFtdIHsKKyAgICAgICAgT3B0aW9u YWw8Q2hhc3Npc1R5cGU+IG9wdGlvbmFsQ2hhc3Npc1R5cGUgPSByZWFkTWFjaGluZUluZm9DaGFz c2lzVHlwZSgpOworICAgICAgICBpZiAoIW9wdGlvbmFsQ2hhc3Npc1R5cGUpCisgICAgICAgICAg ICBvcHRpb25hbENoYXNzaXNUeXBlID0gcmVhZERNSUNoYXNzaXNUeXBlKCk7CisgICAgICAgIGlm ICghb3B0aW9uYWxDaGFzc2lzVHlwZSkKKyAgICAgICAgICAgIG9wdGlvbmFsQ2hhc3Npc1R5cGUg PSByZWFkQUNQSUNoYXNzaXNUeXBlKCk7CisgICAgICAgIGNoYXNzaXNUeXBlID0gb3B0aW9uYWxD aGFzc2lzVHlwZS52YWx1ZU9yKENoYXNzaXNUeXBlOjpEZXNrdG9wKTsKKyAgICB9KTsKKworICAg IHJldHVybiBjaGFzc2lzVHlwZTsKK30KKworfSAvLyBuYW1lc3BhY2UgV1RGCmRpZmYgLS1naXQg YS9Tb3VyY2UvV1RGL3d0Zi9nbGliL0NoYXNzaXNUeXBlLmggYi9Tb3VyY2UvV1RGL3d0Zi9nbGli L0NoYXNzaXNUeXBlLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYWE4YTYxMzU5MDgxNGI2NWNiNDM5NzI4YjQ0MTA1 OTljMjBhN2YwZgotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XVEYvd3RmL2dsaWIvQ2hhc3Np c1R5cGUuaApAQCAtMCwwICsxLDMzIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDIwIEphbi1N aWNoYWVsIEJydW1tZXIgPGphbi5icnVtbWVyQHRhYm9zLm9yZz4KKyAqCisgKiAgVGhpcyBsaWJy YXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICog IG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVi bGljCisgKiAgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRh dGlvbjsgZWl0aGVyCisgKiAgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBv cHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqICBUaGlzIGxpYnJhcnkgaXMgZGlzdHJp YnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqICBidXQgV0lUSE9V VCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICog IE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNl ZSB0aGUgR05VCisgKiAgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRl dGFpbHMuCisgKgorICogIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdO VSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqICBhbG9uZyB3aXRoIHRoaXMgbGli cmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICogIHRo ZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlm dGggRmxvb3IsCisgKiAgQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisgKi8KKworI3ByYWdt YSBvbmNlCisKK25hbWVzcGFjZSBXVEYgeworCitlbnVtIGNsYXNzIENoYXNzaXNUeXBlIHsKKyAg ICBEZXNrdG9wLAorICAgIE1vYmlsZQorfTsKKworV1RGX0VYUE9SVF9QUklWQVRFIENoYXNzaXNU eXBlIGNoYXNzaXNUeXBlKCk7CisKK30gLy8gbmFtZXNwYWNlIFdURgorCit1c2luZyBXVEY6OmNo YXNzaXNUeXBlOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vVXNlckFnZW50 UXVpcmtzLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1VzZXJBZ2VudFF1aXJrcy5jcHAK aW5kZXggNGFiZGI4NmI3ZDc5ZDU4OWMwMThhN2UyYjEwNGU0NTllY2FmZWQ0My4uMTA1M2E3YWE3 NTMwZjVhZThhODY3ZWI4OWVkNzBlOWRkZjYxNDAxOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vVXNlckFnZW50UXVpcmtzLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9Vc2VyQWdlbnRRdWlya3MuY3BwCkBAIC0yOCw2ICsyOCw3IEBACiAKICNpbmNsdWRlICJQ dWJsaWNTdWZmaXguaCIKICNpbmNsdWRlIDx3dGYvVVJMLmg+CisjaW5jbHVkZSA8d3RmL2dsaWIv Q2hhc3Npc1R5cGUuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCkBAIC0xMTksMTEgKzEyMCwx MSBAQCBzdGF0aWMgYm9vbCB1cmxSZXF1aXJlc01hY2ludG9zaFBsYXRmb3JtKGNvbnN0IFVSTCYg dXJsKQogICAgIFN0cmluZyBiYXNlRG9tYWluID0gdG9wUHJpdmF0ZWx5Q29udHJvbGxlZERvbWFp bihkb21haW4pOwogCiAgICAgLy8gQXQgbGVhc3QgZmluYW5jZS55YWhvby5jb20gZGlzcGxheXMg YSBtb2JpbGUgdmVyc2lvbiB3aXRoIFdlYktpdEdUSydzIHN0YW5kYXJkIHVzZXIgYWdlbnQuCi0g ICAgaWYgKGJhc2VEb21haW4gPT0gInlhaG9vLmNvbSIpCisgICAgaWYgKGNoYXNzaXNUeXBlKCkg IT0gV1RGOjpDaGFzc2lzVHlwZTo6TW9iaWxlICYmIGJhc2VEb21haW4gPT0gInlhaG9vLmNvbSIp CiAgICAgICAgIHJldHVybiB0cnVlOwogCiAgICAgLy8gdGFvYmFvLmNvbSBkaXNwbGF5cyBhIG1v YmlsZSB2ZXJzaW9uIHdpdGggV2ViS2l0R1RLJ3Mgc3RhbmRhcmQgdXNlciBhZ2VudC4KLSAgICBp ZiAoYmFzZURvbWFpbiA9PSAidGFvYmFvLmNvbSIpCisgICAgaWYgKGNoYXNzaXNUeXBlKCkgIT0g V1RGOjpDaGFzc2lzVHlwZTo6TW9iaWxlICYmIGJhc2VEb21haW4gPT0gInRhb2Jhby5jb20iKQog ICAgICAgICByZXR1cm4gdHJ1ZTsKIAogICAgIC8vIHdlYi53aGF0c2FwcC5jb20gY29tcGxldGVs eSBibG9ja3MgdXNlcnMgd2l0aCBXZWJLaXRHVEsncyBzdGFuZGFyZCB1c2VyIGFnZW50LgpAQCAt MTUyLDcgKzE1Myw3IEBAIHN0YXRpYyBib29sIHVybFJlcXVpcmVzTWFjaW50b3NoUGxhdGZvcm0o Y29uc3QgVVJMJiB1cmwpCiAKIHN0YXRpYyBib29sIHVybFJlcXVpcmVzTGludXhEZXNrdG9wUGxh dGZvcm0oY29uc3QgVVJMJiB1cmwpCiB7Ci0gICAgcmV0dXJuIGlzR29vZ2xlKHVybCk7CisgICAg cmV0dXJuIGlzR29vZ2xlKHVybCkgJiYgY2hhc3Npc1R5cGUoKSAhPSBXVEY6OkNoYXNzaXNUeXBl OjpNb2JpbGU7CiB9CiAKIFVzZXJBZ2VudFF1aXJrcyBVc2VyQWdlbnRRdWlya3M6OnF1aXJrc0Zv clVSTChjb25zdCBVUkwmIHVybCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dsaWIvVXNlckFnZW50R0xpYi5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9nbGliL1Vz ZXJBZ2VudEdMaWIuY3BwCmluZGV4IDNlMTZjN2FhZjc5ODEyNWM0ZmY4ZmU3MDc0ZWMyMjc0Mjg3 YWRlNzkuLmE1ODA4MWY0Y2IzYzY1YzA3MjBmZTkyNmY1NDk2MzA0MGFlYzE2ZDkgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dsaWIvVXNlckFnZW50R0xpYi5jcHAKKysrIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ2xpYi9Vc2VyQWdlbnRHTGliLmNwcApAQCAtMzEsNiAr MzEsNyBAQAogI2luY2x1ZGUgIlVzZXJBZ2VudFF1aXJrcy5oIgogI2luY2x1ZGUgPHd0Zi9OZXZl ckRlc3Ryb3llZC5oPgogI2luY2x1ZGUgPHd0Zi9VUkwuaD4KKyNpbmNsdWRlIDx3dGYvZ2xpYi9D aGFzc2lzVHlwZS5oPgogI2luY2x1ZGUgPHd0Zi90ZXh0L1N0cmluZ0J1aWxkZXIuaD4KIAogI2lm IE9TKFVOSVgpCkBAIC01MCw2ICs1MSw4IEBAIHN0YXRpYyBjb25zdCBjaGFyKiBwbGF0Zm9ybUZv clVBU3RyaW5nKCkKICNpZiBPUyhNQUNfT1NfWCkKICAgICByZXR1cm4gIk1hY2ludG9zaCI7CiAj ZWxzZQorICAgIGlmIChjaGFzc2lzVHlwZSgpID09IFdURjo6Q2hhc3Npc1R5cGU6Ok1vYmlsZSkK KyAgICAgICAgcmV0dXJuICJMaW51eCI7CiAgICAgcmV0dXJuICJYMTEiOwogI2VuZGlmCiB9CkBA IC01Nyw2ICs2MCw5IEBAIHN0YXRpYyBjb25zdCBjaGFyKiBwbGF0Zm9ybUZvclVBU3RyaW5nKCkK IHN0YXRpYyBjb25zdCBTdHJpbmcgcGxhdGZvcm1WZXJzaW9uRm9yVUFTdHJpbmcoKQogewogI2lm IE9TKFVOSVgpCisgICAgaWYgKGNoYXNzaXNUeXBlKCkgPT0gV1RGOjpDaGFzc2lzVHlwZTo6TW9i aWxlKQorICAgICAgICByZXR1cm4gImxpa2UgQW5kcm9pZCA0LjQiOworCiAgICAgc3RydWN0IHV0 c25hbWUgbmFtZTsKICAgICB1bmFtZSgmbmFtZSk7CiAgICAgc3RhdGljIE5ldmVyRGVzdHJveWVk PGNvbnN0IFN0cmluZz4gdWFPU1ZlcnNpb24obWFrZVN0cmluZyhuYW1lLnN5c25hbWUsICcgJywg bmFtZS5tYWNoaW5lKSk7CkBAIC0xMTMsNiArMTE5LDkgQEAgc3RhdGljIFN0cmluZyBidWlsZFVz ZXJBZ2VudFN0cmluZyhjb25zdCBVc2VyQWdlbnRRdWlya3MmIHF1aXJrcykKICAgICAvLyBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTMzNDAzIGZvciBkZXRhaWxzLgog ICAgIH0gZWxzZQogICAgICAgICB1YVN0cmluZy5hcHBlbmRMaXRlcmFsKCJWZXJzaW9uLzEzLjAg Iik7CisKKyAgICBpZiAoY2hhc3Npc1R5cGUoKSA9PSBXVEY6OkNoYXNzaXNUeXBlOjpNb2JpbGUp CisgICAgICAgIHVhU3RyaW5nLmFwcGVuZExpdGVyYWwoIk1vYmlsZSAiKTsKICAgICB1YVN0cmlu Zy5hcHBlbmRMaXRlcmFsKCJTYWZhcmkvIik7CiAgICAgdWFTdHJpbmcuYXBwZW5kKHZlcnNpb25G b3JVQVN0cmluZygpKTsKIAo=