173655 2017-06-21 09:14:16 -0700 [GStreamer][MiniBrowser] Honor GStreamer command line parameters in MiniBrowser 2018-02-26 01:25:48 -0800 1 1 1 Unclassified WebKit Media WebKit Local Build Unspecified Unspecified RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=183119 InRadar P2 Enhancement --- 1 eocanha vchipirras calvaris cgarcia mcatanzaro pnormand webkit-bug-importer zan oldest_to_newest 1321510 0 eocanha 2017-06-21 09:14:16 -0700 This FIXME in GStreamerUtilities.cpp asks to pass the command line parameters to the GStreamer initialization function: https://github.com/WebKit/webkit/blob/80403285b787da5677372e320efca24b304ea5b4/Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp#L154 Having support for GStreamer command line parameters would be nice for debugging MiniBrowser. 1322333 1 313727 vchipirras 2017-06-23 10:33:39 -0700 Created attachment 313727 Patch 1322771 2 313727 calvaris 2017-06-26 02:25:25 -0700 Comment on attachment 313727 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=313727&action=review > Source/WebCore/ChangeLog:12 > + (WebCore::initializeGStreamer): Here gets the Gstreamer's option from GStreamer should be spelled like this. > Source/WebCore/ChangeLog:13 > + the main() and create the char "argv" to Initialize the GStreamer library. "the main() function" or just "main()". Initialized does not need to be capitalized. > Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp:155 > + Please remove this empty line. > Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp:156 > + const gchar* gstArgv = g_getenv("GST_ARGUMENTS"); const char* gstreamerArgumentsString > Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp:157 > + bool gstInitialized = false; bool isGStreamerInitialized > Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp:160 > + Please remove this empty line. > Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp:161 > + gchar ** argvSplit = g_strsplit(gstArgv, " ", -1); char** splitGStreamerArguments > Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp:162 > + guint argcSizeSplit = g_strv_length(argvSplit); unsigned gstreamerArgumentsSize > Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp:164 > + char ** nArgv = g_new0(char*, argcSizeSplit+1); char** argv = g_new0(char*, gstreamerArgumentsSize + 1); > Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp:167 > + for (guint i = 0; i < (argcSizeSplit+1); i++) unsigned i > Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp:173 > + argcSizeSplit++; > + int* argc = (int*)(&argcSizeSplit); > + > + gstInitialized = gst_init_check(argc, &nArgv, &error.outPtr()); int argc = gstreamerArgumentsSize + 1; isGStreamerInitialized = gst_init_check(&argc, &argv, &error.outPtr()); > Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp:175 > + ASSERT_WITH_MESSAGE(gstInitialized, "GStreamer initialization failed: %s", error ? error->message : > + "unknown error occurred"); As we allow long lines, you can make this so. > Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp:176 > + Please remove this empty line. > Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp:184 > + Please remove this empty line. > Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp:187 > + ASSERT_WITH_MESSAGE(gstInitialized, "GStreamer initialization failed: %s", error ? error->message : > + "unknown error occurred"); ditto > Tools/ChangeLog:12 > + I need to use them in this part of the project to returns there's a typo "to returns" -> "to return". > Tools/ChangeLog:15 > + (main): Detect the Gstreamer's input options to pass GStreamer is the proper capitalization. > Tools/ChangeLog:16 > + them to the GStreamer initialization function. ditto. > Tools/MiniBrowser/gtk/main.c:471 > + GString *strbuf = g_string_new(NULL); Please use WTF::StringBuilder and name it stringBuilder (WK coding style: full words as variable names) > Tools/MiniBrowser/gtk/main.c:472 > + gboolean gstParam = false; Please use bool and name the variable as gstreamerParameters. > Tools/MiniBrowser/gtk/main.c:482 > + gchar * arguments = g_string_free(strbuf, FALSE); I suspect you won't need this line with WTF::StringBuilder but you should have used char instead gchar and placing the * next to the type: char* arguments; > Tools/MiniBrowser/gtk/main.c:491 > + g_option_context_add_group(context, gst_init_get_option_group()); Doc says: If you use this function, you should make sure you initialise the GLib threading system as one of the very first things in your program (see the example at the beginning of this section). I guess you should call gst_init here which is going to be fun as it will steal your GStreamer parameter and you'll need to copy them first. 1322772 3 calvaris 2017-06-26 02:26:42 -0700 In general I don't like passing the information from one process to the other by using an environment variable. I think there must some some better way that Carlos García knows better than me (CCed). 1322775 4 calvaris 2017-06-26 02:40:51 -0700 (In reply to Xabier Rodríguez Calvar from comment #2) > > Tools/MiniBrowser/gtk/main.c:471 > > + GString *strbuf = g_string_new(NULL); > > Please use WTF::StringBuilder and name it stringBuilder (WK coding style: > full words as variable names) According to Enrique, this is plain C and we can't use WTF here, so forget this. > > Tools/MiniBrowser/gtk/main.c:482 > > + gchar * arguments = g_string_free(strbuf, FALSE); > > I suspect you won't need this line with WTF::StringBuilder but you should > have used char instead gchar and placing the * next to the type: char* > arguments; In this case, as we are keeing GString, better to access stringBuilder->str in the next line and free the GString with g_string_free(stringBuilder, TRUE). 1322776 5 cgarcia 2017-06-26 02:43:18 -0700 Are the gst command line options only for debugging? Isn't it possible to do the same things with GST en vars? Do we expect that other application will be able to pass command line options to gst? or is this an internal MiniBrowser thing for debugging? 1322777 6 313727 calvaris 2017-06-26 02:43:42 -0700 Comment on attachment 313727 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=313727&action=review > Tools/MiniBrowser/gtk/main.c:483 > + g_setenv("GST_ARGUMENTS", arguments, FALSE); The variable name, should we keep it in case Carlos does not provide a better solution, should be called GSTREAMER_ARGUMENTS 1322783 7 eocanha 2017-06-26 03:10:49 -0700 (In reply to Carlos Garcia Campos from comment #5) > Are the gst command line options only for debugging? Isn't it possible to do > the same things with GST en vars? Do we expect that other application will > be able to pass command line options to gst? or is this an internal > MiniBrowser thing for debugging? The purpose, as Philippe originally commented to me when we thought about the task, is about debugging. All the GStreamer-related tools have a --help-gst command line parameter which explains what gst parameters you can pass. If other applications using WebKit want to honor the parameters, it's up to them. By now, the most useful usage for debugging is to have support just in MiniBrowser. 1322784 8 cgarcia 2017-06-26 03:17:17 -0700 (In reply to Enrique Ocaña from comment #7) > (In reply to Carlos Garcia Campos from comment #5) > > > Are the gst command line options only for debugging? Isn't it possible to do > > the same things with GST en vars? Do we expect that other application will > > be able to pass command line options to gst? or is this an internal > > MiniBrowser thing for debugging? > > The purpose, as Philippe originally commented to me when we thought about > the task, is about debugging. All the GStreamer-related tools have a > --help-gst command line parameter which explains what gst parameters you can > pass. > > If other applications using WebKit want to honor the parameters, it's up to > them. It's not up to them, how are they going to do it if we don't provide a way to do it? That's exactly why I'm asking. > By now, the most useful usage for debugging is to have support just in > MiniBrowser. What cab be done with command line argument that can't be done with GST_DEBUG? 1322787 9 eocanha 2017-06-26 03:39:31 -0700 (In reply to Carlos Garcia Campos from comment #8) > It's not up to them, how are they going to do it if we don't provide a way > to do it? That's exactly why I'm asking. Ask Philippe. He's the one who wrote the FIXME in the first place. > > By now, the most useful usage for debugging is to have support just in > > MiniBrowser. > > What cab be done with command line argument that can't be done with > GST_DEBUG? These are all the options which can't be emulated via GST_DEBUG: --gst-version Print the GStreamer version --gst-fatal-warnings Make all warnings fatal --gst-debug-help Print available debug categories and exit --gst-debug-no-color Disable colored debugging output --gst-debug-color-mode Changes coloring mode of the debug log. Possible modes: off, on, disable, auto, unix --gst-plugin-spew Enable verbose plugin loading diagnostics --gst-plugin-path=PATHS Colon-separated paths containing plugins --gst-plugin-load=PLUGINS Comma-separated list of plugins to preload in addition to the list stored in environment variable GST_PLUGIN_PATH --gst-disable-segtrap Disable trapping of segmentation faults during plugin loading --gst-disable-registry-update Disable updating the registry --gst-disable-registry-fork Disable spawning a helper process while scanning the registry 1322789 10 cgarcia 2017-06-26 03:52:20 -0700 (In reply to Enrique Ocaña from comment #9) > (In reply to Carlos Garcia Campos from comment #8) > > > It's not up to them, how are they going to do it if we don't provide a way > > to do it? That's exactly why I'm asking. > > Ask Philippe. He's the one who wrote the FIXME in the first place. Let's wait for Philippe to do this them, because I can't ask him. 1322792 11 calvaris 2017-06-26 04:21:41 -0700 (In reply to Carlos Garcia Campos from comment #10) > (In reply to Enrique Ocaña from comment #9) > > (In reply to Carlos Garcia Campos from comment #8) > > > > > It's not up to them, how are they going to do it if we don't provide a way > > > to do it? That's exactly why I'm asking. > > > > Ask Philippe. He's the one who wrote the FIXME in the first place. > > Let's wait for Philippe to do this them, because I can't ask him. We don't need to wait for Philippe. I can tell you that this is not absolutely necessary but very good to have. Our problem is that a user can call the UI process and pass these options but we need to put it through to the web process. My question to you was not if this was necessary or not, my question is which is the best way to share the information between the UI and web processes in this case. 1322795 12 cgarcia 2017-06-26 04:29:50 -0700 (In reply to Xabier Rodríguez Calvar from comment #11) > (In reply to Carlos Garcia Campos from comment #10) > > (In reply to Enrique Ocaña from comment #9) > > > (In reply to Carlos Garcia Campos from comment #8) > > > > > > > It's not up to them, how are they going to do it if we don't provide a way > > > > to do it? That's exactly why I'm asking. > > > > > > Ask Philippe. He's the one who wrote the FIXME in the first place. > > > > Let's wait for Philippe to do this them, because I can't ask him. > > We don't need to wait for Philippe. I can tell you that this is not > absolutely necessary but very good to have. Our problem is that a user can > call the UI process and pass these options but we need to put it through to > the web process. > > My question to you was not if this was necessary or not, my question is > which is the best way to share the information between the UI and web > processes in this case. But the best way depends on what this is for, and how it's going to be used, that's why I'm asking. If it's only a debug thing, that we will enable for developer buuolds only, the env var is a good enough solution, and very convenient. If this si somethign we want other applications to use for whatever purpose, then we would need to add public API and then the proper way is to pass them via IPC as web process initialization parameters 1322796 13 cgarcia 2017-06-26 04:39:54 -0700 One possible solution would be to check /proc/self/cmdline in the UI process, collect all gst options and pass them to the web process as initialization parameters (WebProcessCreationParameters). That way we don't need changes in MB/apps, new API nor using env vars. 1322829 14 313727 mcatanzaro 2017-06-26 07:45:50 -0700 Comment on attachment 313727 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=313727&action=review > Tools/MiniBrowser/gtk/main.c:469 > g_setenv("WEBKIT_INJECTED_BUNDLE_PATH", WEBKIT_INJECTED_BUNDLE_PATH, FALSE); I know this was here before, but it needs to move up above the call to gtk_init... >> Tools/MiniBrowser/gtk/main.c:483 >> + g_setenv("GST_ARGUMENTS", arguments, FALSE); > > The variable name, should we keep it in case Carlos does not provide a better solution, should be called GSTREAMER_ARGUMENTS ...but I don't know what you can do about this one. r- from me for using setenv after threads have been created. We just had a crash in GNOME a couple years ago where this brought down the entire desktop session. Last month we had another one in Endless where it randomly crashed our inital-setup process, so users couldn't boot their computers. Here it's just going to crash MB, but still. setenv is not threadsafe unless no threads are calling getenv, and getenv is used all over the place, deep in libraries. It's unavoidable. So setenv has to happen at the very very top of main, before doing things like library initialization. Unfortunately I do not have any alternate recommendation as to how to achieve the behavior you want. :/ 1322831 15 mcatanzaro 2017-06-26 07:49:24 -0700 (In reply to Michael Catanzaro from comment #14) > Unfortunately I do not have any alternate recommendation as to how to > achieve the behavior you want. :/ Ah, I didn't realize I hadn't read the bug before commenting: (In reply to Carlos Garcia Campos from comment #13) > One possible solution would be to check /proc/self/cmdline in the UI > process, collect all gst options and pass them to the web process as > initialization parameters (WebProcessCreationParameters). That way we don't > need changes in MB/apps, new API nor using env vars. Yes, that would be safe. 1322837 16 calvaris 2017-06-26 08:12:39 -0700 (In reply to Carlos Garcia Campos from comment #13) > One possible solution would be to check /proc/self/cmdline in the UI > process, collect all gst options and pass them to the web process as > initialization parameters (WebProcessCreationParameters). That way we don't > need changes in MB/apps, new API nor using env vars. This sounds good. 1325681 17 vchipirras 2017-07-05 11:51:37 -0700 (In reply to Carlos Garcia Campos from comment #13) > One possible solution would be to check /proc/self/cmdline in the UI > process, collect all gst options and pass them to the web process as > initialization parameters (WebProcessCreationParameters). That way we don't > need changes in MB/apps, new API nor using env vars. Ok, I will apply this solution by following these steps: 1- Check /proc/self/cmdline and collect all gst options inside WebProcessCreationParameters. This will be done within the WebProcessPool::createNewWebProcess() method. (UIProcess) 2- After, I will receive the WebProcessCreationParameters within the WebProcess::initializeWebProcess() method. (WebProcess) - BUT!!, the problem is how to make WebProcess::initializeWebProcess() and the MediaPlayerPrivateGStreamer talk to each other, because gst_init() is located in the "GstreamerUtilities.cpp" file, and here it needs to get some information from the WebProcessCreationParameters. This is possible? Does anyone know any possible solution? Thanks! 1344997 18 319788 vchipirras 2017-09-03 10:49:44 -0700 Created attachment 319788 Patch 1345078 19 319788 mcatanzaro 2017-09-03 16:30:05 -0700 Comment on attachment 319788 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=319788&action=review Hi! I have a lot of comments, but don't be discouraged: that's normal. Getting patches into WebKit isn't easy. > Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp:28 > +#include "WebKit/WebProcess/InjectedBundle/API/gtk/DOM/ConvertToUTF8String.h" There's a reason that the WebKit subproject directories are not in the include path: WebCore is a lower layer. You can't use the WebKit subproject here. (In fact, WebCore/platform is supposed to be a lower layer than the rest of WebCore, too, though that's not enforced yet.) It looks like you don't use the functions from this header anymore, since you found WTF::String::utf8, so you can just remove it. > Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp:153 > +#if ENABLE(VIDEO) && USE(GSTREAMER) What if WebKit is built with USE(GSTREAMER) and ENABLE(WEB_AUDIO) but not ENABLE(VIDEO)? Now GStreamer won't be initialized. I think you need to drop the ENABLE(VIDEO) check here. > Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp:163 > + nArgv = g_new0(char*, argcSizeSplit+1); > + > + for (guint i = 0; i < parameters.size(); i++) > + nArgv[i] = g_strdup(parameters[i].utf8().data()); You need to free nArgv with g_strfreev(). > Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp:167 > + argc = (int*) (&size); > + gstInitialized = gst_init_check(argc, &nArgv, &error.outPtr()); You don't need argc here. Just pass &size to gst_init_check(). > Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp:169 > + ASSERT_WITH_MESSAGE(gstInitialized, "GStreamer initialization failed: %s", error ? error->message : > + "unknown error occurred"); This would be nicer on one long line. Anyway, this is a preexisting problem, but it doesn't make sense to use ASSERT_WITH_MESSAGE() here because we really want this assert in release mode, not just debug mode. We could use RELEASE_ASSERT(), but it would be easier to just use gst_init() instead of gst_init_check(). The point of gst_init_check() is to allow the application to gracefully handle a situation where GStreamer is broken, but that's fatal for WebKit: we really just want to crash always. If you make this change, then this function will need to be changed to return void instead of a bool. > Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp:177 > return gstInitialized; > +#endif So now the function has no return value in the !ENABLE(VIDEO) || !USE(GSTREAMER) case. Easiest solution is to change the function to return void like I suggest above, but alternatively you could declare gstInitialized outside the conditional. > Source/WebKit/UIProcess/gtk/WebProcessPoolGtk.cpp:96 > + gboolean isGStreamerParameters = false; Use normal bool. If you need to use gboolean, which is necessary when interacting with GNOME's C APIs, then beware that it's an int rather than one byte, and use GLib's TRUE/FALSE instead of C++'s true/false. But otherwise, it's best to use C++ bool. > Source/WebKit/UIProcess/gtk/WebProcessPoolGtk.cpp:99 > + enum { > + BufferSize = 2048 > + }; Don't create an enum with only one member, just declare a constant: const unsigned BufferSize = 2048; > Source/WebKit/UIProcess/gtk/WebProcessPoolGtk.cpp:105 > + while (fgets(buffer, BufferSize, file)) { I see you've tried to account for the command line being longer than 2048 characters, but it doesn't work: it misses any GStreamer options that might be split over the boundary. So this is going to need a rethink. The standard library fgets() makes this very difficult because it forces you to guess the size of the buffer in advance. I'm going to suggest using g_file_get_contents() instead of fopen(), that way you get the result in one string of the right size allocated by Gio (remember to free it with g_free()) and everything will become much simpler. > Source/WebKit/UIProcess/gtk/WebProcessPoolGtk.cpp:108 > + isGStreamerParameters = g_str_has_prefix(buffer + n, "--gst"); There's actually no reason to filter out parameters here. Just pass everything on to GStreamer. Let GStreamer figure out for itself what to do with the options. > Source/WebKit/UIProcess/gtk/WebProcessPoolGtk.cpp:111 > + char* var = &buffer[n]; > + parameters.gstreamerOptions.append(String::fromUTF8(var)); In WebKit we prefer to avoid unnecessary local variables unless it significantly improves readability. In this case it's better to do it in one line: parameters.gstreamerOptions.append(String::fromUTF8(&buffer[n]). > Source/WebKit/WebProcess/soup/WebProcessSoup.cpp:30 > +#include "WebCore/platform/graphics/gstreamer/GStreamerUtilities.h" We don't use full paths in WebKit, see https://webkit.org/code-style-guidelines/#include-statements. Just #include <GStreamerUtilities.h>. Add WebCore/platform/graphics/gstreamer to the include path in PlatformGTK.cmake and PlatformWPE.cmake if you need to. 1345193 20 319788 calvaris 2017-09-04 02:41:56 -0700 Comment on attachment 319788 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=319788&action=review Besides Michael's comments, I have some of my own. > Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp:154 > + bool gstInitialized = false; We should name this isGStreamerInitialized. > Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp:155 > + char** nArgv; nArgv -> argv. I don't see the need of prepending the n here. > Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp:157 > + guint size = 0; This should be unsigned. > Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp:159 > + guint argcSizeSplit = parameters.size(); This should be size_t > Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp:162 > + for (guint i = 0; i < parameters.size(); i++) guint -> unsigned. >> Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp:163 >> + nArgv[i] = g_strdup(parameters[i].utf8().data()); > > You need to free nArgv with g_strfreev(). Or not duplicating the memory cause gst_init_check can modify the number of options but it won't free the strings. I would maybe g_newa argv (to allocate it in the stack and avoid freeing it later) and just assign parameters[i].utf8().data() to it. 1345219 21 mcatanzaro 2017-09-04 08:44:46 -0700 (In reply to Xabier Rodríguez Calvar from comment #20) > Or not duplicating the memory cause gst_init_check can modify the number of > options but it won't free the strings. Hm, good catch. > I would maybe g_newa argv (to allocate it in the stack and avoid freeing it > later) and just assign parameters[i].utf8().data() to it. I hate to use g_newa for user input, but this is a very tricky problem and it seems like the best option. It's not really an unbounded amount of input because there is a command line length limit. And clearly the API is not usable with memory that is not stack-allocated. 1400299 22 334147 pnormand 2018-02-19 01:57:14 -0800 Created attachment 334147 Patch 1400310 23 cgarcia 2018-02-19 03:01:18 -0800 (In reply to Michael Catanzaro from comment #19) [...] > I see you've tried to account for the command line being longer than 2048 > characters, but it doesn't work: it misses any GStreamer options that might > be split over the boundary. So this is going to need a rethink. The standard > library fgets() makes this very difficult because it forces you to guess the > size of the buffer in advance. I'm going to suggest using > g_file_get_contents() instead of fopen(), that way you get the result in one > string of the right size allocated by Gio (remember to free it with > g_free()) and everything will become much simpler. > > > Source/WebKit/UIProcess/gtk/WebProcessPoolGtk.cpp:108 > > + isGStreamerParameters = g_str_has_prefix(buffer + n, "--gst"); > > There's actually no reason to filter out parameters here. Just pass > everything on to GStreamer. Let GStreamer figure out for itself what to do > with the options. Are you sure gst doesn't fail if it receives options it doesn't recognize? 1400312 24 pnormand 2018-02-19 03:11:50 -0800 MiniBrowser exits in those cases: Cannot parse arguments: Unknown option --gaaast-version2 Cannot parse arguments: Unknown option --gst-version2 1400313 25 cgarcia 2018-02-19 03:14:58 -0800 (In reply to Philippe Normand from comment #24) > MiniBrowser exits in those cases: > > Cannot parse arguments: Unknown option --gaaast-version2 > Cannot parse arguments: Unknown option --gst-version2 I don't mean in case of invalid options, but when passing valid minibrowser options to gst init. 1400314 26 pnormand 2018-02-19 03:22:07 -0800 (In reply to Carlos Garcia Campos from comment #25) > (In reply to Philippe Normand from comment #24) > > MiniBrowser exits in those cases: > > > > Cannot parse arguments: Unknown option --gaaast-version2 > > Cannot parse arguments: Unknown option --gst-version2 > > I don't mean in case of invalid options, but when passing valid minibrowser > options to gst init. That works here 1400333 27 334147 calvaris 2018-02-19 05:18:24 -0800 Comment on attachment 334147 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=334147&action=review I don't know if carlos has any other comments and needs to freely undo my r+, but other that the nits I wrote, LGTM. > Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp:245 > + char** nArgv; nArgv -> newArgv or just argv > Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp:247 > + size_t argcSizeSplit = parameters.size(); You don't need this variable > Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp:248 > + nArgv = g_new0(char*, argcSizeSplit+1); parameters.size() + 1 > Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp:251 > + char** nArgv; > + parameters.insert(0, "WebProcess"); > + size_t argcSizeSplit = parameters.size(); > + nArgv = g_new0(char*, argcSizeSplit+1); > + > + for (unsigned i = 0; i < parameters.size(); i++) > + nArgv[i] = g_strdup(parameters[i].utf8().data()); If I had to write this, I would: 1. make the function take const Vector& 2. g_new0 size + 2 instead of 1 3. g_strdup("WebProcess") to newArgs[0]. 4. begin the loop at 1. 1400743 28 pnormand 2018-02-20 06:16:21 -0800 Committed r228818: <https://trac.webkit.org/changeset/228818> 1400750 29 webkit-bug-importer 2018-02-20 06:28:41 -0800 <rdar://problem/37706341> 1401685 30 334147 cgarcia 2018-02-23 03:58:36 -0800 Comment on attachment 334147 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=334147&action=review I'm sorry to be late here, but yes, I have a few comments. The most important thing is that this patch does nothing and breaks several unit tests. The gst options passed to MiniBrowser only work in the UI process because gst_init_get_option_group() ends up initializing gst, but then we are just passing the program name to the web process. It breaks several unit tests that use the MIMETypeRegistry in the UI process, because we are now assuming that gst is only used in the web process. The MIMETypeRegistry uses it to get the list of supported media types. In the UI process gst is initialized by gst_init_get_option_group() in MiniBrowser, but not in the unit tests or any other application not using gst_init_get_option_group(). > Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp:241 > GUniqueOutPtr<GError> error; Now this is unused if !ENABLE(VIDEO) && !ENABLE(WEB_AUDIO) > Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp:246 > + parameters.insert(0, "WebProcess"); Why WebProcess? that's not even the name in the gtk port. We could use g_get_prgname() > Source/WebCore/platform/graphics/gstreamer/GStreamerUtilities.cpp:253 > + int size = g_strv_length(nArgv); This iterates the array again when we already know the size is parameters.size() > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:-142 > - if (!initializeGStreamer()) > - return false; This is still needed, this is called in the UI process too. > Source/WebKit/UIProcess/gtk/WebProcessPoolGtk.cpp:98 > + GUniqueOutPtr<gchar> contents; > + gsize length; > + if (g_file_get_contents("/proc/self/cmdline", &contents.outPtr(), &length, nullptr)) > + parameters.gstreamerOptions.append(String::fromUTF8(contents.get())); Options in /proc/self/cmdline are separated by null characters. Here we are using a Vector to always pass only one option, the whole contents of /proc/self/cmdline, but String::fromUTF8() will read until the first null character, so we are always passing the program name here. > Source/WebKit/WebProcess/soup/WebProcessSoup.cpp:57 > +#if USE(GSTREAMER) > + WebCore::initializeGStreamer(parameters.gstreamerOptions); > +#endif This is done for both WPE and GTK, but only GTK is sending the gst parameters to the WebProcess. 1401686 31 cgarcia 2018-02-23 04:00:11 -0800 (In reply to Philippe Normand from comment #26) > (In reply to Carlos Garcia Campos from comment #25) > > (In reply to Philippe Normand from comment #24) > > > MiniBrowser exits in those cases: > > > > > > Cannot parse arguments: Unknown option --gaaast-version2 > > > Cannot parse arguments: Unknown option --gst-version2 > > > > I don't mean in case of invalid options, but when passing valid minibrowser > > options to gst init. > > That works here I would still feel more confortable if we only pass the gst options, if gst_init is changed in the future to fail in case of unrecognized options, this will break. And there's no reason to send options via IPC when we know they are going to be ignored. 1401687 32 cgarcia 2018-02-23 04:00:32 -0800 Reopening, I'll submit a new patch. 1401688 33 334515 cgarcia 2018-02-23 04:00:55 -0800 Created attachment 334515 Patch 1401692 34 334515 pnormand 2018-02-23 04:40:20 -0800 Comment on attachment 334515 Patch Thanks. 1401696 35 cgarcia 2018-02-23 04:53:16 -0800 Committed r228946: <https://trac.webkit.org/changeset/228946> 1401864 36 zan 2018-02-24 03:33:12 -0800 Not exactly sure how GTK+ sets up the prgname thing, probably through gtk_main(). But with WPE we have to do it manually: https://trac.webkit.org/changeset/228973/webkit 1401914 37 cgarcia 2018-02-25 03:05:39 -0800 (In reply to Zan Dobersek from comment #36) > Not exactly sure how GTK+ sets up the prgname thing, probably through > gtk_main(). But with WPE we have to do it manually: > https://trac.webkit.org/changeset/228973/webkit Ah, right, that's done in gtk_init. I think it's a good idea that wpe sets it, but we should still fallback to getting the last component of getCurrentExecutablePath() in case we get nullptr. 313727 2017-06-23 10:33:39 -0700 2017-09-03 10:49:40 -0700 Patch bug-173655-20170623193338.patch text/plain 6359 vchipirras U3VidmVyc2lvbiBSZXZpc2lvbjogMjE2NTA4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZDRmMTAwMWY3OGM4OTUw YzJmNDU1M2I2ZjgzODc3MjRmNDE3N2VjYS4uNmI1MTFjZTM0YzJjMDgxNzY2NTZlMGMzM2IzYjg5 MDgxZjVkNmZjMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE3IEBACisyMDE3LTA2LTIyICBWYW5l c3NhIENoaXBpcnLDoXMgTmF2YWzDs24gIDx2Y2hpcGlycmFzQGlnYWxpYS5jb20+CisKKyAgICAg ICAgW0dTdHJlYW1lcl1bTWluaUJyb3dzZXJdIEhvbm9yIEdTdHJlYW1lciBjb21tYW5kIGxpbmUg cGFyYW1ldGVycyBpbiBNaW5pQnJvd3NlcgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MTczNjU1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgVGhlIEZJWE1FIGluIEdTdHJlYW1lclV0aWxpdGllcy5jcHAgYXNr cyB0byBwYXNzIHRoZSBjb21tYW5kIGxpbmUgCisgICAgICAgIHBhcmFtZXRlcnMgdG8gdGhlIEdT dHJlYW1lciBpbml0aWFsaXphdGlvbiBmdW5jdGlvbi4KKworICAgICAgICAqIHBsYXRmb3JtL2dy YXBoaWNzL2dzdHJlYW1lci9HU3RyZWFtZXJVdGlsaXRpZXMuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6aW5pdGlhbGl6ZUdTdHJlYW1lcik6IEhlcmUgZ2V0cyB0aGUgR3N0cmVhbWVyJ3Mgb3B0aW9u IGZyb20KKyAgICAgICAgdGhlIG1haW4oKSBhbmQgY3JlYXRlIHRoZSBjaGFyICJhcmd2IiB0byBJ bml0aWFsaXplIHRoZSBHU3RyZWFtZXIgbGlicmFyeS4KKwogMjAxNy0wNS0wOSAgTmFlbCBPdWVk cmFvZ28gIDxuYWVsLm91ZWRyYW9nb0BjcmYuY2Fub24uZnI+CiAKICAgICAgICAgSW52YWxpZCBN ZWRpYVNvdXJjZSBkdXJhdGlvbiB2YWx1ZSBzaG91bGQgdGhyb3cgVHlwZXJFcnJvciBpbnN0ZWFk IG9mIEludmFsaWRTdGF0ZUVycm9yCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9nc3RyZWFtZXIvR1N0cmVhbWVyVXRpbGl0aWVzLmNwcCBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9HU3RyZWFtZXJVdGlsaXRpZXMuY3BwCmlu ZGV4IDc3MDY3NTI2NmJlZWYxMTY2ZjdjOGQwMzE4MzJmOTFmYWMzMWEyZmMuLmYxYzZhOTk5YWIy OTIzZTVlYmQ1NjQ4NjA0N2I0MjMwZGJkZGVhMzkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9HU3RyZWFtZXJVdGlsaXRpZXMuY3BwCisrKyBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9HU3RyZWFtZXJVdGls aXRpZXMuY3BwCkBAIC0xNTEsMTQgKzE1MSw0NiBAQCBib29sIGluaXRpYWxpemVHU3RyZWFtZXIo KQogICAgICAgICByZXR1cm4gdHJ1ZTsKIAogICAgIEdVbmlxdWVPdXRQdHI8R0Vycm9yPiBlcnJv cjsKLSAgICAvLyBGSVhNRTogV2Ugc2hvdWxkIHByb2JhYmx5IHBhc3MgdGhlIGFyZ3VtZW50cyBm cm9tIHRoZSBjb21tYW5kIGxpbmUuCi0gICAgYm9vbCBnc3RJbml0aWFsaXplZCA9IGdzdF9pbml0 X2NoZWNrKG51bGxwdHIsIG51bGxwdHIsICZlcnJvci5vdXRQdHIoKSk7Ci0gICAgQVNTRVJUX1dJ VEhfTUVTU0FHRShnc3RJbml0aWFsaXplZCwgIkdTdHJlYW1lciBpbml0aWFsaXphdGlvbiBmYWls ZWQ6ICVzIiwgZXJyb3IgPyBlcnJvci0+bWVzc2FnZSA6ICJ1bmtub3duIGVycm9yIG9jY3VycmVk Iik7CisjaWYgRU5BQkxFKFZJREVPKSAmJiBVU0UoR1NUUkVBTUVSKQorCisgICAgY29uc3QgZ2No YXIqIGdzdEFyZ3YgPSBnX2dldGVudigiR1NUX0FSR1VNRU5UUyIpOworICAgIGJvb2wgZ3N0SW5p dGlhbGl6ZWQgPSBmYWxzZTsKKworICAgIGlmIChnc3RBcmd2ICYmIHN0cmxlbihnc3RBcmd2KSA+ IDApIHsKKworICAgICAgICBnY2hhciAqKiBhcmd2U3BsaXQgPSBnX3N0cnNwbGl0KGdzdEFyZ3Ys ICIgIiwgLTEpOworICAgICAgICBndWludCBhcmdjU2l6ZVNwbGl0ID0gZ19zdHJ2X2xlbmd0aChh cmd2U3BsaXQpOworCisgICAgICAgIGNoYXIgKiogbkFyZ3YgPSBnX25ldzAoY2hhciosIGFyZ2NT aXplU3BsaXQrMSk7CisgICAgICAgIG5Bcmd2WzBdID0gZ19zdHJkdXAoIldlYlByb2Nlc3MiKTsK KworICAgICAgICBmb3IgKGd1aW50IGkgPSAwOyBpIDwgKGFyZ2NTaXplU3BsaXQrMSk7IGkrKykK KyAgICAgICAgICAgIG5Bcmd2W2krMV0gPSBhcmd2U3BsaXRbaV07CisKKyAgICAgICAgYXJnY1Np emVTcGxpdCsrOworICAgICAgICBpbnQqIGFyZ2MgPSAoaW50KikoJmFyZ2NTaXplU3BsaXQpOwor CisgICAgICAgIGdzdEluaXRpYWxpemVkID0gZ3N0X2luaXRfY2hlY2soYXJnYywgJm5Bcmd2LCAm ZXJyb3Iub3V0UHRyKCkpOworICAgICAgICBBU1NFUlRfV0lUSF9NRVNTQUdFKGdzdEluaXRpYWxp emVkLCAiR1N0cmVhbWVyIGluaXRpYWxpemF0aW9uIGZhaWxlZDogJXMiLCBlcnJvciA/IGVycm9y LT5tZXNzYWdlIDoKKyAgICAgICAgInVua25vd24gZXJyb3Igb2NjdXJyZWQiKTsKKworI2VuZGlm CisKKyNpZiBFTkFCTEUoVklERU9fVFJBQ0spICYmIFVTRShHU1RSRUFNRVJfTVBFR1RTKQorICAg IGlmIChnc3RJbml0aWFsaXplZCkKKyAgICAgICAgZ3N0X21wZWd0c19pbml0aWFsaXplKCk7Cisj ZW5kaWYKKyAgICB9IGVsc2UgeworCisgICAgZ3N0SW5pdGlhbGl6ZWQgPSBnc3RfaW5pdF9jaGVj ayhudWxscHRyLCBudWxscHRyLCAmZXJyb3Iub3V0UHRyKCkpOworICAgIEFTU0VSVF9XSVRIX01F U1NBR0UoZ3N0SW5pdGlhbGl6ZWQsICJHU3RyZWFtZXIgaW5pdGlhbGl6YXRpb24gZmFpbGVkOiAl cyIsIGVycm9yID8gZXJyb3ItPm1lc3NhZ2UgOgorICAgICJ1bmtub3duIGVycm9yIG9jY3VycmVk Iik7CiAKICNpZiBFTkFCTEUoVklERU9fVFJBQ0spICYmIFVTRShHU1RSRUFNRVJfTVBFR1RTKQog ICAgIGlmIChnc3RJbml0aWFsaXplZCkKICAgICAgICAgZ3N0X21wZWd0c19pbml0aWFsaXplKCk7 CiAjZW5kaWYKKyAgICB9CiAKICAgICByZXR1cm4gZ3N0SW5pdGlhbGl6ZWQ7CiB9CmRpZmYgLS1n aXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggZTg2NjkwN2I5Zjg4 M2EwZWE1M2E1NGJkZmFkNGViZDU3MzQ1MWY3My4uN2VjMjkyN2QxYWUzOGE1MjJiMzUwZWE0ZmY0 ZDc0M2ViMTM0NDI3NSAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0No YW5nZUxvZwpAQCAtMSwzICsxLDIwIEBACisyMDE3LTA2LTIyICBWYW5lc3NhIENoaXBpcnLDoXMg TmF2YWzDs24gIDx2Y2hpcGlycmFzQGlnYWxpYS5jb20+CisKKyAgICAgICAgW0dTdHJlYW1lcl1b TWluaUJyb3dzZXJdIEhvbm9yIEdTdHJlYW1lciBjb21tYW5kIGxpbmUgcGFyYW1ldGVycyBpbiBN aW5pQnJvd3NlcgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MTczNjU1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgVGhlIEZJWE1FIGluIEdTdHJlYW1lclV0aWxpdGllcy5jcHAgYXNrcyB0byBwYXNzIHRoZSBj b21tYW5kIGxpbmUgCisgICAgICAgIHBhcmFtZXRlcnMgdG8gdGhlIEdTdHJlYW1lciBpbml0aWFs aXphdGlvbiBmdW5jdGlvbi4KKworICAgICAgICAqIE1pbmlCcm93c2VyL2d0ay9DTWFrZUxpc3Rz LnR4dDogR3N0cmVhbWVyIGxpYnJhcmllcyBpbmNsdWRlZCBiZWNhdXNlIAorICAgICAgICBJIG5l ZWQgdG8gdXNlIHRoZW0gaW4gdGhpcyBwYXJ0IG9mIHRoZSBwcm9qZWN0IHRvIHJldHVybnMgCisg ICAgICAgIGEgR09wdGlvbkdyb3VwIHdpdGggR1N0cmVhbWVyJ3MgYXJndW1lbnQgc3BlY2lmaWNh dGlvbnMuCisgICAgICAgICogTWluaUJyb3dzZXIvZ3RrL21haW4uYzoKKyAgICAgICAgKG1haW4p OiBEZXRlY3QgdGhlIEdzdHJlYW1lcidzIGlucHV0IG9wdGlvbnMgdG8gcGFzcyAKKyAgICAgICAg dGhlbSB0byB0aGUgR1N0cmVhbWVyIGluaXRpYWxpemF0aW9uIGZ1bmN0aW9uLgorCiAyMDE3LTA1 LTA5ICBKb25hdGhhbiBCZWRhcmQgIDxqYmVkYXJkQGFwcGxlLmNvbT4KIAogICAgICAgICBSRUdS RVNTSU9OOiBJbWFnZURpZmYgbm90IGJ1aWxkaW5nIHdpdGggbWFrZQpkaWZmIC0tZ2l0IGEvVG9v bHMvTWluaUJyb3dzZXIvZ3RrL0NNYWtlTGlzdHMudHh0IGIvVG9vbHMvTWluaUJyb3dzZXIvZ3Rr L0NNYWtlTGlzdHMudHh0CmluZGV4IGUzOGJjNmRjMTE5ZjczZTlmZWVmNmI2MzZkYzM3YTY4MGZj ZDMwZDcuLmVlM2E0ZjM1NmI5NWU0OTkyMjhiNjBjYjExNDg3NTFiMjk0Zjk2MjQgMTAwNjQ0Ci0t LSBhL1Rvb2xzL01pbmlCcm93c2VyL2d0ay9DTWFrZUxpc3RzLnR4dAorKysgYi9Ub29scy9NaW5p QnJvd3Nlci9ndGsvQ01ha2VMaXN0cy50eHQKQEAgLTMxLDYgKzMxLDcgQEAgc2V0KE1pbmlCcm93 c2VyX0lOQ0xVREVfRElSRUNUT1JJRVMKIHNldChNaW5pQnJvd3Nlcl9TWVNURU1fSU5DTFVERV9E SVJFQ1RPUklFUwogICAgICR7R1RLM19JTkNMVURFX0RJUlN9CiAgICAgJHtHTElCX0lOQ0xVREVf RElSU30KKyAgICAke0dTVFJFQU1FUl9JTkNMVURFX0RJUlN9CiAgICAgJHtMSUJTT1VQX0lOQ0xV REVfRElSU30KICkKIApAQCAtMzksNiArNDAsNyBAQCBzZXQoTWluaUJyb3dzZXJfTElCUkFSSUVT CiAgICAgV2ViS2l0MgogICAgICR7R1RLM19MSUJSQVJJRVN9CiAgICAgJHtHTElCX0xJQlJBUklF U30KKyAgICAke0dTVFJFQU1FUl9MSUJSQVJJRVN9CiAgICAgJHtMSUJTT1VQX0xJQlJBUklFU30K ICkKIApkaWZmIC0tZ2l0IGEvVG9vbHMvTWluaUJyb3dzZXIvZ3RrL21haW4uYyBiL1Rvb2xzL01p bmlCcm93c2VyL2d0ay9tYWluLmMKaW5kZXggNTcwNTU0MDU2YTI2N2ZmYzc0ODcyYWI5ODAyMmYy NmQxMDZkNzIwMy4uMjNhYzk4YjMzYmQyZjA3MDhiYWI1YTFiMWIyMDA2YmZmODU3M2ExOCAxMDA2 NDQKLS0tIGEvVG9vbHMvTWluaUJyb3dzZXIvZ3RrL21haW4uYworKysgYi9Ub29scy9NaW5pQnJv d3Nlci9ndGsvbWFpbi5jCkBAIC0zMCw2ICszMCw3IEBACiAjaW5jbHVkZSAiQnJvd3NlcldpbmRv dy5oIgogI2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL0phdmFTY3JpcHQuaD4KICNpbmNsdWRlIDxl cnJuby5oPgorI2luY2x1ZGUgPGdzdC9nc3QuaD4KICNpbmNsdWRlIDxndGsvZ3RrLmg+CiAjaW5j bHVkZSA8c3RyaW5nLmg+CiAjaW5jbHVkZSA8d2Via2l0Mi93ZWJraXQyLmg+CkBAIC00NjYsMTEg KzQ2NywyOCBAQCBpbnQgbWFpbihpbnQgYXJnYywgY2hhciAqYXJndltdKQogICAgIGd0a19pbml0 KCZhcmdjLCAmYXJndik7CiAjaWYgRU5BQkxFX0RFVkVMT1BFUl9NT0RFCiAgICAgZ19zZXRlbnYo IldFQktJVF9JTkpFQ1RFRF9CVU5ETEVfUEFUSCIsIFdFQktJVF9JTkpFQ1RFRF9CVU5ETEVfUEFU SCwgRkFMU0UpOworCisgICAgR1N0cmluZyAqc3RyYnVmID0gZ19zdHJpbmdfbmV3KE5VTEwpOwor ICAgIGdib29sZWFuIGdzdFBhcmFtID0gZmFsc2U7CisKKyAgICBmb3IgKGludCBjID0gMDsgYyA8 IGFyZ2M7IGMrKykgeworICAgICAgICBnc3RQYXJhbSA9IGdfc3RyX2hhc19wcmVmaXgoYXJndltj XSwgIi0tZ3N0Iik7CisgICAgICAgIGlmIChnc3RQYXJhbSA9PSBUUlVFKSB7CisgICAgICAgICAg ICBnX3N0cmluZ19hcHBlbmQoc3RyYnVmLCBhcmd2W2NdKTsKKyAgICAgICAgICAgIGdfc3RyaW5n X2FwcGVuZChzdHJidWYsICIgIik7CisgICAgICAgIH0KKyAgICB9CisKKyAgICAgICAgZ2NoYXIg KiBhcmd1bWVudHMgPSBnX3N0cmluZ19mcmVlKHN0cmJ1ZiwgRkFMU0UpOworICAgICAgICBnX3Nl dGVudigiR1NUX0FSR1VNRU5UUyIsIGFyZ3VtZW50cywgRkFMU0UpOworCisgICAgICAgIGdfZnJl ZShhcmd1bWVudHMpOwogI2VuZGlmCiAKICAgICBHT3B0aW9uQ29udGV4dCAqY29udGV4dCA9IGdf b3B0aW9uX2NvbnRleHRfbmV3KE5VTEwpOwogICAgIGdfb3B0aW9uX2NvbnRleHRfYWRkX21haW5f ZW50cmllcyhjb250ZXh0LCBjb21tYW5kTGluZU9wdGlvbnMsIDApOwogICAgIGdfb3B0aW9uX2Nv bnRleHRfYWRkX2dyb3VwKGNvbnRleHQsIGd0a19nZXRfb3B0aW9uX2dyb3VwKFRSVUUpKTsKKyAg ICBnX29wdGlvbl9jb250ZXh0X2FkZF9ncm91cChjb250ZXh0LCBnc3RfaW5pdF9nZXRfb3B0aW9u X2dyb3VwKCkpOwogCiAgICAgV2ViS2l0U2V0dGluZ3MgKndlYmtpdFNldHRpbmdzID0gd2Via2l0 X3NldHRpbmdzX25ldygpOwogICAgIHdlYmtpdF9zZXR0aW5nc19zZXRfZW5hYmxlX2RldmVsb3Bl cl9leHRyYXMod2Via2l0U2V0dGluZ3MsIFRSVUUpOwo= 319788 2017-09-03 10:49:44 -0700 2018-02-19 01:57:09 -0800 Patch bug-173655-20170903194943.patch text/plain 15238 vchipirras U3VidmVyc2lvbiBSZXZpc2lvbjogMjIxNTQ4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggOTEyZTNhMjAzNGVjZWYw MTA4ZTJiMGE5MDM1YjQ2ZjM3ZWNjY2EwYy4uYjJjOTdjZDJmODY1ZDJhODNlMjgyODVmNzU5MGVi OWVmNTI4YmVhNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI4IEBACisyMDE3LTA5LTAzICBWYW5l c3NhIENoaXBpcnLDoXMgTmF2YWzDs24gIDx2Y2hpcGlycmFzQGlnYWxpYS5jb20+CisKKyAgICAg ICAgW0dTdHJlYW1lcl1bTWluaUJyb3dzZXJdIEhvbm9yIEdTdHJlYW1lciBjb21tYW5kIGxpbmUg cGFyYW1ldGVycyBpbiBNaW5pQnJvd3NlcgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MTczNjU1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgVGhlIEZJWE1FIGluIEdTdHJlYW1lclV0aWxpdGllcy5jcHAgYXNr cyB0byBwYXNzIHRoZSBjb21tYW5kIGxpbmUKKyAgICAgICAgcGFyYW1ldGVycyB0byB0aGUgR1N0 cmVhbWVyIGluaXRpYWxpemF0aW9uIGZ1bmN0aW9uLgorCisgICAgICAgICogTW9kdWxlcy93ZWJh dWRpby9BdWRpb0NvbnRleHQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9Db250ZXh0Ojpj b25zdHJ1Y3RDb21tb24pOiBSZW1vdmVzIHRoZSBjYWxsIHRvIHRoZSBtZXRob2QKKyAgICAgICAg dGhhdCBHU3RyZWFtZXIgaW5pdGlhbGl6ZXMuIEl0IGlzIG5vIGxvbmdlciBuZWNlc3NhcnkuCisg ICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL01lZGlhUGxheWVyUHJpdmF0ZUdT dHJlYW1lckJhc2UuY3BwOgorICAgICAgICAoV2ViQ29yZTo6TWVkaWFQbGF5ZXJQcml2YXRlR1N0 cmVhbWVyQmFzZTo6aW5pdGlhbGl6ZUdTdHJlYW1lckFuZFJlZ2lzdGVyV2ViS2l0RWxlbWVudHMp OiBEaXR0bworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9NZWRpYVBsYXll clByaXZhdGVHU3RyZWFtZXJPd3IuY3BwOgorICAgICAgICAoV2ViQ29yZTo6TWVkaWFQbGF5ZXJQ cml2YXRlR1N0cmVhbWVyT3dyOjpsb2FkKTogRGl0dG8KKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlh UGxheWVyUHJpdmF0ZUdTdHJlYW1lck93cjo6aW5pdGlhbGl6ZUdTdHJlYW1lckFuZEdTdHJlYW1l ckRlYnVnZ2luZyk6IERpdHRvCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVy L21zZS9NZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJNU0UuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6aW5pdGlhbGl6ZUdTdHJlYW1lckFuZFJlZ2lzdGVyV2ViS2l0TVNFRWxlbWVudCk6IERpdHRv CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL0dTdHJlYW1lclV0aWxpdGll cy5jcHA6CisgICAgICAgIChXZWJDb3JlOjppbml0aWFsaXplR1N0cmVhbWVyKTogUmVjZWl2ZSB0 aGUgR1N0cmVhbWVyIG9wdGlvbnMgYW5kIGluaXRpYWxpemUgR1N0cmVhbWVyLgorICAgICAgICAq IHBsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9HU3RyZWFtZXJVdGlsaXRpZXMuaDogQWRkIHZl Y3RvciB3aGljaCBjb250YWlucworICAgICAgICBHU3RyZWFtZXIgb3B0aW9ucyBhcyB0aGUgaW5w dXQgcGFyYW1ldGVyIG9mIHRoZSBpbml0aWFsaXplR1N0cmVhbWVyKCkgbWV0aG9kLgorCiAyMDE3 LTA5LTAzICBTYW0gV2VpbmlnICA8c2FtQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmVtb3ZlIENh bnZhc1Byb3h5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZyBiL1NvdXJjZS9X ZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDQ4MjdiYjNlOTdjMzE1ZjIwYmFkMDJhZTdjMzBkYWM0YTBm OWZiYjguLjViMWEwN2NlZGE4N2NhNjVhMjI4YmY4MmExM2QxZTM4YTBhOTY0ZDAgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9n CkBAIC0xLDMgKzEsMjQgQEAKKzIwMTctMDktMDMgIFZhbmVzc2EgQ2hpcGlycsOhcyBOYXZhbMOz biAgPHZjaGlwaXJyYXNAaWdhbGlhLmNvbT4KKworICAgICAgICBbR1N0cmVhbWVyXVtNaW5pQnJv d3Nlcl0gSG9ub3IgR1N0cmVhbWVyIGNvbW1hbmQgbGluZSBwYXJhbWV0ZXJzIGluIE1pbmlCcm93 c2VyCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNzM2 NTUKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBUaGUg RklYTUUgaW4gR1N0cmVhbWVyVXRpbGl0aWVzLmNwcCBhc2tzIHRvIHBhc3MgdGhlIGNvbW1hbmQg bGluZQorICAgICAgICBwYXJhbWV0ZXJzIHRvIHRoZSBHU3RyZWFtZXIgaW5pdGlhbGl6YXRpb24g ZnVuY3Rpb24uCisKKyAgICAgICAgKiBTaGFyZWQvV2ViUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVy cy5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYlByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnM6OmVu Y29kZSBjb25zdCk6CisgICAgICAgIChXZWJLaXQ6OldlYlByb2Nlc3NDcmVhdGlvblBhcmFtZXRl cnM6OmRlY29kZSk6CisgICAgICAgICogU2hhcmVkL1dlYlByb2Nlc3NDcmVhdGlvblBhcmFtZXRl cnMuaDogRGVmaW5lIHRoZSB2ZWN0b3Igd2hpY2ggY29udGFpbnMgdGhlIEdTdHJlYW1lciBvcHRp b25zLgorICAgICAgICAqIFVJUHJvY2Vzcy9ndGsvV2ViUHJvY2Vzc1Bvb2xHdGsuY3BwOgorICAg ICAgICAoV2ViS2l0OjpXZWJQcm9jZXNzUG9vbDo6cGxhdGZvcm1Jbml0aWFsaXplV2ViUHJvY2Vz cyk6IFJlYWQgZnJvbSBjbWRsaW5lIGZpbGUKKyAgICAgICAgdGhlIEdTdHJlYW1lciBvcHRpb25z IHdyaXR0ZW4gYnkgY29uc29sZS4KKyAgICAgICAgKiBXZWJQcm9jZXNzL3NvdXAvV2ViUHJvY2Vz c1NvdXAuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJQcm9jZXNzOjpwbGF0Zm9ybUluaXRpYWxp emVXZWJQcm9jZXNzKTogQ2FsbCBpbml0aWFsaXplR1N0cmVhbWVyKCkgbWV0aG9kIHBhc3NpbmcK KyAgICAgICAgdGhlIHZlY3RvciB3aGljaCBjb250YWlucyB0aGUgb3B0aW9ucy4KKwogMjAxNy0w OS0wMyAgU2FtIFdlaW5pZyAgPHNhbUB3ZWJraXQub3JnPgogCiAgICAgICAgIFJlbW92ZSBDYW52 YXNQcm94eQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRp b0NvbnRleHQuY3BwIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb0NvbnRl eHQuY3BwCmluZGV4IGQ5NTA0N2M5MDMwNTFjMGJjM2Q1ZTYzOGIyN2I0NTg1NDI0YjA1MzIuLmE0 MjFkODc0ZjUyNzYxYjNmMzRhNjE1MjA5YWU0Y2U2NGNmYjU2ZDIgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9Db250ZXh0LmNwcAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvQ29udGV4dC5jcHAKQEAgLTE2NywxMCArMTY3 LDYgQEAgdm9pZCBBdWRpb0NvbnRleHQ6OmNvbnN0cnVjdENvbW1vbigpCiAgICAgLy8gTGV0cyBt YXJrIGl0IGFzIEFjdGl2ZURPTU9iamVjdCB3aXRoIHBlbmRpbmcgYWN0aXZpdHkgYW5kIHVubWFy ayBpdCBpbiBjbGVhciBtZXRob2QuCiAgICAgc2V0UGVuZGluZ0FjdGl2aXR5KHRoaXMpOwogCi0j aWYgVVNFKEdTVFJFQU1FUikKLSAgICBpbml0aWFsaXplR1N0cmVhbWVyKCk7Ci0jZW5kaWYKLQog ICAgIEZGVEZyYW1lOjppbml0aWFsaXplKCk7CiAgICAgCiAgICAgbV9saXN0ZW5lciA9IEF1ZGlv TGlzdGVuZXI6OmNyZWF0ZSgpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvZ3N0cmVhbWVyL0dTdHJlYW1lclV0aWxpdGllcy5jcHAgYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvR1N0cmVhbWVyVXRpbGl0aWVzLmNwcAppbmRl eCAxODU0ZTM2NTJlNjUyOTA3ZjliZjE2MTgwMjc0ZGJiNzljNjc4ZTBmLi5jMmY2OWYzNWM0NDdl MWEwZDNjNzhkNDEzNGU1YTA2NmJmZTFiOTVmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvR1N0cmVhbWVyVXRpbGl0aWVzLmNwcAorKysgYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvR1N0cmVhbWVyVXRpbGl0 aWVzLmNwcApAQCAtMjUsNiArMjUsNyBAQAogCiAjaW5jbHVkZSAiR1JlZlB0ckdTdHJlYW1lci5o IgogI2luY2x1ZGUgIkludFNpemUuaCIKKyNpbmNsdWRlICJXZWJLaXQvV2ViUHJvY2Vzcy9Jbmpl Y3RlZEJ1bmRsZS9BUEkvZ3RrL0RPTS9Db252ZXJ0VG9VVEY4U3RyaW5nLmgiCiAKICNpbmNsdWRl IDxnc3QvYXVkaW8vYXVkaW8taW5mby5oPgogI2luY2x1ZGUgPGdzdC9nc3QuaD4KQEAgLTE0NSwx NSArMTQ2LDI3IEBAIHZvaWQgdW5tYXBHc3RCdWZmZXIoR3N0QnVmZmVyKiBidWZmZXIpCiAgICAg ZmFzdEZyZWUobWFwSW5mbyk7CiB9CiAKLWJvb2wgaW5pdGlhbGl6ZUdTdHJlYW1lcigpCitib29s IGluaXRpYWxpemVHU3RyZWFtZXIoVmVjdG9yPFN0cmluZz4mIHBhcmFtZXRlcnMpCiB7Ci0gICAg aWYgKGdzdF9pc19pbml0aWFsaXplZCgpKQotICAgICAgICByZXR1cm4gdHJ1ZTsKLQogICAgIEdV bmlxdWVPdXRQdHI8R0Vycm9yPiBlcnJvcjsKLSAgICAvLyBGSVhNRTogV2Ugc2hvdWxkIHByb2Jh Ymx5IHBhc3MgdGhlIGFyZ3VtZW50cyBmcm9tIHRoZSBjb21tYW5kIGxpbmUuCi0gICAgYm9vbCBn c3RJbml0aWFsaXplZCA9IGdzdF9pbml0X2NoZWNrKG51bGxwdHIsIG51bGxwdHIsICZlcnJvci5v dXRQdHIoKSk7Ci0gICAgQVNTRVJUX1dJVEhfTUVTU0FHRShnc3RJbml0aWFsaXplZCwgIkdTdHJl YW1lciBpbml0aWFsaXphdGlvbiBmYWlsZWQ6ICVzIiwgZXJyb3IgPyBlcnJvci0+bWVzc2FnZSA6 ICJ1bmtub3duIGVycm9yIG9jY3VycmVkIik7CisKKyNpZiBFTkFCTEUoVklERU8pICYmIFVTRShH U1RSRUFNRVIpCisgICAgYm9vbCBnc3RJbml0aWFsaXplZCA9IGZhbHNlOworICAgIGNoYXIqKiBu QXJndjsKKyAgICBpbnQqIGFyZ2M7CisgICAgZ3VpbnQgc2l6ZSA9IDA7CisgICAgcGFyYW1ldGVy cy5pbnNlcnQoMCwgIldlYlByb2Nlc3MiKTsKKyAgICBndWludCBhcmdjU2l6ZVNwbGl0ID0gcGFy YW1ldGVycy5zaXplKCk7CisgICAgbkFyZ3YgPSBnX25ldzAoY2hhciosIGFyZ2NTaXplU3BsaXQr MSk7CisKKyAgICBmb3IgKGd1aW50IGkgPSAwOyBpIDwgcGFyYW1ldGVycy5zaXplKCk7IGkrKykK KyAgICAgICAgbkFyZ3ZbaV0gPSBnX3N0cmR1cChwYXJhbWV0ZXJzW2ldLnV0ZjgoKS5kYXRhKCkp OworCisgICAgc2l6ZSA9IGdfc3Rydl9sZW5ndGgobkFyZ3YpOworICAgIGFyZ2MgPSAoaW50Kikg KCZzaXplKTsKKyAgICBnc3RJbml0aWFsaXplZCA9IGdzdF9pbml0X2NoZWNrKGFyZ2MsICZuQXJn diwgJmVycm9yLm91dFB0cigpKTsKKyAgICBBU1NFUlRfV0lUSF9NRVNTQUdFKGdzdEluaXRpYWxp emVkLCAiR1N0cmVhbWVyIGluaXRpYWxpemF0aW9uIGZhaWxlZDogJXMiLCBlcnJvciA/IGVycm9y LT5tZXNzYWdlIDoKKyAgICAgICAgInVua25vd24gZXJyb3Igb2NjdXJyZWQiKTsKIAogI2lmIEVO QUJMRShWSURFT19UUkFDSykgJiYgVVNFKEdTVFJFQU1FUl9NUEVHVFMpCiAgICAgaWYgKGdzdElu aXRpYWxpemVkKQpAQCAtMTYxLDYgKzE3NCw3IEBAIGJvb2wgaW5pdGlhbGl6ZUdTdHJlYW1lcigp CiAjZW5kaWYKIAogICAgIHJldHVybiBnc3RJbml0aWFsaXplZDsKKyNlbmRpZgogfQogCiB1bnNp Z25lZCBnZXRHc3RQbGF5RmxhZyhjb25zdCBjaGFyKiBuaWNrKQpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL0dTdHJlYW1lclV0aWxpdGllcy5o IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL0dTdHJlYW1lclV0 aWxpdGllcy5oCmluZGV4IDkzM2JkMWRhYmVkZWRjOTIxYmQ0ODg3NzY2ODUxMWFjM2UxNTk1MjYu LmQxM2RmYTQ5ZWRlYjAxMzNiNjk5MzU2YTJkMWM5NjBmYjFkZWQ2OWIgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9HU3RyZWFtZXJVdGlsaXRp ZXMuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvR1N0 cmVhbWVyVXRpbGl0aWVzLmgKQEAgLTIzLDYgKzIzLDggQEAKICNpbmNsdWRlIDxnc3QvZ3N0Lmg+ CiAjaW5jbHVkZSA8Z3N0L3ZpZGVvL3ZpZGVvLWZvcm1hdC5oPgogI2luY2x1ZGUgPGdzdC92aWRl by92aWRlby1pbmZvLmg+CisjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgorI2luY2x1ZGUgPHd0Zi90 ZXh0L1dURlN0cmluZy5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKQEAgLTU5LDcgKzYxLDcg QEAgR3N0QnVmZmVyKiBjcmVhdGVHc3RCdWZmZXJGb3JEYXRhKGNvbnN0IGNoYXIqIGRhdGEsIGlu dCBsZW5ndGgpOwogY2hhciogZ2V0R3N0QnVmZmVyRGF0YVBvaW50ZXIoR3N0QnVmZmVyKik7CiB2 b2lkIG1hcEdzdEJ1ZmZlcihHc3RCdWZmZXIqLCB1aW50MzJfdCk7CiB2b2lkIHVubWFwR3N0QnVm ZmVyKEdzdEJ1ZmZlciopOwotYm9vbCBpbml0aWFsaXplR1N0cmVhbWVyKCk7Citib29sIGluaXRp YWxpemVHU3RyZWFtZXIoVmVjdG9yPFN0cmluZz4mIHBhcmFtZXRlcnMpOwogdW5zaWduZWQgZ2V0 R3N0UGxheUZsYWcoY29uc3QgY2hhciogbmljayk7CiBHc3RDbG9ja1RpbWUgdG9Hc3RDbG9ja1Rp bWUoZmxvYXQgdGltZSk7CiBib29sIGdzdFJlZ2lzdHJ5SGFzRWxlbWVudEZvck1lZGlhVHlwZShH TGlzdCogZWxlbWVudEZhY3RvcmllcywgY29uc3QgY2hhciogY2Fwc1N0cmluZyk7CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5 ZXJQcml2YXRlR1N0cmVhbWVyQmFzZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZS5jcHAKaW5kZXgg NzIxMjE5YmE2NWIyOThlNDgxYjZkZDk1NGFlZjExMmMyMGRlZTI0OC4uMThkMmEyMjU3MDUyMWVk MWU1NDg5NDJkMDNlOTY2OGQ3ODJkODFmMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL01lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2Uu Y3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9NZWRp YVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlLmNwcApAQCAtMTM5LDkgKzEzOSw2IEBAIHZvaWQg cmVnaXN0ZXJXZWJLaXRHU3RyZWFtZXJFbGVtZW50cygpCiAKIGJvb2wgTWVkaWFQbGF5ZXJQcml2 YXRlR1N0cmVhbWVyQmFzZTo6aW5pdGlhbGl6ZUdTdHJlYW1lckFuZFJlZ2lzdGVyV2ViS2l0RWxl bWVudHMoKQogewotICAgIGlmICghaW5pdGlhbGl6ZUdTdHJlYW1lcigpKQotICAgICAgICByZXR1 cm4gZmFsc2U7Ci0KICAgICByZWdpc3RlcldlYktpdEdTdHJlYW1lckVsZW1lbnRzKCk7CiAKICAg ICBHUmVmUHRyPEdzdEVsZW1lbnRGYWN0b3J5PiBzcmNGYWN0b3J5ID0gYWRvcHRHUmVmKGdzdF9l bGVtZW50X2ZhY3RvcnlfZmluZCgid2Via2l0d2Vic3JjIikpOwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL01lZGlhUGxheWVyUHJpdmF0ZUdT dHJlYW1lck93ci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFt ZXIvTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyT3dyLmNwcAppbmRleCBlNTFmZjZjZjc3ZmUz YzE3NjhiYTkwNzEwODZjOTZlMmVkYzlhYTk1Li44YTRjMjI5MTUxY2RjNWUyN2NhZjBkNDhjNTAw ODFlOWE3NDJjYmEzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9nc3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyT3dyLmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRl R1N0cmVhbWVyT3dyLmNwcApAQCAtMTY1LDkgKzE2NSw2IEBAIHZvaWQgTWVkaWFQbGF5ZXJQcml2 YXRlR1N0cmVhbWVyT3dyOjpsb2FkKGNvbnN0IFN0cmluZyYsIE1lZGlhU291cmNlUHJpdmF0ZUNs aWVuCiAKIHZvaWQgTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyT3dyOjpsb2FkKE1lZGlhU3Ry ZWFtUHJpdmF0ZSYgc3RyZWFtUHJpdmF0ZSkKIHsKLSAgICBpZiAoIWluaXRpYWxpemVHU3RyZWFt ZXIoKSkKLSAgICAgICAgcmV0dXJuOwotCiAgICAgbV9zdHJlYW1Qcml2YXRlID0gJnN0cmVhbVBy aXZhdGU7CiAgICAgaWYgKCFtX3N0cmVhbVByaXZhdGUtPmFjdGl2ZSgpKSB7CiAgICAgICAgIGxv YWRpbmdGYWlsZWQoTWVkaWFQbGF5ZXI6Ok5ldHdvcmtFcnJvcik7CkBAIC0zMDYsOSArMzAzLDYg QEAgTWVkaWFQbGF5ZXI6OlN1cHBvcnRzVHlwZSBNZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJP d3I6OnN1cHBvcnRzVHlwZShjb25zdCBNZWQKIAogYm9vbCBNZWRpYVBsYXllclByaXZhdGVHU3Ry ZWFtZXJPd3I6OmluaXRpYWxpemVHU3RyZWFtZXJBbmRHU3RyZWFtZXJEZWJ1Z2dpbmcoKQogewot ICAgIGlmICghaW5pdGlhbGl6ZUdTdHJlYW1lcigpKQotICAgICAgICByZXR1cm4gZmFsc2U7Ci0K ICAgICBzdGF0aWMgc3RkOjpvbmNlX2ZsYWcgZGVidWdSZWdpc3RlcmVkRmxhZzsKICAgICBzdGQ6 OmNhbGxfb25jZShkZWJ1Z1JlZ2lzdGVyZWRGbGFnLCBbXSB7CiAgICAgICAgIEdTVF9ERUJVR19D QVRFR09SWV9JTklUKHdlYmtpdF9vcGVud2VicnRjX2RlYnVnLCAid2Via2l0b3dycGxheWVyIiwg MCwgIldlYktpdCBPcGVuV2ViUlRDIHBsYXllciIpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL21zZS9NZWRpYVBsYXllclByaXZhdGVHU3Ry ZWFtZXJNU0UuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVy L21zZS9NZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJNU0UuY3BwCmluZGV4IDAyNDY3MDBkM2Y5 OWU2NDBmNDJiNDBjNzQ3ZTJkYjhjNjM5YzRmYTkuLmE4N2NjOGJkNTIyNDNkNWQyMWFhOGU0MDVk OGNiZThhMDhlNzg4ZjEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2dzdHJlYW1lci9tc2UvTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyTVNFLmNwcAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvbXNlL01lZGlhUGxh eWVyUHJpdmF0ZUdTdHJlYW1lck1TRS5jcHAKQEAgLTgwLDkgKzgwLDYgQEAgdm9pZCBNZWRpYVBs YXllclByaXZhdGVHU3RyZWFtZXJNU0U6OnJlZ2lzdGVyTWVkaWFFbmdpbmUoTWVkaWFFbmdpbmVS ZWdpc3RyYXIgcmUKIAogYm9vbCBpbml0aWFsaXplR1N0cmVhbWVyQW5kUmVnaXN0ZXJXZWJLaXRN U0VFbGVtZW50KCkKIHsKLSAgICBpZiAoVU5MSUtFTFkoIWluaXRpYWxpemVHU3RyZWFtZXIoKSkp Ci0gICAgICAgIHJldHVybiBmYWxzZTsKLQogICAgIHJlZ2lzdGVyV2ViS2l0R1N0cmVhbWVyRWxl bWVudHMoKTsKIAogICAgIEdTVF9ERUJVR19DQVRFR09SWV9JTklUKHdlYmtpdF9tc2VfZGVidWcs ICJ3ZWJraXRtc2UiLCAwLCAiV2ViS2l0IE1TRSBtZWRpYSBwbGF5ZXIiKTsKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQvU2hhcmVkL1dlYlByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuY3BwIGIv U291cmNlL1dlYktpdC9TaGFyZWQvV2ViUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5jcHAKaW5k ZXggYWViN2MxMTEyNjE1MDNmNGExYjgwNjY0OWM5MTVkMGJjNGUzNmZmMy4uMDQxNDQyMDU1Njg4 OWQ4Mjk4NmIyMWY1YTNmYjJkYzhhMjEzNWUwYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9T aGFyZWQvV2ViUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5jcHAKKysrIGIvU291cmNlL1dlYktp dC9TaGFyZWQvV2ViUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5jcHAKQEAgLTkyLDYgKzkyLDkg QEAgdm9pZCBXZWJQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzOjplbmNvZGUoSVBDOjpFbmNvZGVy JiBlbmNvZGVyKSBjb25zdAogICAgIGVuY29kZXIgPDwgZm9udFdoaXRlbGlzdDsKICAgICBlbmNv ZGVyIDw8IHRlcm1pbmF0aW9uVGltZW91dDsKICAgICBlbmNvZGVyIDw8IGxhbmd1YWdlczsKKyNp ZiBVU0UoR1NUUkVBTUVSKQorICAgIGVuY29kZXIgPDwgZ3N0cmVhbWVyT3B0aW9uczsKKyNlbmRp ZgogICAgIGVuY29kZXIgPDwgdGV4dENoZWNrZXJTdGF0ZTsKICAgICBlbmNvZGVyIDw8IGZ1bGxL ZXlib2FyZEFjY2Vzc0VuYWJsZWQ7CiAgICAgZW5jb2RlciA8PCBkZWZhdWx0UmVxdWVzdFRpbWVv dXRJbnRlcnZhbDsKQEAgLTIzOCw2ICsyNDEsMTAgQEAgYm9vbCBXZWJQcm9jZXNzQ3JlYXRpb25Q YXJhbWV0ZXJzOjpkZWNvZGUoSVBDOjpEZWNvZGVyJiBkZWNvZGVyLCBXZWJQcm9jZXNzQ3JlYXQK ICAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgIGlmICghZGVjb2Rlci5kZWNvZGUocGFyYW1ldGVy cy5sYW5ndWFnZXMpKQogICAgICAgICByZXR1cm4gZmFsc2U7CisjaWYgVVNFKEdTVFJFQU1FUikK KyAgICBpZiAoIWRlY29kZXIuZGVjb2RlKHBhcmFtZXRlcnMuZ3N0cmVhbWVyT3B0aW9ucykpCisg ICAgICAgIHJldHVybiBmYWxzZTsKKyNlbmRpZgogICAgIGlmICghZGVjb2Rlci5kZWNvZGUocGFy YW1ldGVycy50ZXh0Q2hlY2tlclN0YXRlKSkKICAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgIGlm ICghZGVjb2Rlci5kZWNvZGUocGFyYW1ldGVycy5mdWxsS2V5Ym9hcmRBY2Nlc3NFbmFibGVkKSkK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvU2hhcmVkL1dlYlByb2Nlc3NDcmVhdGlvblBhcmFt ZXRlcnMuaCBiL1NvdXJjZS9XZWJLaXQvU2hhcmVkL1dlYlByb2Nlc3NDcmVhdGlvblBhcmFtZXRl cnMuaAppbmRleCA1NjE4NWFiZTc2YjUxYjNjNGYxNGM3ZjY2MDgzNWM3NzEwODlmMzg4Li42NzMw YTMzMjg0MDRiYzVjMzI2ZTUxYzA4N2NmYTFhNzY1NTUyZDdlIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViS2l0L1NoYXJlZC9XZWJQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmgKKysrIGIvU291cmNl L1dlYktpdC9TaGFyZWQvV2ViUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5oCkBAIC0xMDgsNiAr MTA4LDkgQEAgc3RydWN0IFdlYlByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMgewogCiAgICAgVmVj dG9yPFN0cmluZz4gZm9udFdoaXRlbGlzdDsKICAgICBWZWN0b3I8U3RyaW5nPiBsYW5ndWFnZXM7 CisjaWYgVVNFKEdTVFJFQU1FUikKKyAgICBWZWN0b3I8U3RyaW5nPiBnc3RyZWFtZXJPcHRpb25z OworI2VuZGlmCiAKICAgICBDYWNoZU1vZGVsIGNhY2hlTW9kZWw7CiAKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJLaXQvVUlQcm9jZXNzL2d0ay9XZWJQcm9jZXNzUG9vbEd0ay5jcHAgYi9Tb3VyY2Uv V2ViS2l0L1VJUHJvY2Vzcy9ndGsvV2ViUHJvY2Vzc1Bvb2xHdGsuY3BwCmluZGV4IGM1OTVkNTZk ZjM5MTM0YzA1MWU1YzE3NDJmOTUzODNkNDg4MWMzOWIuLmRkNzYxN2M1Y2IxOGQyMTNhMzNhZGNh NWI4YjM4NTNjZDZkZWE4YzQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL2d0 ay9XZWJQcm9jZXNzUG9vbEd0ay5jcHAKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvZ3Rr L1dlYlByb2Nlc3NQb29sR3RrLmNwcApAQCAtOTAsNiArOTAsMzEgQEAgdm9pZCBXZWJQcm9jZXNz UG9vbDo6cGxhdGZvcm1Jbml0aWFsaXplV2ViUHJvY2VzcyhXZWJQcm9jZXNzQ3JlYXRpb25QYXJh bWV0ZXJzJgogewogICAgIHBhcmFtZXRlcnMubWVtb3J5Q2FjaGVEaXNhYmxlZCA9IG1fbWVtb3J5 Q2FjaGVEaXNhYmxlZCB8fCBjYWNoZU1vZGVsKCkgPT0gQ2FjaGVNb2RlbERvY3VtZW50Vmlld2Vy OwogICAgIHBhcmFtZXRlcnMucHJveHlTZXR0aW5ncyA9IG1fbmV0d29ya1Byb3h5U2V0dGluZ3M7 CisKKyNpZiBVU0UoR1NUUkVBTUVSKQorICAgIEZJTEUqIGZpbGUgPSBmb3BlbigiL3Byb2Mvc2Vs Zi9jbWRsaW5lIiwgInIiKTsKKyAgICBnYm9vbGVhbiBpc0dTdHJlYW1lclBhcmFtZXRlcnMgPSBm YWxzZTsKKyAgICBlbnVtIHsKKyAgICAgICAgQnVmZmVyU2l6ZSA9IDIwNDgKKyAgICB9OworICAg IGNoYXIgYnVmZmVyW0J1ZmZlclNpemVdOworCisgICAgaWYgKCFmaWxlKQorICAgICAgICBwZXJy b3IoImZvcGVuIik7CisKKyAgICB3aGlsZSAoZmdldHMoYnVmZmVyLCBCdWZmZXJTaXplLCBmaWxl KSkgeworICAgICAgICBzaXplX3QgbiA9IDA7CisgICAgICAgIHdoaWxlIChuIDwgQnVmZmVyU2l6 ZSAmJiBidWZmZXJbbl0gIT0gJ1wwJykgeworICAgICAgICAgICAgaXNHU3RyZWFtZXJQYXJhbWV0 ZXJzID0gZ19zdHJfaGFzX3ByZWZpeChidWZmZXIgKyBuLCAiLS1nc3QiKTsKKyAgICAgICAgICAg IGlmIChpc0dTdHJlYW1lclBhcmFtZXRlcnMgPT0gVFJVRSkgeworICAgICAgICAgICAgICAgIGNo YXIqIHZhciA9ICZidWZmZXJbbl07CisgICAgICAgICAgICAgICAgcGFyYW1ldGVycy5nc3RyZWFt ZXJPcHRpb25zLmFwcGVuZChTdHJpbmc6OmZyb21VVEY4KHZhcikpOworICAgICAgICAgICAgfQor ICAgICAgICAgICAgbiArPSBzdHJsZW4oYnVmZmVyICsgbikgKyAxOworICAgICAgICB9CisgICAg fQorICAgIGZjbG9zZShmaWxlKTsKKyNlbmRpZgogfQogCiB2b2lkIFdlYlByb2Nlc3NQb29sOjpw bGF0Zm9ybUludmFsaWRhdGVDb250ZXh0KCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvV2Vi UHJvY2Vzcy9zb3VwL1dlYlByb2Nlc3NTb3VwLmNwcCBiL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vz cy9zb3VwL1dlYlByb2Nlc3NTb3VwLmNwcAppbmRleCAwNzEwNGJlM2EzOWZjNTU2YWI3MTQyZTNj N2JmZjQwNDI5NThjMDYxLi5hNDJkMGQ1OGFlNWEyNGRjYzNmN2IzYmYxZWRiOTkzYmRhOWViZDYy IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3Mvc291cC9XZWJQcm9jZXNzU291 cC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL3NvdXAvV2ViUHJvY2Vzc1NvdXAu Y3BwCkBAIC0yNyw2ICsyNyw3IEBACiAjaW5jbHVkZSAiY29uZmlnLmgiCiAjaW5jbHVkZSAiV2Vi UHJvY2Vzcy5oIgogCisjaW5jbHVkZSAiV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFt ZXIvR1N0cmVhbWVyVXRpbGl0aWVzLmgiCiAjaW5jbHVkZSAiV2ViUHJvY2Vzc0NyZWF0aW9uUGFy YW1ldGVycy5oIgogI2luY2x1ZGUgPFdlYkNvcmUvTWVtb3J5Q2FjaGUuaD4KICNpbmNsdWRlIDxX ZWJDb3JlL05ldHdvcmtTdG9yYWdlU2Vzc2lvbi5oPgpAQCAtNTEsNiArNTIsOSBAQCB2b2lkIFdl YlByb2Nlc3M6OnBsYXRmb3JtSW5pdGlhbGl6ZVdlYlByb2Nlc3MoV2ViUHJvY2Vzc0NyZWF0aW9u UGFyYW1ldGVycyYmIHBhcgogI2lmIFBMQVRGT1JNKFdBWUxBTkQpCiAgICAgbV93YXlsYW5kQ29t cG9zaXRvckRpc3BsYXkgPSBXYXlsYW5kQ29tcG9zaXRvckRpc3BsYXk6OmNyZWF0ZShwYXJhbWV0 ZXJzLndheWxhbmRDb21wb3NpdG9yRGlzcGxheU5hbWUpOwogI2VuZGlmCisjaWYgVVNFKEdTVFJF QU1FUikKKyAgICBXZWJDb3JlOjppbml0aWFsaXplR1N0cmVhbWVyKHBhcmFtZXRlcnMuZ3N0cmVh bWVyT3B0aW9ucyk7CisjZW5kaWYKIH0KIAogdm9pZCBXZWJQcm9jZXNzOjpwbGF0Zm9ybVRlcm1p bmF0ZSgpCmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5k ZXggZWEzNjAwMDUwY2M4YTcwMmY3ODA1NzFmMzQ1N2MyNWYyMWVhYjc3Yi4uM2QzMjEwM2I1NjY4 N2Y4YTViMmEwZDY5ZmFkMzRiYTY4NGY5ODI5ZSAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9n CisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDE3LTA5LTAzICBWYW5l c3NhIENoaXBpcnLDoXMgTmF2YWzDs24gIDx2Y2hpcGlycmFzQGlnYWxpYS5jb20+CisKKyAgICAg ICAgW0dTdHJlYW1lcl1bTWluaUJyb3dzZXJdIEhvbm9yIEdTdHJlYW1lciBjb21tYW5kIGxpbmUg cGFyYW1ldGVycyBpbiBNaW5pQnJvd3NlcgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MTczNjU1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgVGhlIEZJWE1FIGluIEdTdHJlYW1lclV0aWxpdGllcy5jcHAgYXNr cyB0byBwYXNzIHRoZSBjb21tYW5kIGxpbmUKKyAgICAgICAgcGFyYW1ldGVycyB0byB0aGUgR1N0 cmVhbWVyIGluaXRpYWxpemF0aW9uIGZ1bmN0aW9uLgorCisgICAgICAgICogTWluaUJyb3dzZXIv Z3RrL21haW4uYzoKKyAgICAgICAgKG1haW4pOiBBZGQgdGhlIGdyb3VwIGNvbnRhaW5pbmcgdGhl IEdzdHJlYW1lciBvcHRpb25zIHRoYXQgdGhlIGNvbnNvbGUgZGlzcGxheXMuCiAyMDE3LTA5LTAz ICBTYW0gV2VpbmlnICA8c2FtQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmVtb3ZlIENhbnZhc1By b3h5CmRpZmYgLS1naXQgYS9Ub29scy9NaW5pQnJvd3Nlci9ndGsvbWFpbi5jIGIvVG9vbHMvTWlu aUJyb3dzZXIvZ3RrL21haW4uYwppbmRleCA1ZTc2ZWQ4YWIxODc3MzU4NTMwNTkxNjJhYTk4NGQx OGNhZWJhMDRlLi5jNjQ2ZTk5N2UxYjRlMTk2NDBjNWEwN2YyYjkzZjM1MDFmNGI4YWZhIDEwMDY0 NAotLS0gYS9Ub29scy9NaW5pQnJvd3Nlci9ndGsvbWFpbi5jCisrKyBiL1Rvb2xzL01pbmlCcm93 c2VyL2d0ay9tYWluLmMKQEAgLTQ3Niw2ICs0NzYsNyBAQCBpbnQgbWFpbihpbnQgYXJnYywgY2hh ciAqYXJndltdKQogICAgIEdPcHRpb25Db250ZXh0ICpjb250ZXh0ID0gZ19vcHRpb25fY29udGV4 dF9uZXcoTlVMTCk7CiAgICAgZ19vcHRpb25fY29udGV4dF9hZGRfbWFpbl9lbnRyaWVzKGNvbnRl eHQsIGNvbW1hbmRMaW5lT3B0aW9ucywgMCk7CiAgICAgZ19vcHRpb25fY29udGV4dF9hZGRfZ3Jv dXAoY29udGV4dCwgZ3RrX2dldF9vcHRpb25fZ3JvdXAoVFJVRSkpOworICAgIGdfb3B0aW9uX2Nv bnRleHRfYWRkX2dyb3VwKGNvbnRleHQsIGdzdF9pbml0X2dldF9vcHRpb25fZ3JvdXAoKSk7CiAK ICAgICBXZWJLaXRTZXR0aW5ncyAqd2Via2l0U2V0dGluZ3MgPSB3ZWJraXRfc2V0dGluZ3NfbmV3 KCk7CiAgICAgd2Via2l0X3NldHRpbmdzX3NldF9lbmFibGVfZGV2ZWxvcGVyX2V4dHJhcyh3ZWJr aXRTZXR0aW5ncywgVFJVRSk7Cg== 334147 2018-02-19 01:57:14 -0800 2018-02-23 04:00:55 -0800 Patch bug-173655-20180219095712.patch text/plain 14185 pnormand U3VidmVyc2lvbiBSZXZpc2lvbjogMjI4NjE4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMjc1ZGY1N2E0NDYzNWZl NGIxNTcxM2RjY2EwMzRiMWJkYTE1MTgyMi4uMGZmYmQ3NjAwMzU0MjI2M2I4NGY0YjlhOGZlOTM2 MzNkMWRjN2I3YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI3IEBACisyMDE4LTAyLTE5ICBQaGls aXBwZSBOb3JtYW5kICA8cG5vcm1hbmRAaWdhbGlhLmNvbT4KKworICAgICAgICBbR1N0cmVhbWVy XVtNaW5pQnJvd3Nlcl0gSG9ub3IgR1N0cmVhbWVyIGNvbW1hbmQgbGluZSBwYXJhbWV0ZXJzIGlu IE1pbmlCcm93c2VyCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0xNzM2NTUKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAg ICAgICBUaGUgRklYTUUgaW4gR1N0cmVhbWVyVXRpbGl0aWVzLmNwcCBhc2tzIHRvIHBhc3MgdGhl IGNvbW1hbmQgbGluZQorICAgICAgICBwYXJhbWV0ZXJzIHRvIHRoZSBHU3RyZWFtZXIgaW5pdGlh bGl6YXRpb24gZnVuY3Rpb24uCisKKyAgICAgICAgQmFzZWQgb24gaW5pdGlhbCBwYXRjaCBieTog VmFuZXNzYSBDaGlwaXJyw6FzIE5hdmFsw7NuICA8dmNoaXBpcnJhc0BpZ2FsaWEuY29tPgorCisg ICAgICAgICogTW9kdWxlcy93ZWJhdWRpby9BdWRpb0NvbnRleHQuY3BwOgorICAgICAgICAoV2Vi Q29yZTo6QXVkaW9Db250ZXh0Ojpjb25zdHJ1Y3RDb21tb24pOiBSZW1vdmVzIHRoZSBjYWxsIHRv IHRoZSBtZXRob2QKKyAgICAgICAgdGhhdCBHU3RyZWFtZXIgaW5pdGlhbGl6ZXMuIEl0IGlzIG5v IGxvbmdlciBuZWNlc3NhcnkuCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVy L01lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2UuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 TWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZTo6aW5pdGlhbGl6ZUdTdHJlYW1lckFuZFJl Z2lzdGVyV2ViS2l0RWxlbWVudHMpOiBEaXR0bworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNz L2dzdHJlYW1lci9tc2UvTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyTVNFLmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OmluaXRpYWxpemVHU3RyZWFtZXJBbmRSZWdpc3RlcldlYktpdE1TRUVsZW1l bnQpOiBEaXR0bworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9HU3RyZWFt ZXJVdGlsaXRpZXMuY3BwOgorICAgICAgICAoV2ViQ29yZTo6aW5pdGlhbGl6ZUdTdHJlYW1lcik6 IFJlY2VpdmUgdGhlIEdTdHJlYW1lciBvcHRpb25zIGFuZCBpbml0aWFsaXplIEdTdHJlYW1lci4K KyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvR1N0cmVhbWVyVXRpbGl0aWVz Lmg6IEFkZCB2ZWN0b3Igd2hpY2ggY29udGFpbnMKKyAgICAgICAgR1N0cmVhbWVyIG9wdGlvbnMg YXMgdGhlIGlucHV0IHBhcmFtZXRlciBvZiB0aGUgaW5pdGlhbGl6ZUdTdHJlYW1lcigpIG1ldGhv ZC4KKwogMjAxOC0wMi0xOSAgUGhpbGlwcGUgTm9ybWFuZCAgPHBub3JtYW5kQGlnYWxpYS5jb20+ CiAKICAgICAgICAgW0dTdHJlYW1lcl0gUGxheWJpbjMgc3VwcG9ydApkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwppbmRleCA3MmJm ZDdiZTZkNTdjMTAzOWFmYWEzMTY0ZWE5MTdmNjhlZWVkZmJjLi43N2I5ZWNiMGUyODIwNjZiOTJi YWMzNjE2OTlmNTYwMTc4ZTM2OTUyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxv ZworKysgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwpAQCAtMSwzICsxLDI2IEBACisyMDE4LTAy LTE5ICBQaGlsaXBwZSBOb3JtYW5kICA8cG5vcm1hbmRAaWdhbGlhLmNvbT4KKworICAgICAgICBb R1N0cmVhbWVyXVtNaW5pQnJvd3Nlcl0gSG9ub3IgR1N0cmVhbWVyIGNvbW1hbmQgbGluZSBwYXJh bWV0ZXJzIGluIE1pbmlCcm93c2VyCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0xNzM2NTUKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBUaGUgRklYTUUgaW4gR1N0cmVhbWVyVXRpbGl0aWVzLmNwcCBhc2tzIHRv IHBhc3MgdGhlIGNvbW1hbmQgbGluZQorICAgICAgICBwYXJhbWV0ZXJzIHRvIHRoZSBHU3RyZWFt ZXIgaW5pdGlhbGl6YXRpb24gZnVuY3Rpb24uCisKKyAgICAgICAgQmFzZWQgb24gaW5pdGlhbCBw YXRjaCBieTogVmFuZXNzYSBDaGlwaXJyw6FzIE5hdmFsw7NuICA8dmNoaXBpcnJhc0BpZ2FsaWEu Y29tPgorCisgICAgICAgICogU2hhcmVkL1dlYlByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuY3Bw OgorICAgICAgICAoV2ViS2l0OjpXZWJQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzOjplbmNvZGUg Y29uc3QpOgorICAgICAgICAoV2ViS2l0OjpXZWJQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzOjpk ZWNvZGUpOgorICAgICAgICAqIFNoYXJlZC9XZWJQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmg6 IERlZmluZSB0aGUgdmVjdG9yIHdoaWNoIGNvbnRhaW5zIHRoZSBHU3RyZWFtZXIgb3B0aW9ucy4K KyAgICAgICAgKiBVSVByb2Nlc3MvZ3RrL1dlYlByb2Nlc3NQb29sR3RrLmNwcDoKKyAgICAgICAg KFdlYktpdDo6V2ViUHJvY2Vzc1Bvb2w6OnBsYXRmb3JtSW5pdGlhbGl6ZVdlYlByb2Nlc3MpOiBS ZWFkIGZyb20gY21kbGluZSBmaWxlCisgICAgICAgIHRoZSBHU3RyZWFtZXIgb3B0aW9ucyB3cml0 dGVuIGJ5IGNvbnNvbGUuCisgICAgICAgICogV2ViUHJvY2Vzcy9zb3VwL1dlYlByb2Nlc3NTb3Vw LmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViUHJvY2Vzczo6cGxhdGZvcm1Jbml0aWFsaXplV2Vi UHJvY2Vzcyk6IENhbGwgaW5pdGlhbGl6ZUdTdHJlYW1lcigpIG1ldGhvZCBwYXNzaW5nCisgICAg ICAgIHRoZSB2ZWN0b3Igd2hpY2ggY29udGFpbnMgdGhlIG9wdGlvbnMuCisKIDIwMTgtMDItMTgg IFJlemEgQWJiYXNpYW4gIDxyYWJiYXNpYW5AYXBwbGUuY29tPgogCiAgICAgICAgIFNldCB0aGUg YXBwcm9wcmlhdGUgQXV0b0ZpbGwgY29udGV4dCBmb3Igc3VnZ2VzdGVkIHBhc3N3b3Jkcy4KZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9Db250ZXh0LmNw cCBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9Db250ZXh0LmNwcAppbmRl eCAwOTFiMGQxY2FlNmQxNTk4NjUzMWJkNDk4ZGIzYmQ1OGU0MjIwYTM4Li5kYzY0NjJiMjgwMDNh YzMxZGRhNzdkOTM5OGQ5MDExODI2NDM2ZDYxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9N b2R1bGVzL3dlYmF1ZGlvL0F1ZGlvQ29udGV4dC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvTW9k dWxlcy93ZWJhdWRpby9BdWRpb0NvbnRleHQuY3BwCkBAIC0xNjIsMTAgKzE2Miw2IEBAIHZvaWQg QXVkaW9Db250ZXh0Ojpjb25zdHJ1Y3RDb21tb24oKQogICAgIC8vIExldHMgbWFyayBpdCBhcyBB Y3RpdmVET01PYmplY3Qgd2l0aCBwZW5kaW5nIGFjdGl2aXR5IGFuZCB1bm1hcmsgaXQgaW4gY2xl YXIgbWV0aG9kLgogICAgIHNldFBlbmRpbmdBY3Rpdml0eSh0aGlzKTsKIAotI2lmIFVTRShHU1RS RUFNRVIpCi0gICAgaW5pdGlhbGl6ZUdTdHJlYW1lcigpOwotI2VuZGlmCi0KICAgICBGRlRGcmFt ZTo6aW5pdGlhbGl6ZSgpOwogICAgIAogICAgIG1fbGlzdGVuZXIgPSBBdWRpb0xpc3RlbmVyOjpj cmVhdGUoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dz dHJlYW1lci9HU3RyZWFtZXJVdGlsaXRpZXMuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvZ3N0cmVhbWVyL0dTdHJlYW1lclV0aWxpdGllcy5jcHAKaW5kZXggOGMyZTBjMmZl ZDVlMzM0YzFkYmMwYzYzYjFkN2NlNDc2YTY2ZjcxOS4uYzNkZDdlNDA4ZGI5ZmMzYmZlOWFiMmQ2 MzZiMjM0ODJjYTEzYWFhZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvZ3N0cmVhbWVyL0dTdHJlYW1lclV0aWxpdGllcy5jcHAKKysrIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL0dTdHJlYW1lclV0aWxpdGllcy5jcHAKQEAg LTIzNiwxNSArMjM2LDI0IEBAIHZvaWQgdW5tYXBHc3RCdWZmZXIoR3N0QnVmZmVyKiBidWZmZXIp CiAgICAgZmFzdEZyZWUobWFwSW5mbyk7CiB9CiAKLWJvb2wgaW5pdGlhbGl6ZUdTdHJlYW1lcigp Citib29sIGluaXRpYWxpemVHU3RyZWFtZXIoVmVjdG9yPFN0cmluZz4mIHBhcmFtZXRlcnMpCiB7 Ci0gICAgaWYgKGdzdF9pc19pbml0aWFsaXplZCgpKQotICAgICAgICByZXR1cm4gdHJ1ZTsKLQog ICAgIEdVbmlxdWVPdXRQdHI8R0Vycm9yPiBlcnJvcjsKLSAgICAvLyBGSVhNRTogV2Ugc2hvdWxk IHByb2JhYmx5IHBhc3MgdGhlIGFyZ3VtZW50cyBmcm9tIHRoZSBjb21tYW5kIGxpbmUuCi0gICAg Ym9vbCBnc3RJbml0aWFsaXplZCA9IGdzdF9pbml0X2NoZWNrKG51bGxwdHIsIG51bGxwdHIsICZl cnJvci5vdXRQdHIoKSk7Ci0gICAgQVNTRVJUX1dJVEhfTUVTU0FHRShnc3RJbml0aWFsaXplZCwg IkdTdHJlYW1lciBpbml0aWFsaXphdGlvbiBmYWlsZWQ6ICVzIiwgZXJyb3IgPyBlcnJvci0+bWVz c2FnZSA6ICJ1bmtub3duIGVycm9yIG9jY3VycmVkIik7CisgICAgYm9vbCBpc0dTdHJlYW1lcklu aXRpYWxpemVkID0gZmFsc2U7CisKKyNpZiBFTkFCTEUoVklERU8pIHx8IEVOQUJMRShXRUJfQVVE SU8pCisgICAgY2hhcioqIG5Bcmd2OworICAgIHBhcmFtZXRlcnMuaW5zZXJ0KDAsICJXZWJQcm9j ZXNzIik7CisgICAgc2l6ZV90IGFyZ2NTaXplU3BsaXQgPSBwYXJhbWV0ZXJzLnNpemUoKTsKKyAg ICBuQXJndiA9IGdfbmV3MChjaGFyKiwgYXJnY1NpemVTcGxpdCsxKTsKKworICAgIGZvciAodW5z aWduZWQgaSA9IDA7IGkgPCBwYXJhbWV0ZXJzLnNpemUoKTsgaSsrKQorICAgICAgICBuQXJndltp XSA9IGdfc3RyZHVwKHBhcmFtZXRlcnNbaV0udXRmOCgpLmRhdGEoKSk7CisKKyAgICBpbnQgc2l6 ZSA9IGdfc3Rydl9sZW5ndGgobkFyZ3YpOworICAgIGlzR1N0cmVhbWVySW5pdGlhbGl6ZWQgPSBn c3RfaW5pdF9jaGVjaygmc2l6ZSwgJm5Bcmd2LCAmZXJyb3Iub3V0UHRyKCkpOworICAgIGdfc3Ry ZnJlZXYobkFyZ3YpOworICAgIEFTU0VSVF9XSVRIX01FU1NBR0UoaXNHU3RyZWFtZXJJbml0aWFs aXplZCwgIkdTdHJlYW1lciBpbml0aWFsaXphdGlvbiBmYWlsZWQ6ICVzIiwgZXJyb3IgPyBlcnJv ci0+bWVzc2FnZSA6ICJ1bmtub3duIGVycm9yIG9jY3VycmVkIik7CiAKICAgICBpZiAoaXNGYXN0 TWFsbG9jRW5hYmxlZCgpKSB7CiAgICAgICAgIGNvbnN0IGNoYXIqIGRpc2FibGVGYXN0TWFsbG9j ID0gZ2V0ZW52KCJXRUJLSVRfR1NUX0RJU0FCTEVfRkFTVF9NQUxMT0MiKTsKQEAgLTI1MywxMSAr MjYyLDEyIEBAIGJvb2wgaW5pdGlhbGl6ZUdTdHJlYW1lcigpCiAgICAgfQogCiAjaWYgRU5BQkxF KFZJREVPX1RSQUNLKSAmJiBVU0UoR1NUUkVBTUVSX01QRUdUUykKLSAgICBpZiAoZ3N0SW5pdGlh bGl6ZWQpCisgICAgaWYgKGlzR1N0cmVhbWVySW5pdGlhbGl6ZWQpCiAgICAgICAgIGdzdF9tcGVn dHNfaW5pdGlhbGl6ZSgpOworI2VuZGlmCiAjZW5kaWYKIAotICAgIHJldHVybiBnc3RJbml0aWFs aXplZDsKKyAgICByZXR1cm4gaXNHU3RyZWFtZXJJbml0aWFsaXplZDsKIH0KIAogdW5zaWduZWQg Z2V0R3N0UGxheUZsYWcoY29uc3QgY2hhciogbmljaykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9HU3RyZWFtZXJVdGlsaXRpZXMuaCBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9HU3RyZWFtZXJVdGlsaXRp ZXMuaAppbmRleCA4NDcyZDc4Mjk5NWI1NTNmYmI0OTIxMTc3NDg0Y2M1ZTg4MTdlYzUzLi4wMzYy YjczZTQ0NWIxMTJkYjM3ZjIzNzQ5MTE2MDVhNzU5ZTZhYWVkIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvR1N0cmVhbWVyVXRpbGl0aWVzLmgK KysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL0dTdHJlYW1l clV0aWxpdGllcy5oCkBAIC02OSw3ICs2OSw3IEBAIGJvb2wgZG9DYXBzSGF2ZVR5cGUoY29uc3Qg R3N0Q2FwcyosIGNvbnN0IGNoYXIqKTsKIGJvb2wgYXJlRW5jcnlwdGVkQ2Fwcyhjb25zdCBHc3RD YXBzKik7CiB2b2lkIG1hcEdzdEJ1ZmZlcihHc3RCdWZmZXIqLCB1aW50MzJfdCk7CiB2b2lkIHVu bWFwR3N0QnVmZmVyKEdzdEJ1ZmZlciopOwotYm9vbCBpbml0aWFsaXplR1N0cmVhbWVyKCk7Citi b29sIGluaXRpYWxpemVHU3RyZWFtZXIoVmVjdG9yPFN0cmluZz4mIHBhcmFtZXRlcnMpOwogdW5z aWduZWQgZ2V0R3N0UGxheUZsYWcoY29uc3QgY2hhciogbmljayk7CiB1aW50NjRfdCB0b0dzdFVu c2lnbmVkNjRUaW1lKGNvbnN0IE1lZGlhVGltZSYpOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVh bWVyQmFzZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIv TWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZS5jcHAKaW5kZXggYjRhMjgwZDI2NDBmMmFi MGI4NzA2MDdlNzA5MTUxOWViYTRjNmE5ZS4uZWVhZDU2MDVlYTQ5MTFmNTNiMWI1NGJkNzhiZDNh MzFhNmRkNDZjZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Z3N0cmVhbWVyL01lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2UuY3BwCisrKyBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9NZWRpYVBsYXllclByaXZhdGVH U3RyZWFtZXJCYXNlLmNwcApAQCAtMTM4LDkgKzEzOCw2IEBAIHZvaWQgcmVnaXN0ZXJXZWJLaXRH U3RyZWFtZXJFbGVtZW50cygpCiAKIGJvb2wgTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFz ZTo6aW5pdGlhbGl6ZUdTdHJlYW1lckFuZFJlZ2lzdGVyV2ViS2l0RWxlbWVudHMoKQogewotICAg IGlmICghaW5pdGlhbGl6ZUdTdHJlYW1lcigpKQotICAgICAgICByZXR1cm4gZmFsc2U7Ci0KICAg ICByZWdpc3RlcldlYktpdEdTdHJlYW1lckVsZW1lbnRzKCk7CiAKICAgICBHUmVmUHRyPEdzdEVs ZW1lbnRGYWN0b3J5PiBzcmNGYWN0b3J5ID0gYWRvcHRHUmVmKGdzdF9lbGVtZW50X2ZhY3Rvcnlf ZmluZCgid2Via2l0d2Vic3JjIikpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL21zZS9NZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJNU0Uu Y3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL21zZS9NZWRp YVBsYXllclByaXZhdGVHU3RyZWFtZXJNU0UuY3BwCmluZGV4IDQwZWFlOWExZTE2ZTY3ZDc3YzFm YWIwMGViOTc2NzFhZjI2NmQ0MTEuLjI3NWJjMmRhOTI0NjgxOTlmMDI1ZjRlYmU4ZmUxZDBiNTM2 Y2I5MWMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJl YW1lci9tc2UvTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyTVNFLmNwcAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvbXNlL01lZGlhUGxheWVyUHJpdmF0 ZUdTdHJlYW1lck1TRS5jcHAKQEAgLTg2LDkgKzg2LDYgQEAgdm9pZCBNZWRpYVBsYXllclByaXZh dGVHU3RyZWFtZXJNU0U6OnJlZ2lzdGVyTWVkaWFFbmdpbmUoTWVkaWFFbmdpbmVSZWdpc3RyYXIg cmUKIAogYm9vbCBpbml0aWFsaXplR1N0cmVhbWVyQW5kUmVnaXN0ZXJXZWJLaXRNU0VFbGVtZW50 KCkKIHsKLSAgICBpZiAoVU5MSUtFTFkoIWluaXRpYWxpemVHU3RyZWFtZXIoKSkpCi0gICAgICAg IHJldHVybiBmYWxzZTsKLQogICAgIHJlZ2lzdGVyV2ViS2l0R1N0cmVhbWVyRWxlbWVudHMoKTsK IAogICAgIEdTVF9ERUJVR19DQVRFR09SWV9JTklUKHdlYmtpdF9tc2VfZGVidWcsICJ3ZWJraXRt c2UiLCAwLCAiV2ViS2l0IE1TRSBtZWRpYSBwbGF5ZXIiKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJLaXQvU2hhcmVkL1dlYlByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuY3BwIGIvU291cmNlL1dl YktpdC9TaGFyZWQvV2ViUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5jcHAKaW5kZXggOWJjNmMz NzU2MzQ5ODQ0MjA5N2E5ZmNhODFiY2Q1ZDE0ZTA5NDJjMi4uNzQ3Yjg0YTNhZDI5ODAyOTQxMDdh MDllZDA3NGM1ZjVhYzk5YWExNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9TaGFyZWQvV2Vi UHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5jcHAKKysrIGIvU291cmNlL1dlYktpdC9TaGFyZWQv V2ViUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5jcHAKQEAgLTk0LDYgKzk0LDkgQEAgdm9pZCBX ZWJQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzOjplbmNvZGUoSVBDOjpFbmNvZGVyJiBlbmNvZGVy KSBjb25zdAogICAgIGVuY29kZXIgPDwgZm9udFdoaXRlbGlzdDsKICAgICBlbmNvZGVyIDw8IHRl cm1pbmF0aW9uVGltZW91dDsKICAgICBlbmNvZGVyIDw8IGxhbmd1YWdlczsKKyNpZiBVU0UoR1NU UkVBTUVSKQorICAgIGVuY29kZXIgPDwgZ3N0cmVhbWVyT3B0aW9uczsKKyNlbmRpZgogICAgIGVu Y29kZXIgPDwgdGV4dENoZWNrZXJTdGF0ZTsKICAgICBlbmNvZGVyIDw8IGZ1bGxLZXlib2FyZEFj Y2Vzc0VuYWJsZWQ7CiAgICAgZW5jb2RlciA8PCBkZWZhdWx0UmVxdWVzdFRpbWVvdXRJbnRlcnZh bDsKQEAgLTI5Niw2ICsyOTksMTAgQEAgYm9vbCBXZWJQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJz OjpkZWNvZGUoSVBDOjpEZWNvZGVyJiBkZWNvZGVyLCBXZWJQcm9jZXNzQ3JlYXQKICAgICAgICAg cmV0dXJuIGZhbHNlOwogICAgIGlmICghZGVjb2Rlci5kZWNvZGUocGFyYW1ldGVycy5sYW5ndWFn ZXMpKQogICAgICAgICByZXR1cm4gZmFsc2U7CisjaWYgVVNFKEdTVFJFQU1FUikKKyAgICBpZiAo IWRlY29kZXIuZGVjb2RlKHBhcmFtZXRlcnMuZ3N0cmVhbWVyT3B0aW9ucykpCisgICAgICAgIHJl dHVybiBmYWxzZTsKKyNlbmRpZgogICAgIGlmICghZGVjb2Rlci5kZWNvZGUocGFyYW1ldGVycy50 ZXh0Q2hlY2tlclN0YXRlKSkKICAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgIGlmICghZGVjb2Rl ci5kZWNvZGUocGFyYW1ldGVycy5mdWxsS2V5Ym9hcmRBY2Nlc3NFbmFibGVkKSkKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQvU2hhcmVkL1dlYlByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuaCBi L1NvdXJjZS9XZWJLaXQvU2hhcmVkL1dlYlByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuaAppbmRl eCA3MmU5Mjc0YzU1Y2E1ZGY5ZTJmMzA3ZWY2ZTIxMDVkMzU2OTQ2ZmEwLi4zZDA4MTNmNGY4Nzk0 MGM0OWFkYzgyMTRiMWFlNjg0NjE1Nzg5MTBmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1No YXJlZC9XZWJQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmgKKysrIGIvU291cmNlL1dlYktpdC9T aGFyZWQvV2ViUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5oCkBAIC0xMTEsNiArMTExLDkgQEAg c3RydWN0IFdlYlByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMgewogCiAgICAgVmVjdG9yPFN0cmlu Zz4gZm9udFdoaXRlbGlzdDsKICAgICBWZWN0b3I8U3RyaW5nPiBsYW5ndWFnZXM7CisjaWYgVVNF KEdTVFJFQU1FUikKKyAgICBWZWN0b3I8U3RyaW5nPiBnc3RyZWFtZXJPcHRpb25zOworI2VuZGlm CiAKICAgICBDYWNoZU1vZGVsIGNhY2hlTW9kZWw7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQvVUlQcm9jZXNzL2d0ay9XZWJQcm9jZXNzUG9vbEd0ay5jcHAgYi9Tb3VyY2UvV2ViS2l0L1VJ UHJvY2Vzcy9ndGsvV2ViUHJvY2Vzc1Bvb2xHdGsuY3BwCmluZGV4IGI0YTE3MjM5ZjViYzQ0NmRi YzBhNWMwZWJlZTNhYTU4N2NmZjhiOGEuLmVkZTQxMDZlN2I5NDZiN2I4MjQwYmE4MTA0OTFhOWZi OTA5MzMxZTkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL2d0ay9XZWJQcm9j ZXNzUG9vbEd0ay5jcHAKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvZ3RrL1dlYlByb2Nl c3NQb29sR3RrLmNwcApAQCAtOTAsNiArOTAsMTMgQEAgdm9pZCBXZWJQcm9jZXNzUG9vbDo6cGxh dGZvcm1Jbml0aWFsaXplV2ViUHJvY2VzcyhXZWJQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzJgog ewogICAgIHBhcmFtZXRlcnMubWVtb3J5Q2FjaGVEaXNhYmxlZCA9IG1fbWVtb3J5Q2FjaGVEaXNh YmxlZCB8fCBjYWNoZU1vZGVsKCkgPT0gQ2FjaGVNb2RlbERvY3VtZW50Vmlld2VyOwogICAgIHBh cmFtZXRlcnMucHJveHlTZXR0aW5ncyA9IG1fbmV0d29ya1Byb3h5U2V0dGluZ3M7CisKKyNpZiBV U0UoR1NUUkVBTUVSKQorICAgIEdVbmlxdWVPdXRQdHI8Z2NoYXI+IGNvbnRlbnRzOworICAgIGdz aXplIGxlbmd0aDsKKyAgICBpZiAoZ19maWxlX2dldF9jb250ZW50cygiL3Byb2Mvc2VsZi9jbWRs aW5lIiwgJmNvbnRlbnRzLm91dFB0cigpLCAmbGVuZ3RoLCBudWxscHRyKSkKKyAgICAgICAgcGFy YW1ldGVycy5nc3RyZWFtZXJPcHRpb25zLmFwcGVuZChTdHJpbmc6OmZyb21VVEY4KGNvbnRlbnRz LmdldCgpKSk7CisjZW5kaWYKIH0KIAogdm9pZCBXZWJQcm9jZXNzUG9vbDo6cGxhdGZvcm1JbnZh bGlkYXRlQ29udGV4dCgpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3Mvc291 cC9XZWJQcm9jZXNzU291cC5jcHAgYi9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3Mvc291cC9XZWJQ cm9jZXNzU291cC5jcHAKaW5kZXggMDcxMDRiZTNhMzlmYzU1NmFiNzE0MmUzYzdiZmY0MDQyOTU4 YzA2MS4uNWM5OWEzY2ZjNWUwZTJlNGJiYTZlNDk5YzQxOGRiNmE0OTcxMmM3ZSAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL3NvdXAvV2ViUHJvY2Vzc1NvdXAuY3BwCisrKyBi L1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9zb3VwL1dlYlByb2Nlc3NTb3VwLmNwcApAQCAtMjgs NiArMjgsNyBAQAogI2luY2x1ZGUgIldlYlByb2Nlc3MuaCIKIAogI2luY2x1ZGUgIldlYlByb2Nl c3NDcmVhdGlvblBhcmFtZXRlcnMuaCIKKyNpbmNsdWRlIDxXZWJDb3JlL0dTdHJlYW1lclV0aWxp dGllcy5oPgogI2luY2x1ZGUgPFdlYkNvcmUvTWVtb3J5Q2FjaGUuaD4KICNpbmNsdWRlIDxXZWJD b3JlL05ldHdvcmtTdG9yYWdlU2Vzc2lvbi5oPgogI2luY2x1ZGUgPFdlYkNvcmUvU291cE5ldHdv cmtTZXNzaW9uLmg+CkBAIC01MSw2ICs1Miw5IEBAIHZvaWQgV2ViUHJvY2Vzczo6cGxhdGZvcm1J bml0aWFsaXplV2ViUHJvY2VzcyhXZWJQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzJiYgcGFyCiAj aWYgUExBVEZPUk0oV0FZTEFORCkKICAgICBtX3dheWxhbmRDb21wb3NpdG9yRGlzcGxheSA9IFdh eWxhbmRDb21wb3NpdG9yRGlzcGxheTo6Y3JlYXRlKHBhcmFtZXRlcnMud2F5bGFuZENvbXBvc2l0 b3JEaXNwbGF5TmFtZSk7CiAjZW5kaWYKKyNpZiBVU0UoR1NUUkVBTUVSKQorICAgIFdlYkNvcmU6 OmluaXRpYWxpemVHU3RyZWFtZXIocGFyYW1ldGVycy5nc3RyZWFtZXJPcHRpb25zKTsKKyNlbmRp ZgogfQogCiB2b2lkIFdlYlByb2Nlc3M6OnBsYXRmb3JtVGVybWluYXRlKCkKZGlmZiAtLWdpdCBh L1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRleCBjYzhlODUzMzNjN2ZhY2U1 MGFiODNkOTE5YWRmNjNkYmE4M2JlNWUxLi4yYTAyZDEzM2EzNmI1ZWZmYTRiOGIwNjQwZGFiOWVh Mzg2ZWI0ZDdmIDEwMDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdl TG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMTgtMDItMTkgIFBoaWxpcHBlIE5vcm1hbmQgIDxwbm9y bWFuZEBpZ2FsaWEuY29tPgorCisgICAgICAgIFtHU3RyZWFtZXJdW01pbmlCcm93c2VyXSBIb25v ciBHU3RyZWFtZXIgY29tbWFuZCBsaW5lIHBhcmFtZXRlcnMgaW4gTWluaUJyb3dzZXIKKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE3MzY1NQorCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoZSBGSVhNRSBpbiBH U3RyZWFtZXJVdGlsaXRpZXMuY3BwIGFza3MgdG8gcGFzcyB0aGUgY29tbWFuZCBsaW5lCisgICAg ICAgIHBhcmFtZXRlcnMgdG8gdGhlIEdTdHJlYW1lciBpbml0aWFsaXphdGlvbiBmdW5jdGlvbi4K KworICAgICAgICBCYXNlZCBvbiBpbml0aWFsIHBhdGNoIGJ5OiBWYW5lc3NhIENoaXBpcnLDoXMg TmF2YWzDs24gIDx2Y2hpcGlycmFzQGlnYWxpYS5jb20+CisKKyAgICAgICAgKiBNaW5pQnJvd3Nl ci9ndGsvbWFpbi5jOgorICAgICAgICAobWFpbik6IEFkZCB0aGUgZ3JvdXAgY29udGFpbmluZyB0 aGUgR3N0cmVhbWVyIG9wdGlvbnMgdGhhdCB0aGUgY29uc29sZSBkaXNwbGF5cy4KIDIwMTgtMDIt MTYgIFJ5b3N1a2UgTml3YSAgPHJuaXdhQHdlYmtpdC5vcmc+CiAKICAgICAgICAgQWRkIGFuIGVu dGl0bGVtZW50IGNoZWNrIGZvciBzZXJ2aWNlIHdvcmtlciBvbiBpT1MKZGlmZiAtLWdpdCBhL1Rv b2xzL01pbmlCcm93c2VyL2d0ay9DTWFrZUxpc3RzLnR4dCBiL1Rvb2xzL01pbmlCcm93c2VyL2d0 ay9DTWFrZUxpc3RzLnR4dAppbmRleCBkYzJiNjFlNWVkNjhkYjVlODhiN2Y5ZTA4MDM0ZWIyODMx ODM2ZjFkLi5hMGQzMjA1OTYxN2U1MDhiMjc1NGZmNjljZTBjN2ExYWZiNDkyNzI3IDEwMDY0NAot LS0gYS9Ub29scy9NaW5pQnJvd3Nlci9ndGsvQ01ha2VMaXN0cy50eHQKKysrIGIvVG9vbHMvTWlu aUJyb3dzZXIvZ3RrL0NNYWtlTGlzdHMudHh0CkBAIC0zMiw2ICszMiw3IEBAIHNldChNaW5pQnJv d3Nlcl9TWVNURU1fSU5DTFVERV9ESVJFQ1RPUklFUwogICAgICR7R1RLM19JTkNMVURFX0RJUlN9 CiAgICAgJHtHTElCX0lOQ0xVREVfRElSU30KICAgICAke0xJQlNPVVBfSU5DTFVERV9ESVJTfQor ICAgICR7R1NUUkVBTUVSX0lOQ0xVREVfRElSU30KICkKIAogc2V0KE1pbmlCcm93c2VyX0xJQlJB UklFUwpAQCAtNDAsNiArNDEsNyBAQCBzZXQoTWluaUJyb3dzZXJfTElCUkFSSUVTCiAgICAgJHtH VEszX0xJQlJBUklFU30KICAgICAke0dMSUJfTElCUkFSSUVTfQogICAgICR7TElCU09VUF9MSUJS QVJJRVN9CisgICAgJHtHU1RSRUFNRVJfTElCUkFSSUVTfQogKQogCiBhZGRfY3VzdG9tX2NvbW1h bmQoCmRpZmYgLS1naXQgYS9Ub29scy9NaW5pQnJvd3Nlci9ndGsvbWFpbi5jIGIvVG9vbHMvTWlu aUJyb3dzZXIvZ3RrL21haW4uYwppbmRleCBjNWI4YTRlODlmYTRkNzEwNTQ1Njk1MWRkZDdjMGMz ZmNjNzY1MWY2Li5mNWRhNmVkZWRjY2Q0MWUzNjI2MzZmYTgwZWY3YWFlYjY0YWZmYjExIDEwMDY0 NAotLS0gYS9Ub29scy9NaW5pQnJvd3Nlci9ndGsvbWFpbi5jCisrKyBiL1Rvb2xzL01pbmlCcm93 c2VyL2d0ay9tYWluLmMKQEAgLTMwLDYgKzMwLDcgQEAKICNpbmNsdWRlICJCcm93c2VyV2luZG93 LmgiCiAjaW5jbHVkZSA8SmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdC5oPgogI2luY2x1ZGUgPGVy cm5vLmg+CisjaW5jbHVkZSA8Z3N0L2dzdC5oPgogI2luY2x1ZGUgPGd0ay9ndGsuaD4KICNpbmNs dWRlIDxzdHJpbmcuaD4KICNpbmNsdWRlIDx3ZWJraXQyL3dlYmtpdDIuaD4KQEAgLTQ4NCw2ICs0 ODUsNyBAQCBpbnQgbWFpbihpbnQgYXJnYywgY2hhciAqYXJndltdKQogICAgIEdPcHRpb25Db250 ZXh0ICpjb250ZXh0ID0gZ19vcHRpb25fY29udGV4dF9uZXcoTlVMTCk7CiAgICAgZ19vcHRpb25f Y29udGV4dF9hZGRfbWFpbl9lbnRyaWVzKGNvbnRleHQsIGNvbW1hbmRMaW5lT3B0aW9ucywgMCk7 CiAgICAgZ19vcHRpb25fY29udGV4dF9hZGRfZ3JvdXAoY29udGV4dCwgZ3RrX2dldF9vcHRpb25f Z3JvdXAoVFJVRSkpOworICAgIGdfb3B0aW9uX2NvbnRleHRfYWRkX2dyb3VwKGNvbnRleHQsIGdz dF9pbml0X2dldF9vcHRpb25fZ3JvdXAoKSk7CiAKICAgICBXZWJLaXRTZXR0aW5ncyAqd2Via2l0 U2V0dGluZ3MgPSB3ZWJraXRfc2V0dGluZ3NfbmV3KCk7CiAgICAgd2Via2l0X3NldHRpbmdzX3Nl dF9lbmFibGVfZGV2ZWxvcGVyX2V4dHJhcyh3ZWJraXRTZXR0aW5ncywgVFJVRSk7Cg== 334515 2018-02-23 04:00:55 -0800 2018-02-23 04:40:20 -0800 Patch gst-cmdline.diff text/plain 11258 cgarcia ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCBlNmZjNmFlODlmZC4uN2ZkMDBhYWVkNzAgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwyOCBAQAorMjAxOC0wMi0yMyAgQ2FybG9zIEdhcmNpYSBDYW1wb3MgIDxjZ2FyY2lhQGln YWxpYS5jb20+CisKKyAgICAgICAgW0dTdHJlYW1lcl1bTWluaUJyb3dzZXJdIEhvbm9yIEdTdHJl YW1lciBjb21tYW5kIGxpbmUgcGFyYW1ldGVycyBpbiBNaW5pQnJvd3NlcgorICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTczNjU1CisgICAgICAgIDxyZGFy Oi8vcHJvYmxlbS8zNzcwNjM0MT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBEbyBub3QgYXNzdW1lIGdzdCBpcyBvbmx5IHVzZWQgaW4gdGhlIFdlYlBy b2Nlc3MsIHRoZSBNSU1FVHlwZVJlZ2lzdHJ5IGFsc28gdXNlcyBnc3QgdG8gZ2V0IHRoZSBsaXN0 IG9mCisgICAgICAgIHN1cHBvcnRlZCBtZWRpYSB0eXBlcy4gTW92ZSB0aGUgY29kZSB0byBleHRy YWN0IGdzdCBvcHRpb25zIGZyb20gdGhlIHByb2Nlc3MgY29tbWFuZCBsaW5lIHRvIGEgaGVscGVy IGZ1bmN0aW9uCisgICAgICAgIGFuZCB1c2UgaXQgaW4gdGhlIFVJIHByb2Nlc3MgdG8gcGFzcyB0 aGUgb3B0aW9ucyB0byB0aGUgV2ViUHJvY2VzcywgYnV0IGFsc28gaW4gdGhlIGN1cnJlbnQgcHJv Y2VzcyB3aGVuIGdzdCBpcworICAgICAgICBpbml0aWFsaXplZCB3aXRob3V0IHByb3ZpZGluZyBv cHRpb25zLgorCisgICAgICAgIEZpeGVzIHNldmVyYWwgdW5pdCB0ZXN0cyB0aGF0IHVzZSBNSU1F VHlwZVJlZ2lzdHJ5IGluIHRoZSBVSSBwcm9jZXNzLgorCisgICAgICAgICogcGxhdGZvcm0vZ3Jh cGhpY3MvZ3N0cmVhbWVyL0dTdHJlYW1lclV0aWxpdGllcy5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpleHRyYWN0R1N0cmVhbWVyT3B0aW9uc0Zyb21Db21tYW5kTGluZSk6IEhlbHBlciB0byBnZXQg dGhlIGdzdCBvcHRpb25zIGZyb20gdGhlIGN1cnJlbnQgcHJvY2VzcworICAgICAgICBjb21tYW5k IGxpbmUuCisgICAgICAgIChXZWJDb3JlOjppbml0aWFsaXplR1N0cmVhbWVyKTogRW5zdXJlIHRo aXMgaXMgY2FsbGVkIG9uY2UuIEdldCB0aGUgZ3N0IG9wdGlvbnMgZnJvbSB0aGUgZ2l2ZW4gdmVj dG9yIG9yIGV4dHJhY3QKKyAgICAgICAgaXQgZnJvbSB0aGUgY29tbWFuZCBsaW5lIGlmIG5vdCBw cm92aWRlZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvR1N0cmVhbWVy VXRpbGl0aWVzLmg6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL01lZGlh UGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2UuY3BwOgorICAgICAgICAoV2ViQ29yZTo6TWVkaWFQ bGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZTo6aW5pdGlhbGl6ZUdTdHJlYW1lckFuZFJlZ2lzdGVy V2ViS2l0RWxlbWVudHMpOiBCcmluZyBiYWNrIHRoZSBnc3QKKyAgICAgICAgaW5pdGlhbGl6YXRp b24gaGVyZS4KKwogMjAxOC0wMi0yMSAgUGhpbGlwcGUgTm9ybWFuZCAgPHBub3JtYW5kQGlnYWxp YS5jb20+CiAKICAgICAgICAgW0dTdHJlYW1lcl0gQ3Jhc2ggaW4gRGVidWcgYnVpbGQgd2hlbiBw dXJnaW5nIGludmFsaWQgdHJhY2tzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9nc3RyZWFtZXIvR1N0cmVhbWVyVXRpbGl0aWVzLmNwcCBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9HU3RyZWFtZXJVdGlsaXRpZXMuY3BwCmlu ZGV4IGVhMjAyMjk2ZWI1Li5kNmY3ZTFjZGFmZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL0dTdHJlYW1lclV0aWxpdGllcy5jcHAKKysrIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL0dTdHJlYW1lclV0aWxp dGllcy5jcHAKQEAgLTI2LDkgKzI2LDEwIEBACiAjaW5jbHVkZSAiR1JlZlB0ckdTdHJlYW1lci5o IgogI2luY2x1ZGUgIkdzdEFsbG9jYXRvckZhc3RNYWxsb2MuaCIKICNpbmNsdWRlICJJbnRTaXpl LmgiCi0KICNpbmNsdWRlIDxnc3QvYXVkaW8vYXVkaW8taW5mby5oPgogI2luY2x1ZGUgPGdzdC9n c3QuaD4KKyNpbmNsdWRlIDxtdXRleD4KKyNpbmNsdWRlIDx3dGYvZ2xpYi9HTGliVXRpbGl0aWVz Lmg+CiAjaW5jbHVkZSA8d3RmL2dsaWIvR1VuaXF1ZVB0ci5oPgogCiAjaWYgRU5BQkxFKFZJREVP X1RSQUNLKSAmJiBVU0UoR1NUUkVBTUVSX01QRUdUUykKQEAgLTIzNiwzNCArMjM3LDY1IEBAIHZv aWQgdW5tYXBHc3RCdWZmZXIoR3N0QnVmZmVyKiBidWZmZXIpCiAgICAgZmFzdEZyZWUobWFwSW5m byk7CiB9CiAKLWJvb2wgaW5pdGlhbGl6ZUdTdHJlYW1lcihWZWN0b3I8U3RyaW5nPiYgcGFyYW1l dGVycykKK1ZlY3RvcjxTdHJpbmc+IGV4dHJhY3RHU3RyZWFtZXJPcHRpb25zRnJvbUNvbW1hbmRM aW5lKCkKK3sKKyAgICBHVW5pcXVlT3V0UHRyPGNoYXI+IGNvbnRlbnRzOworICAgIGdzaXplIGxl bmd0aDsKKyAgICBpZiAoIWdfZmlsZV9nZXRfY29udGVudHMoIi9wcm9jL3NlbGYvY21kbGluZSIs ICZjb250ZW50cy5vdXRQdHIoKSwgJmxlbmd0aCwgbnVsbHB0cikpCisgICAgICAgIHJldHVybiB7 IH07CisKKyAgICBWZWN0b3I8U3RyaW5nPiBvcHRpb25zOworICAgIGNvbnN0IGNoYXIqIG9wdGlv biA9IGNvbnRlbnRzLmdldCgpOworICAgIHdoaWxlIChsZW5ndGggPiAwKSB7CisgICAgICAgIGlm IChnX3N0cl9oYXNfcHJlZml4KG9wdGlvbiwgIi0tZ3N0IikpCisgICAgICAgICAgICBvcHRpb25z LmFwcGVuZChTdHJpbmc6OmZyb21VVEY4KG9wdGlvbikpOworCisgICAgICAgIGF1dG8gb3B0aW9u TGVuZ3RoID0gc3RybGVuKG9wdGlvbik7CisgICAgICAgIG9wdGlvbiArPSBvcHRpb25MZW5ndGg7 CisgICAgICAgIGxlbmd0aCAtPSBvcHRpb25MZW5ndGg7CisKKyAgICAgICAgLy8gU2tpcCBudWxs IGNoYXJhY3RlcnMuCisgICAgICAgIHdoaWxlIChsZW5ndGggPiAwICYmICpvcHRpb24gPT0gJ1ww JykgeworICAgICAgICAgICAgb3B0aW9uKys7CisgICAgICAgICAgICBsZW5ndGgtLTsKKyAgICAg ICAgfQorICAgIH0KKworICAgIHJldHVybiBvcHRpb25zOworfQorCitib29sIGluaXRpYWxpemVH U3RyZWFtZXIoc3RkOjpvcHRpb25hbDxWZWN0b3I8U3RyaW5nPj4mJiBvcHRpb25zKQogewotICAg IEdVbmlxdWVPdXRQdHI8R0Vycm9yPiBlcnJvcjsKLSAgICBib29sIGlzR1N0cmVhbWVySW5pdGlh bGl6ZWQgPSBmYWxzZTsKKyAgICBzdGF0aWMgc3RkOjpvbmNlX2ZsYWcgb25jZUZsYWc7CisgICAg c3RhdGljIGJvb2wgaXNHU3RyZWFtZXJJbml0aWFsaXplZDsKKyAgICBzdGQ6OmNhbGxfb25jZShv bmNlRmxhZywgW29wdGlvbnMgPSBXVEZNb3ZlKG9wdGlvbnMpXSB7CisgICAgICAgIGlzR1N0cmVh bWVySW5pdGlhbGl6ZWQgPSBmYWxzZTsKIAogI2lmIEVOQUJMRShWSURFTykgfHwgRU5BQkxFKFdF Ql9BVURJTykKLSAgICBjaGFyKiogYXJndiA9IGdfbmV3MChjaGFyKiwgcGFyYW1ldGVycy5zaXpl KCkgKyAyKTsKLSAgICBhcmd2WzBdID0gZ19zdHJkdXAoIldlYlByb2Nlc3MiKTsKLSAgICBmb3Ig KHVuc2lnbmVkIGkgPSAxOyBpIDwgcGFyYW1ldGVycy5zaXplKCk7IGkrKykKLSAgICAgICAgYXJn dltpXSA9IGdfc3RyZHVwKHBhcmFtZXRlcnNbaV0udXRmOCgpLmRhdGEoKSk7Ci0KLSAgICBpbnQg c2l6ZSA9IGdfc3Rydl9sZW5ndGgoYXJndik7Ci0gICAgaXNHU3RyZWFtZXJJbml0aWFsaXplZCA9 IGdzdF9pbml0X2NoZWNrKCZzaXplLCAmYXJndiwgJmVycm9yLm91dFB0cigpKTsKLSAgICBnX3N0 cmZyZWV2KGFyZ3YpOwotICAgIEFTU0VSVF9XSVRIX01FU1NBR0UoaXNHU3RyZWFtZXJJbml0aWFs aXplZCwgIkdTdHJlYW1lciBpbml0aWFsaXphdGlvbiBmYWlsZWQ6ICVzIiwgZXJyb3IgPyBlcnJv ci0+bWVzc2FnZSA6ICJ1bmtub3duIGVycm9yIG9jY3VycmVkIik7Ci0KLSAgICBpZiAoaXNGYXN0 TWFsbG9jRW5hYmxlZCgpKSB7Ci0gICAgICAgIGNvbnN0IGNoYXIqIGRpc2FibGVGYXN0TWFsbG9j ID0gZ2V0ZW52KCJXRUJLSVRfR1NUX0RJU0FCTEVfRkFTVF9NQUxMT0MiKTsKLSAgICAgICAgaWYg KCFkaXNhYmxlRmFzdE1hbGxvYyB8fCAhc3RyY21wKGRpc2FibGVGYXN0TWFsbG9jLCAiMCIpKQot ICAgICAgICAgICAgZ3N0X2FsbG9jYXRvcl9zZXRfZGVmYXVsdChHU1RfQUxMT0NBVE9SKGdfb2Jq ZWN0X25ldyhnc3RfYWxsb2NhdG9yX2Zhc3RfbWFsbG9jX2dldF90eXBlKCksIG51bGxwdHIpKSk7 Ci0gICAgfQorICAgICAgICBWZWN0b3I8U3RyaW5nPiBwYXJhbWV0ZXJzID0gb3B0aW9ucy52YWx1 ZV9vcihleHRyYWN0R1N0cmVhbWVyT3B0aW9uc0Zyb21Db21tYW5kTGluZSgpKTsKKyAgICAgICAg Y2hhcioqIGFyZ3YgPSBnX25ldzAoY2hhciosIHBhcmFtZXRlcnMuc2l6ZSgpICsgMik7CisgICAg ICAgIGludCBhcmdjID0gcGFyYW1ldGVycy5zaXplKCkgKyAxOworICAgICAgICBhcmd2WzBdID0g Z19zdHJkdXAoZ19nZXRfcHJnbmFtZSgpKTsKKyAgICAgICAgZm9yICh1bnNpZ25lZCBpID0gMDsg aSA8IHBhcmFtZXRlcnMuc2l6ZSgpOyBpKyspCisgICAgICAgICAgICBhcmd2W2kgKyAxXSA9IGdf c3RyZHVwKHBhcmFtZXRlcnNbaV0udXRmOCgpLmRhdGEoKSk7CisKKyAgICAgICAgR1VuaXF1ZU91 dFB0cjxHRXJyb3I+IGVycm9yOworICAgICAgICBpc0dTdHJlYW1lckluaXRpYWxpemVkID0gZ3N0 X2luaXRfY2hlY2soJmFyZ2MsICZhcmd2LCAmZXJyb3Iub3V0UHRyKCkpOworICAgICAgICBBU1NF UlRfV0lUSF9NRVNTQUdFKGlzR1N0cmVhbWVySW5pdGlhbGl6ZWQsICJHU3RyZWFtZXIgaW5pdGlh bGl6YXRpb24gZmFpbGVkOiAlcyIsIGVycm9yID8gZXJyb3ItPm1lc3NhZ2UgOiAidW5rbm93biBl cnJvciBvY2N1cnJlZCIpOworICAgICAgICBnX3N0cmZyZWV2KGFyZ3YpOworCisgICAgICAgIGlm IChpc0Zhc3RNYWxsb2NFbmFibGVkKCkpIHsKKyAgICAgICAgICAgIGNvbnN0IGNoYXIqIGRpc2Fi bGVGYXN0TWFsbG9jID0gZ2V0ZW52KCJXRUJLSVRfR1NUX0RJU0FCTEVfRkFTVF9NQUxMT0MiKTsK KyAgICAgICAgICAgIGlmICghZGlzYWJsZUZhc3RNYWxsb2MgfHwgIXN0cmNtcChkaXNhYmxlRmFz dE1hbGxvYywgIjAiKSkKKyAgICAgICAgICAgICAgICBnc3RfYWxsb2NhdG9yX3NldF9kZWZhdWx0 KEdTVF9BTExPQ0FUT1IoZ19vYmplY3RfbmV3KGdzdF9hbGxvY2F0b3JfZmFzdF9tYWxsb2NfZ2V0 X3R5cGUoKSwgbnVsbHB0cikpKTsKKyAgICAgICAgfQogCiAjaWYgRU5BQkxFKFZJREVPX1RSQUNL KSAmJiBVU0UoR1NUUkVBTUVSX01QRUdUUykKLSAgICBpZiAoaXNHU3RyZWFtZXJJbml0aWFsaXpl ZCkKLSAgICAgICAgZ3N0X21wZWd0c19pbml0aWFsaXplKCk7CisgICAgICAgIGlmIChpc0dTdHJl YW1lckluaXRpYWxpemVkKQorICAgICAgICAgICAgZ3N0X21wZWd0c19pbml0aWFsaXplKCk7CiAj ZW5kaWYKICNlbmRpZgotCisgICAgfSk7CiAgICAgcmV0dXJuIGlzR1N0cmVhbWVySW5pdGlhbGl6 ZWQ7CiB9CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dz dHJlYW1lci9HU3RyZWFtZXJVdGlsaXRpZXMuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2dzdHJlYW1lci9HU3RyZWFtZXJVdGlsaXRpZXMuaAppbmRleCAwMzYyYjczZTQ0NS4u YTQ4YjRhYzllZTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L2dzdHJlYW1lci9HU3RyZWFtZXJVdGlsaXRpZXMuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvR1N0cmVhbWVyVXRpbGl0aWVzLmgKQEAgLTY5LDcgKzY5 LDggQEAgYm9vbCBkb0NhcHNIYXZlVHlwZShjb25zdCBHc3RDYXBzKiwgY29uc3QgY2hhciopOwog Ym9vbCBhcmVFbmNyeXB0ZWRDYXBzKGNvbnN0IEdzdENhcHMqKTsKIHZvaWQgbWFwR3N0QnVmZmVy KEdzdEJ1ZmZlciosIHVpbnQzMl90KTsKIHZvaWQgdW5tYXBHc3RCdWZmZXIoR3N0QnVmZmVyKik7 Ci1ib29sIGluaXRpYWxpemVHU3RyZWFtZXIoVmVjdG9yPFN0cmluZz4mIHBhcmFtZXRlcnMpOwor VmVjdG9yPFN0cmluZz4gZXh0cmFjdEdTdHJlYW1lck9wdGlvbnNGcm9tQ29tbWFuZExpbmUoKTsK K2Jvb2wgaW5pdGlhbGl6ZUdTdHJlYW1lcihzdGQ6Om9wdGlvbmFsPFZlY3RvcjxTdHJpbmc+PiYm ID0gc3RkOjpudWxsb3B0KTsKIHVuc2lnbmVkIGdldEdzdFBsYXlGbGFnKGNvbnN0IGNoYXIqIG5p Y2spOwogdWludDY0X3QgdG9Hc3RVbnNpZ25lZDY0VGltZShjb25zdCBNZWRpYVRpbWUmKTsKIApk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL01l ZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2UuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL01lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2UuY3Bw CmluZGV4IDZjYzczZGU2MDk5Li4yYzc5ZmRlZjM4YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL01lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1l ckJhc2UuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1l ci9NZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlLmNwcApAQCAtMTM5LDYgKzEzOSw5IEBA IHZvaWQgcmVnaXN0ZXJXZWJLaXRHU3RyZWFtZXJFbGVtZW50cygpCiAKIGJvb2wgTWVkaWFQbGF5 ZXJQcml2YXRlR1N0cmVhbWVyQmFzZTo6aW5pdGlhbGl6ZUdTdHJlYW1lckFuZFJlZ2lzdGVyV2Vi S2l0RWxlbWVudHMoKQogeworICAgIGlmICghaW5pdGlhbGl6ZUdTdHJlYW1lcigpKQorICAgICAg ICByZXR1cm4gZmFsc2U7CisKICAgICByZWdpc3RlcldlYktpdEdTdHJlYW1lckVsZW1lbnRzKCk7 CiAKICAgICBHUmVmUHRyPEdzdEVsZW1lbnRGYWN0b3J5PiBzcmNGYWN0b3J5ID0gYWRvcHRHUmVm KGdzdF9lbGVtZW50X2ZhY3RvcnlfZmluZCgid2Via2l0d2Vic3JjIikpOwpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYktpdC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwppbmRleCBk YWUwZGFlYmJiNC4uNzhmNmNhNzkzMjMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdl TG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjMgQEAKKzIwMTgt MDItMjMgIENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNpYUBpZ2FsaWEuY29tPgorCisgICAg ICAgIFtHU3RyZWFtZXJdW01pbmlCcm93c2VyXSBIb25vciBHU3RyZWFtZXIgY29tbWFuZCBsaW5l IHBhcmFtZXRlcnMgaW4gTWluaUJyb3dzZXIKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTE3MzY1NQorICAgICAgICA8cmRhcjovL3Byb2JsZW0vMzc3MDYz NDE+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWN0 dWFsbHkgcGFzcyB0aGUgZ3N0IGNvbW1hbmQgbGluZSBvcHRpb25zIHRvIHRoZSBXZWJQcm9jZXNz LiBUaGUgb3B0aW9ucyBpbiAvcHJvYy9zZWxmL2NtZGxpbmUgYXJlIHNlcGFyYXRlZCBieQorICAg ICAgICBudWxsIGNoYXJhY3RlcnMsIHNvIHdlIGFyZSBlZmZlY3RpdmVseSBwYXNzaW5nIGFsd2F5 cyB0aGUgZmlyc3Qgb3B0aW9uIG9ubHksIHdoaWNoIGlzIHRoZSBwcm9ncmFtIG5hbWUuIFRoZW4s IGluCisgICAgICAgIHRoZSB3ZWIgcHJvY2VzcyB3ZSBhbHdheXMgaWdub3JlIHRoZSBmaXJzdCBv cHRpb24gYW5kIHByb3ZpZGluZyBXZWJQcm9jZXNzIHVuY29uZGl0aW9uYWxseSwgc28gd2Ugd2Vy ZSBkb2luZworICAgICAgICBub3RoaW5nLgorCisgICAgICAgICogVUlQcm9jZXNzL2d0ay9XZWJQ cm9jZXNzUG9vbEd0ay5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYlByb2Nlc3NQb29sOjpwbGF0 Zm9ybUluaXRpYWxpemVXZWJQcm9jZXNzKTogVXNlIFdlYkNvcmU6OmV4dHJhY3RHU3RyZWFtZXJP cHRpb25zRnJvbUNvbW1hbmRMaW5lKCkKKyAgICAgICAgKiBVSVByb2Nlc3Mvd3BlL1dlYlByb2Nl c3NQb29sV1BFLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViUHJvY2Vzc1Bvb2w6OnBsYXRmb3Jt SW5pdGlhbGl6ZVdlYlByb2Nlc3MpOiBEaXR0by4KKyAgICAgICAgKiBXZWJQcm9jZXNzL3NvdXAv V2ViUHJvY2Vzc1NvdXAuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJQcm9jZXNzOjpwbGF0Zm9y bUluaXRpYWxpemVXZWJQcm9jZXNzKTogTW92ZSB0aGUgdmVjdG9yLgorCiAyMDE4LTAyLTIwICBO YW4gV2FuZyAgPG5fd2FuZ0BhcHBsZS5jb20+CiAKICAgICAgICAgQVg6IEtleWJvYXJkIGZvY3Vz IG5vdCBmb2xsb3dpbmcgVm9pY2VPdmVyIGN1cnNvciBpbnRvIHdlYiBjb250ZW50IG9yIHdpdGhp biB3ZWIgY29udGVudC4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL2d0ay9X ZWJQcm9jZXNzUG9vbEd0ay5jcHAgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9ndGsvV2ViUHJv Y2Vzc1Bvb2xHdGsuY3BwCmluZGV4IGVkZTQxMDZlN2I5Li4zNzcxZGM1NThiNSAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvZ3RrL1dlYlByb2Nlc3NQb29sR3RrLmNwcAorKysg Yi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9ndGsvV2ViUHJvY2Vzc1Bvb2xHdGsuY3BwCkBAIC0z NSw2ICszNSw3IEBACiAjaW5jbHVkZSAiV2ViUHJvY2Vzc01lc3NhZ2VzLmgiCiAjaW5jbHVkZSA8 SmF2YVNjcmlwdENvcmUvUmVtb3RlSW5zcGVjdG9yU2VydmVyLmg+CiAjaW5jbHVkZSA8V2ViQ29y ZS9GaWxlU3lzdGVtLmg+CisjaW5jbHVkZSA8V2ViQ29yZS9HU3RyZWFtZXJVdGlsaXRpZXMuaD4K ICNpbmNsdWRlIDxXZWJDb3JlL05vdEltcGxlbWVudGVkLmg+CiAjaW5jbHVkZSA8V2ViQ29yZS9T Y2hlbWVSZWdpc3RyeS5oPgogI2luY2x1ZGUgPHd0Zi9nbGliL0dVbmlxdWVQdHIuaD4KQEAgLTky LDEwICs5Myw3IEBAIHZvaWQgV2ViUHJvY2Vzc1Bvb2w6OnBsYXRmb3JtSW5pdGlhbGl6ZVdlYlBy b2Nlc3MoV2ViUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycyYKICAgICBwYXJhbWV0ZXJzLnByb3h5 U2V0dGluZ3MgPSBtX25ldHdvcmtQcm94eVNldHRpbmdzOwogCiAjaWYgVVNFKEdTVFJFQU1FUikK LSAgICBHVW5pcXVlT3V0UHRyPGdjaGFyPiBjb250ZW50czsKLSAgICBnc2l6ZSBsZW5ndGg7Ci0g ICAgaWYgKGdfZmlsZV9nZXRfY29udGVudHMoIi9wcm9jL3NlbGYvY21kbGluZSIsICZjb250ZW50 cy5vdXRQdHIoKSwgJmxlbmd0aCwgbnVsbHB0cikpCi0gICAgICAgIHBhcmFtZXRlcnMuZ3N0cmVh bWVyT3B0aW9ucy5hcHBlbmQoU3RyaW5nOjpmcm9tVVRGOChjb250ZW50cy5nZXQoKSkpOworICAg IHBhcmFtZXRlcnMuZ3N0cmVhbWVyT3B0aW9ucyA9IFdlYkNvcmU6OmV4dHJhY3RHU3RyZWFtZXJP cHRpb25zRnJvbUNvbW1hbmRMaW5lKCk7CiAjZW5kaWYKIH0KIApkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdC9VSVByb2Nlc3Mvd3BlL1dlYlByb2Nlc3NQb29sV1BFLmNwcCBiL1NvdXJjZS9XZWJL aXQvVUlQcm9jZXNzL3dwZS9XZWJQcm9jZXNzUG9vbFdQRS5jcHAKaW5kZXggNzNkODAxYmE5NWMu LjlkOTk3NGY2YWNjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy93cGUvV2Vi UHJvY2Vzc1Bvb2xXUEUuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL3dwZS9XZWJQ cm9jZXNzUG9vbFdQRS5jcHAKQEAgLTM2LDYgKzM2LDcgQEAKICNpbmNsdWRlICJXZWJQcm9jZXNz TWVzc2FnZXMuaCIKICNpbmNsdWRlIDxKYXZhU2NyaXB0Q29yZS9SZW1vdGVJbnNwZWN0b3JTZXJ2 ZXIuaD4KICNpbmNsdWRlIDxXZWJDb3JlL0ZpbGVTeXN0ZW0uaD4KKyNpbmNsdWRlIDxXZWJDb3Jl L0dTdHJlYW1lclV0aWxpdGllcy5oPgogI2luY2x1ZGUgPFdlYkNvcmUvTm90SW1wbGVtZW50ZWQu aD4KICNpbmNsdWRlIDxXZWJDb3JlL1NjaGVtZVJlZ2lzdHJ5Lmg+CiAjaW5jbHVkZSA8Y3N0ZGxp Yj4KQEAgLTkyLDYgKzkzLDEwIEBAIFdURjo6U3RyaW5nIFdlYlByb2Nlc3NQb29sOjpsZWdhY3lQ bGF0Zm9ybURlZmF1bHRNZWRpYUNhY2hlRGlyZWN0b3J5KCkKIHZvaWQgV2ViUHJvY2Vzc1Bvb2w6 OnBsYXRmb3JtSW5pdGlhbGl6ZVdlYlByb2Nlc3MoV2ViUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVy cyYgcGFyYW1ldGVycykKIHsKICAgICBwYXJhbWV0ZXJzLm1lbW9yeUNhY2hlRGlzYWJsZWQgPSBt X21lbW9yeUNhY2hlRGlzYWJsZWQgfHwgY2FjaGVNb2RlbCgpID09IENhY2hlTW9kZWxEb2N1bWVu dFZpZXdlcjsKKyNpZiBVU0UoR1NUUkVBTUVSKQorICAgIHBhcmFtZXRlcnMuZ3N0cmVhbWVyT3B0 aW9ucyA9IFdlYkNvcmU6OmV4dHJhY3RHU3RyZWFtZXJPcHRpb25zRnJvbUNvbW1hbmRMaW5lKCk7 CisjZW5kaWYKKwogfQogCiB2b2lkIFdlYlByb2Nlc3NQb29sOjpwbGF0Zm9ybUludmFsaWRhdGVD b250ZXh0KCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9zb3VwL1dlYlBy b2Nlc3NTb3VwLmNwcCBiL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9zb3VwL1dlYlByb2Nlc3NT b3VwLmNwcAppbmRleCA1Yzk5YTNjZmM1ZS4uYWNhZjgzNmRjOWMgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQvV2ViUHJvY2Vzcy9zb3VwL1dlYlByb2Nlc3NTb3VwLmNwcAorKysgYi9Tb3VyY2Uv V2ViS2l0L1dlYlByb2Nlc3Mvc291cC9XZWJQcm9jZXNzU291cC5jcHAKQEAgLTUzLDcgKzUzLDcg QEAgdm9pZCBXZWJQcm9jZXNzOjpwbGF0Zm9ybUluaXRpYWxpemVXZWJQcm9jZXNzKFdlYlByb2Nl c3NDcmVhdGlvblBhcmFtZXRlcnMmJiBwYXIKICAgICBtX3dheWxhbmRDb21wb3NpdG9yRGlzcGxh eSA9IFdheWxhbmRDb21wb3NpdG9yRGlzcGxheTo6Y3JlYXRlKHBhcmFtZXRlcnMud2F5bGFuZENv bXBvc2l0b3JEaXNwbGF5TmFtZSk7CiAjZW5kaWYKICNpZiBVU0UoR1NUUkVBTUVSKQotICAgIFdl YkNvcmU6OmluaXRpYWxpemVHU3RyZWFtZXIocGFyYW1ldGVycy5nc3RyZWFtZXJPcHRpb25zKTsK KyAgICBXZWJDb3JlOjppbml0aWFsaXplR1N0cmVhbWVyKFdURk1vdmUocGFyYW1ldGVycy5nc3Ry ZWFtZXJPcHRpb25zKSk7CiAjZW5kaWYKIH0KIAo=