118974 2013-07-22 10:30:58 -0700 [GStreamer] Video player sets system volume to 100% 2015-07-08 07:13:05 -0700 1 1 1 Unclassified WebKit WebKitGTK 528+ (Nightly build) PC Linux RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=145609 https://bugs.webkit.org/show_bug.cgi?id=140358 http://www.w3.org/2010/05/video/mediaevents.html P2 Major --- 54140 1 jonathon calvaris allan.jensen calvaris commit-queue eric.carlson esprehn+autocc glenn gustavo jer.noble menard mrobinson patrakov pnormand oldest_to_newest 910715 0 jonathon 2013-07-22 10:30:58 -0700 +++ This bug was initially created as a clone of Bug #54140 +++ My computer's system volume is usually set around 25%, which is fairly loud. Whenever I open a page in webkitgtk (via Epiphany) with an html5 video, the player automatically sets its volume to 100%. This in turn drags the system volume up to 100%, resulting in me blasted and frantically reaching for the volume knob in an effort to save my ears. It's possible that this issue only happens on systems that use pulseaudio (which is probably almost everyone on linux these days). According to the pulseaudio/gsreamer developers, this is what is supposed to happen if you set a stream volume to 1.0. The system volume is always equal to the volume level of the loudest stream. What this means is that explicitly setting the webkit player stream to 1.0 will *always* set the system volume to the maximum value. The problem can be easily reproduced by setting the system volume to a low value (e.g. 25%) and then vising e.g. http://www.w3.org/2010/05/video/mediaevents.html and playing the video. Be careful not to have headphones on when doing the above test, or your ears might get damaged. This is one of those little but extremely annoying issues that prevents me from using WebKitGtk as much as I'd like to these days. 910720 1 pnormand 2013-07-22 10:38:09 -0700 +Xabier in CC, who's been looking at this issue too. 911686 2 jonathon 2013-07-25 11:02:55 -0700 Xabier, are you actively working on this, or would you like me to look into it? 911767 3 calvaris 2013-07-25 14:31:20 -0700 (In reply to comment #2) > Xabier, are you actively working on this, or would you like me to look into it? Not now. You can have a look if you want. 911768 4 calvaris 2013-07-25 14:32:05 -0700 (In reply to comment #3) > (In reply to comment #2) > > Xabier, are you actively working on this, or would you like me to look into it? > > Not now. You can have a look if you want. Anyway, if I have free time I could try to give it a look too, but I cannot guarantee anything. 914428 5 208081 calvaris 2013-08-04 00:47:23 -0700 Created attachment 208081 Patch 914429 6 calvaris 2013-08-04 00:56:20 -0700 (In reply to comment #5) > Created an attachment (id=208081) [details] > Patch This is a proof of concept, that's why I didn't request the review flag. This is a workaround I could think of. The ideas behind it is: * Keeping the latest volume used. * We could just avoid setting the volume when creating the MediaPlayer, but if we reset it like this, the behavior is more coherent when using another sink, like alsa. * In this case, both pulse with and without flat volumes work the same, the volume is kept from the last used. In the case of alsa, it always begins with 100%, but as it has relative volume to system, it shouldn't be a big deal. Alternatives to this workaround: * Another workaround of checking if we are using flat volume, which would require GStreamer exposing such property. * Using a volume element that would make us control the whole volume ourselves but we would lose audio passthough. Any thoughts? 914611 7 208081 pnormand 2013-08-05 10:10:03 -0700 Comment on attachment 208081 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=208081&action=review Do the media tests still pass with that patch? > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:61 > +static float lastVolume = -1.0; Perhaps name this gSavedVolumeValue or so... 914687 8 jonathon 2013-08-05 14:23:39 -0700 (In reply to comment #7) > > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:61 > > +static float lastVolume = -1.0; > > Perhaps name this gSavedVolumeValue or so... This should presumably be a class-level property rather than a file-scope static variable, right? Because we want to ignore the very first volume set for *every* player that's created, not simply for the very first time we set volume on any media player. 914718 9 calvaris 2013-08-05 15:38:49 -0700 (In reply to comment #7) > (From update of attachment 208081 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=208081&action=review > > Do the media tests still pass with that patch? Still have to do it. > > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:61 > > +static float lastVolume = -1.0; > > Perhaps name this gSavedVolumeValue or so... Roger that. 914720 10 calvaris 2013-08-05 15:43:11 -0700 (In reply to comment #8) > This should presumably be a class-level property rather than a file-scope static variable, right? Because we want to ignore the very first volume set for *every* player that's created, not simply for the very first time we set volume on any media player. For class level, do you mean static? I guess so because for non-static I understand object-level. If it's static you get the same behavior that in this case, and if it is not, you always avoid setting the volume for every mplayer that is created, but that's what I tried to prevent, otherwise, I would just ignore the volumes. The idea of keeping them like this is sharing them among the different media players. The problem with making a class property is that it's used in a callback so I'd need to either create a public method to reset it or make the attribute public. I would be ok with any solution regarding this specific part. 914766 11 jonathon 2013-08-05 20:15:27 -0700 (In reply to comment #10) > For class level, do you mean static? I guess so because for non-static I understand object-level. Sorry, ignore this comment. I meant a normal class member (non-static) but I misunderstood the patch slightly when I made that comment. This approach has some issues though. Consider the following case. - You play a video in webkitgtk, the lastVolume variable gets set to e.g. 0.3, which is your current system volume. - Now you browse to a page that has no video player. - While on this page, you change your system volume to 0.6 - Now you go to another page with a video player. When the media player is created, it will set the stream volume for that player to 0.3, because that's our last saved value - I suspect that 99% of people would expect the volume of that player to be 0.6 instead of 0.3 914819 12 calvaris 2013-08-06 03:23:17 -0700 (In reply to comment #11) > This approach has some issues though. Consider the following case. > - You play a video in webkitgtk, the lastVolume variable gets set to e.g. 0.3, which is your current system volume. > - Now you browse to a page that has no video player. > - While on this page, you change your system volume to 0.6 > - Now you go to another page with a video player. When the media player is created, it will set the stream volume for that player to 0.3, because that's our last saved value > - I suspect that 99% of people would expect the volume of that player to be 0.6 instead of 0.3 Yes, that can be indeed a problem of this patch, though I don't know exactly if that could be the expected behavior. From my understanding, W3C standard (I cannot find where I had read it now), says that the default volume is 1, though the user agent can decide to cache the volume. From that you can understand that it is the cached volume or the new one you have set when changing the "system" volume . I write it with " because it's tricky to speak about system volume when dealing with flat volumes and also, from my little understanding of pulse flat volumes, you cannot say that the "system" volume you raise will be the one that you have set from the general volume slider. IIRC it can be either the mean or the max of those volumes, but this is based on my fragile memory so handle with care. Another thing we could do is just avoid setting the volume and trusting the sink, whatever it is. We would remove the nasty global variable (or class or object member) and it would behave reasonably well in every situation. In alsa it would raise to 100% of the stream volume, but it is relative to system one, which is under control and in the case of pulsesink, it would be handled by pulse, so it would select the latest volume, regardless of flat or non-flat volumes. 914863 13 jonathon 2013-08-06 07:19:40 -0700 (In reply to comment #12) > Another thing we could do is just avoid setting the volume and trusting the sink, whatever it is. We would remove the nasty global variable (or class or object member) and it would behave reasonably well in every situation. In alsa it would raise to 100% of the stream volume, but it is relative to system one, which is under control and in the case of pulsesink, it would be handled by pulse, so it would select the latest volume, regardless of flat or non-flat volumes. I personally think that this is probably a better approach and will generally give more expected behavior in most situations. This only applies to setting the volume the first time, of course. After the first one, we should set the volume as requested. That still makes it possible for people to get blasted if a page changes the volume to 1.0 via javascript or something, but that's unavoidable unless we do a much more complicated implementation. 914914 14 208208 calvaris 2013-08-06 11:24:29 -0700 Created attachment 208208 Patch 914916 15 calvaris 2013-08-06 11:36:18 -0700 (In reply to comment #14) > Created an attachment (id=208208) [details] > Patch I reworked the patch in order not to set the volume when creating the pipeline. This breaks media/video-volume.html that expects the volume to be 1.0 when the media player is created. I see three ways of facing this problem: * Removing the first tests, checking for 1.0 from the test and changing all expectations * Setting the volume to 1 at the beginning of the test * Flagging the test (in all affected ports) * Creating expectations about that (in all affected ports) 916183 16 calvaris 2013-08-11 23:40:08 -0700 (In reply to comment #15) > This breaks media/video-volume.html that expects the volume to be 1.0 when the media player is created. I see three ways of facing this problem: It looks like media/video-volume.html test revealed some interesting issues about my patch proposal and it looks like you can be changing the volume of a MediaPlayer prior to having a GStreamer pipeline so somebody could be changing the MediaPlayer volume and we wouldn't be acknowledging the change after the media was loaded, so we need to think of something else. 917051 17 patrakov 2013-08-14 02:32:21 -0700 (In reply to comment #6) > This is a proof of concept, that's why I didn't request the review flag. > > This is a workaround I could think of. The ideas behind it is: > > * Keeping the latest volume used. > * We could just avoid setting the volume when creating the MediaPlayer, but if we reset it like this, the behavior is more coherent when using another sink, like alsa. > * In this case, both pulse with and without flat volumes work the same, the volume is kept from the last used. In the case of alsa, it always begins with 100%, but as it has relative volume to system, it shouldn't be a big deal. > > Alternatives to this workaround: > * Another workaround of checking if we are using flat volume, which would require GStreamer exposing such property. > * Using a volume element that would make us control the whole volume ourselves but we would lose audio passthough. > > Any thoughts? +1 to the second alternative, -1 to the main idea, and actually -1 to any attempt to control the mixer if flat volumes are enabled. IMHO, with flat volumes, the only sensible idea is to use a volume element that provides software-based relative volume control inside webkit (completely invisible to pulseaudio), and ignore (and don't touch) the volume on the sink. Otherwise you'll run into the following problem: * Suppose a desktop environment (e.g. Xfce) that has an OSD program that displays a popup showing the current volume if it changes for any reason. * Suppose a web page that wants to adjust the volume of its own stream * Due, to the change of the stream volume, pulseaudio (according to the flat-volume logic) will change the system volume * An OSD popup appears. That's bad. And also into this problem: * Suppose a web page that provides a user with a volume control, initially at 100%. * Suppose that a user changed that to 80%. * According to the flat volume logic, the system volume is also decreased, say, to 80% of what it was. * Suppose that a user changed the in-web-page volume to 70%. * Now webkit has to virtualize that by setting the stream volume to something. If it sets that to 70% of the initial volume, then the adjustments made between steps 1 and 3 outside of the webapp are effectively ignored. If it is set to 70% of the current system volume, that would be only 56% of the initial volume, i.e. too low. I.e. webkit has to notice that the app changed the volume down by 12.5%, read the current stream volume, and down that by 12.5%. And now we have a problem of special-casing 0%. * That's a rather complex and fragile approach, there will be a problem of understanding this by new developers, and they will break it someday. An explicit software volume element, controlled only by webkit and invisible to pulseaudio is so much easier :) 920616 18 209549 calvaris 2013-08-24 11:19:47 -0700 Created attachment 209549 Patch This is also a proof of concept; I guess something that we could do to improve this would be adding a compilation option to enable this feature (and/or a runtime option) and I also accept suggestions about the name of the variables and methods. The idea is leaving the responsibility of initializing the volume to the HTMLMediaElement. media/video-volume.html test is working now. 921030 19 209549 pnormand 2013-08-26 08:25:35 -0700 Comment on attachment 209549 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=209549&action=review > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:627 > + if (m_player->volumeWasInitialized()) { > + LOG_MEDIA_MESSAGE("Setting stream volume to %f", m_player->volume()); > + g_object_set(m_volumeElement.get(), "volume", m_player->volume(), NULL); I find this a bit confusing, perhaps because of the name of the new method. I'm not great at naming stuff but here's a suggestion: requiresPlatformVolumeConfiguration :) 921162 20 calvaris 2013-08-26 14:33:25 -0700 (In reply to comment #19) > (From update of attachment 209549 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=209549&action=review > > > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:627 > > + if (m_player->volumeWasInitialized()) { > > + LOG_MEDIA_MESSAGE("Setting stream volume to %f", m_player->volume()); > > + g_object_set(m_volumeElement.get(), "volume", m_player->volume(), NULL); > > I find this a bit confusing, perhaps because of the name of the new method. I'm not great at naming stuff but here's a suggestion: requiresPlatformVolumeConfiguration :) Roger that. What about guarding the code with #IFDEFs? As it is now, it should work in all platforms because of the default behavior for the virtual method but maybe the Apple guys don't want that anyway. Phil, Eric, more opinions? 921507 21 209549 eric.carlson 2013-08-27 07:24:57 -0700 Comment on attachment 209549 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=209549&action=review > Source/WebCore/platform/graphics/MediaPlayer.h:217 > + virtual bool mediaPlayerVolumeWasInitialized() const { return true; } Nit: It doesn't matter functionally because HTMLMediaElement overrides this virtual method, but shouldn't the default return be false? >>> Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:627 >>> + g_object_set(m_volumeElement.get(), "volume", m_player->volume(), NULL); >> >> I find this a bit confusing, perhaps because of the name of the new method. I'm not great at naming stuff but here's a suggestion: requiresPlatformVolumeConfiguration :) > > Roger that. > > What about guarding the code with #IFDEFs? As it is now, it should work in all platforms because of the default behavior for the virtual method but maybe the Apple guys don't want that anyway. > > Phil, Eric, more opinions? I don't think it is worth adding another #if for this small bit of code. 923345 22 210212 calvaris 2013-08-31 13:47:37 -0700 Created attachment 210212 Patch Changed method name and added changelog. 923613 23 210212 pnormand 2013-09-02 00:56:28 -0700 Comment on attachment 210212 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=210212&action=review > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:627 > + if (!m_player->platformVolumeConfigurationRequired()) { > + LOG_MEDIA_MESSAGE("Setting stream volume to %f", m_player->volume()); > + g_object_set(m_volumeElement.get(), "volume", m_player->volume(), NULL); This still doesn't make sense to me. If no platform volume configuration is required we set the platform volume? 923617 24 calvaris 2013-09-02 01:20:54 -0700 (In reply to comment #23) > > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:627 > > + if (!m_player->platformVolumeConfigurationRequired()) { > > + LOG_MEDIA_MESSAGE("Setting stream volume to %f", m_player->volume()); > > + g_object_set(m_volumeElement.get(), "volume", m_player->volume(), NULL); > > This still doesn't make sense to me. If no platform volume configuration is required we set the platform volume? Yes, because it it is required, we let the sink decide it for us. If it isn't because it was already reset in upper layers, then we set it to what the upper layer has. 923659 25 patrakov 2013-09-02 05:05:29 -0700 I am neutral to the patch if there is no way to change the kind of volume that the patch deals with from javascript. If there is such way, then I strongly object, on the basis that the volume may be not from user input and 100% would then mean the hardware maximum on some platforms, instead of the "default volume". 923681 26 pnormand 2013-09-02 06:18:48 -0700 (In reply to comment #25) > I am neutral to the patch if there is no way to change the kind of volume that the patch deals with from javascript. > > If there is such way, then I strongly object, on the basis that the volume may be not from user input and 100% would then mean the hardware maximum on some platforms, instead of the "default volume". Quoting the HTML5 spec: "The element's effective media volume is volume, interpreted relative to the range 0.0 to 1.0, with 0.0 being silent, and 1.0 being the loudest setting, values in between increasing in loudness. The range need not be linear. The loudest setting may be lower than the system's loudest possible setting; for example the user could have set a maximum volume." There's no way to change which type of volume is used from javascript because this is a platform-specific aspect that doesn't need to be exposed to the Web. 923689 27 patrakov 2013-09-02 06:51:23 -0700 (In reply to comment #26) > "The element's effective media volume is volume, interpreted relative to the range 0.0 to 1.0, with 0.0 being silent, and 1.0 being the loudest setting, values in between increasing in loudness. The range need not be linear. The loudest setting may be lower than the system's loudest possible setting; for example the user could have set a maximum volume." > > There's no way to change which type of volume is used from javascript because this is a platform-specific aspect that doesn't need to be exposed to the Web. Sorry for wording my comment in such a way that you misinterpreted it. I meant: if there is a way to set the media volume from javascript to a floating-point value (such as 0.99) not based on the user input, then I am strongly against the patch, as it doesn't solve the problem of sudden too-loud sounds at all. The reason is a combination of security and common sense. Even though the spec says that the loudest setting MAY be lower than the system's loudest possible setting, configurable volume limiting is in fact a required feature for protection against malicious javascript. In Windows, this is done by interpreting the volume as being relative to the system mixer - i.e. there is no way for the web page to sound louder than allowed by the system mixer. And I think that there are web pages that rely on such behaviour and assume that setting the volume to 1.0 is safe for the user's hearing. On systems such as pulseaudio with flat volumes this assumption is not true. So you need not only to prevent the initial setting of the volume to 1.0, but also to modify the values that application sets as volumes. And as soon as you start doing that, you are no longer doing a volume passthrough. In fact the whole point of this comment is that it is wrong to do a passthrough if the volume that the application attempts to set may be not based on the user input. I suggest never touching the stream volume in gstreamer, on any platform, as this is provided for user-initiated changes only. Instead, please insert an explicit volume element into the gstreamer pipeline and use it for web media volume changes. Then, even on flat-volume pulseaudio platform, there is no way for a web page to sound louder than the system mixer initially allows. 923879 28 210212 commit-queue 2013-09-03 00:14:58 -0700 Comment on attachment 210212 Patch Clearing flags on attachment: 210212 Committed r154970: <http://trac.webkit.org/changeset/154970> 923880 29 commit-queue 2013-09-03 00:15:02 -0700 All reviewed patches have been landed. Closing bug. 928166 30 patrakov 2013-09-11 23:13:23 -0700 Not fixed. See http://jsfiddle.net/bteam/FbkGD/ (suggested by my colleague) for a testcase that stays on close-to-maximum system volume on PulseAudio with flat volumes. 928237 31 calvaris 2013-09-12 04:06:27 -0700 (In reply to comment #30) > Not fixed. See http://jsfiddle.net/bteam/FbkGD/ (suggested by my colleague) for a testcase that stays on close-to-maximum system volume on PulseAudio with flat volumes. As I can see in that web the volume is intentionally set by the website to 0.99 and 1.0 so we consider that a bug in the webpage. We need to keep WebKit's behavior consistent with the rest of desktop applications using pulseaudio, meaning that if as a consequence of rising the app volume, the system volume is risen too, we shall do the same, even taking into account "buggy" websites. If you want that behavior changed, you should change your flat volume settings in pulseaudio. 928241 32 patrakov 2013-09-12 04:52:28 -0700 (In reply to comment #31) > (In reply to comment #30) > > Not fixed. See http://jsfiddle.net/bteam/FbkGD/ (suggested by my colleague) for a testcase that stays on close-to-maximum system volume on PulseAudio with flat volumes. > > As I can see in that web the volume is intentionally set by the website to 0.99 and 1.0 so we consider that a bug in the webpage. Sorry, I have to disagree here. It is not a bug in the webpage. This webpage is malicious by design. It is a security issue in webkit under Linux/pulseaudio that it obeys to such malicious volume requests literally. The whole security model of pulseaudio is that applications will not make such malicious requests, and it is unreasonable to expect that from web pages directly. So some barrier needs to be there between web application volume requests and pulseaudio. In Windows, or without flat volumes, the security model is that the application-set volume applies as a percentage of the system mixer volume, and thus the 1.0 volume is safe, and even matches the default. I think it would be a big stretch to demand the knowledge that such flat volume environments exist from Windows-only web developers. They just assume that 1.0 means "whatever the system mixer says". > We need to keep WebKit's behavior consistent with the rest of desktop applications using pulseaudio, meaning that if as a consequence of rising the app volume, the system volume is risen too, we shall do the same, even taking into account "buggy" websites. If you want that behavior changed, you should change your flat volume settings in pulseaudio. Two points here. 1. I will take this to pulseaudio developers again. I completely agree that flat volumes are a huge bug in their product, but it is also the default that we have to deal with, for now. If you want to influence that, please come to the audio miniconf at LinuxCon Europe. I will be there, too. 2. Given that flat volumes exist, I disagree with the phrase "We need to keep WebKit's behavior consistent with the rest of desktop applications using pulseaudio", because this would be impossible without the above-mentioned security issue. 928262 33 calvaris 2013-09-12 06:39:28 -0700 (In reply to comment #32) > 1. I will take this to pulseaudio developers again. I completely agree that flat volumes are a huge bug in their product, but it is also the default that we have to deal with, for now. If you want to influence that, please come to the audio miniconf at LinuxCon Europe. I will be there, too. Good, come back then and tell us. Thanks! 930267 34 patrakov 2013-09-17 09:44:44 -0700 After thinking a bit more about this, I changed my mind. Now my opinion is that using the volume on the sink (and not a volume element) is wrong even in the non-flat-volume case. In other words, attempting to squeeze the web content into a model of "behavior consistent with the rest of desktop applications" is an inherently flawed idea. The reason is the same: malicious web pages that change the volume of their audio players without user input. The same test page (trivially amended to also unmute itself) will resist to attempts to make its volume lower than the rest of the applications, or to mute it, even in non-flat-volume case. In non-flat-volume case, though, I would consider it as just a bug ("does not obey the mixer"), not as a security issue. One more consideration is consistency with Adobe Flash and Lightspark players. Flash, by necessity, uses relative volumes (equivalent to the volume element), and Lightspark (which was also affected by a similar bug some time ago) now properly virtualizes the volume changes made by Flash content, using the same relative model inconsistent with desktop applications. In my opinion, consistency with Flash is more important here than consistency with desktop applications. 952052 35 allan.jensen 2013-11-19 06:12:23 -0800 The pulseaudio flat model is broken and stupid by design. It should not be used. Could GStreamer perhaps detect bad pulseaudio configuration and add a relative volume control so that playbin and volum-element has consistant behavior? 1043227 36 eric.carlson 2014-10-21 10:54:06 -0700 This change broke the ability of an application to set a volume multiplier (Page::setMediaVolume). See https://bugs.webkit.org/show_bug.cgi?id=137305. 208081 2013-08-04 00:47:23 -0700 2013-08-06 11:24:24 -0700 Patch bug-118974-20130804094705.patch text/plain 2429 calvaris U3VidmVyc2lvbiBSZXZpc2lvbjogMTUzNjg5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFz ZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvTWVkaWFQ bGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZS5jcHAKaW5kZXggMmEwMmFmYmFiM2ZjZWQwYzIwZjM4 OTlmODM1YzUxNDZjODRiN2Q3OS4uNGJhZjgzZTYwMDE4MjNkNDU1ZjZlY2YzN2Q4OTdiZjRjNGU0 NDc0ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVh bWVyL01lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2UuY3BwCisrKyBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9NZWRpYVBsYXllclByaXZhdGVHU3RyZWFt ZXJCYXNlLmNwcApAQCAtNTgsNiArNTgsOCBAQAogR1NUX0RFQlVHX0NBVEVHT1JZKHdlYmtpdF9t ZWRpYV9wbGF5ZXJfZGVidWcpOwogI2RlZmluZSBHU1RfQ0FUX0RFRkFVTFQgd2Via2l0X21lZGlh X3BsYXllcl9kZWJ1ZwogCitzdGF0aWMgZmxvYXQgbGFzdFZvbHVtZSA9IC0xLjA7CisKIHVzaW5n IG5hbWVzcGFjZSBzdGQ7CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKQEAgLTc2LDYgKzc4LDggQEAg c3RhdGljIGludCBncmVhdGVzdENvbW1vbkRpdmlzb3IoaW50IGEsIGludCBiKQogc3RhdGljIHZv aWQgbWVkaWFQbGF5ZXJQcml2YXRlVm9sdW1lQ2hhbmdlZENhbGxiYWNrKEdPYmplY3QqLCBHUGFy YW1TcGVjKiwgTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZSogcGxheWVyKQogewogICAg IC8vIFRoaXMgaXMgY2FsbGVkIHdoZW4gbV92b2x1bWVFbGVtZW50IHJlY2VpdmVzIHRoZSBub3Rp Znk6OnZvbHVtZSBzaWduYWwuCisgICAgTE9HX01FRElBX01FU1NBR0UoIlZvbHVtZSBjaGFuZ2Vk IHRvOiAlZiIsIHBsYXllci0+dm9sdW1lKCkpOworICAgIGxhc3RWb2x1bWUgPSBwbGF5ZXItPnZv bHVtZSgpOwogICAgIHBsYXllci0+dm9sdW1lQ2hhbmdlZCgpOwogfQogCkBAIC0yMzQsNiArMjM4 LDggQEAgdm9pZCBNZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlOjpzZXRWb2x1bWUoZmxv YXQgdm9sdW1lKQogICAgIGlmICghbV92b2x1bWVFbGVtZW50KQogICAgICAgICByZXR1cm47CiAK KyAgICBMT0dfTUVESUFfTUVTU0FHRSgiU2V0dGluZyB2b2x1bWU6ICVmIiwgdm9sdW1lKTsKKyAg ICBsYXN0Vm9sdW1lID0gdm9sdW1lOwogICAgIGdzdF9zdHJlYW1fdm9sdW1lX3NldF92b2x1bWUo bV92b2x1bWVFbGVtZW50LmdldCgpLCBHU1RfU1RSRUFNX1ZPTFVNRV9GT1JNQVRfQ1VCSUMsIHN0 YXRpY19jYXN0PGRvdWJsZT4odm9sdW1lKSk7CiB9CiAKQEAgLTYxOCw3ICs2MjQsMTUgQEAgdm9p ZCBNZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlOjpzZXRTdHJlYW1Wb2x1bWVFbGVtZW50 KEdzdFN0cmVhbVZvbHVtZSogdm8KICAgICBBU1NFUlQoIW1fdm9sdW1lRWxlbWVudCk7CiAgICAg bV92b2x1bWVFbGVtZW50ID0gdm9sdW1lOwogCi0gICAgZ19vYmplY3Rfc2V0KG1fdm9sdW1lRWxl bWVudC5nZXQoKSwgIm11dGUiLCBtX3BsYXllci0+bXV0ZWQoKSwgInZvbHVtZSIsIG1fcGxheWVy LT52b2x1bWUoKSwgTlVMTCk7CisgICAgaWYgKGxhc3RWb2x1bWUgPj0gMC4wKSB7CisgICAgICAg IExPR19NRURJQV9NRVNTQUdFKCJTZXR0aW5nIHN0cmVhbSB2b2x1bWU6ICVsZiIsIGxhc3RWb2x1 bWUpOworICAgICAgICBnc3Rfc3RyZWFtX3ZvbHVtZV9zZXRfdm9sdW1lKG1fdm9sdW1lRWxlbWVu dC5nZXQoKSwgR1NUX1NUUkVBTV9WT0xVTUVfRk9STUFUX0NVQklDLCBzdGF0aWNfY2FzdDxkb3Vi bGU+KGxhc3RWb2x1bWUpKTsKKyAgICB9IGVsc2UKKyAgICAgICAgTE9HX01FRElBX01FU1NBR0Uo Ik5vdCBzZXR0aW5nIHN0cmVhbSB2b2x1bWUsIHRydXN0aW5nIHN5c3RlbSBvbmUiKTsKKworICAg IExPR19NRURJQV9NRVNTQUdFKCJTZXR0aW5nIHN0cmVhbSBtdXRlZCAlZCIsICBtX3BsYXllci0+ bXV0ZWQoKSk7CisgICAgZ19vYmplY3Rfc2V0KG1fdm9sdW1lRWxlbWVudC5nZXQoKSwgIm11dGUi LCBtX3BsYXllci0+bXV0ZWQoKSwgTlVMTCk7CisKIAogICAgIG1fdm9sdW1lU2lnbmFsSGFuZGxl ciA9IGdfc2lnbmFsX2Nvbm5lY3QobV92b2x1bWVFbGVtZW50LmdldCgpLCAibm90aWZ5Ojp2b2x1 bWUiLCBHX0NBTExCQUNLKG1lZGlhUGxheWVyUHJpdmF0ZVZvbHVtZUNoYW5nZWRDYWxsYmFjayks IHRoaXMpOwogICAgIG1fbXV0ZVNpZ25hbEhhbmRsZXIgPSBnX3NpZ25hbF9jb25uZWN0KG1fdm9s dW1lRWxlbWVudC5nZXQoKSwgIm5vdGlmeTo6bXV0ZSIsIEdfQ0FMTEJBQ0sobWVkaWFQbGF5ZXJQ cml2YXRlTXV0ZUNoYW5nZWRDYWxsYmFjayksIHRoaXMpOwo= 208208 2013-08-06 11:24:29 -0700 2013-08-24 11:19:29 -0700 Patch bug-118974-20130806202427.patch text/plain 2089 calvaris U3VidmVyc2lvbiBSZXZpc2lvbjogMTUzNzUzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFz ZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvTWVkaWFQ bGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZS5jcHAKaW5kZXggNTQyZGNmZWQ0OWE5MWIwNDYyNjY4 YTk1OTlkZTU0YTU5NGQ4NzI2NC4uNjNlYjYyMTllMjdmYzgyYzQ4YjA4NGFmYjg5OWVmNTVlZTQ3 ZDc4OSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVh bWVyL01lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2UuY3BwCisrKyBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9NZWRpYVBsYXllclByaXZhdGVHU3RyZWFt ZXJCYXNlLmNwcApAQCAtNzYsNiArNzYsNyBAQCBzdGF0aWMgaW50IGdyZWF0ZXN0Q29tbW9uRGl2 aXNvcihpbnQgYSwgaW50IGIpCiBzdGF0aWMgdm9pZCBtZWRpYVBsYXllclByaXZhdGVWb2x1bWVD aGFuZ2VkQ2FsbGJhY2soR09iamVjdCosIEdQYXJhbVNwZWMqLCBNZWRpYVBsYXllclByaXZhdGVH U3RyZWFtZXJCYXNlKiBwbGF5ZXIpCiB7CiAgICAgLy8gVGhpcyBpcyBjYWxsZWQgd2hlbiBtX3Zv bHVtZUVsZW1lbnQgcmVjZWl2ZXMgdGhlIG5vdGlmeTo6dm9sdW1lIHNpZ25hbC4KKyAgICBMT0df TUVESUFfTUVTU0FHRSgiVm9sdW1lIGNoYW5nZWQgdG86ICVmIiwgcGxheWVyLT52b2x1bWUoKSk7 CiAgICAgcGxheWVyLT52b2x1bWVDaGFuZ2VkKCk7CiB9CiAKQEAgLTIzNCw2ICsyMzUsNyBAQCB2 b2lkIE1lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2U6OnNldFZvbHVtZShmbG9hdCB2b2x1 bWUpCiAgICAgaWYgKCFtX3ZvbHVtZUVsZW1lbnQpCiAgICAgICAgIHJldHVybjsKIAorICAgIExP R19NRURJQV9NRVNTQUdFKCJTZXR0aW5nIHZvbHVtZTogJWYiLCB2b2x1bWUpOwogICAgIGdzdF9z dHJlYW1fdm9sdW1lX3NldF92b2x1bWUobV92b2x1bWVFbGVtZW50LmdldCgpLCBHU1RfU1RSRUFN X1ZPTFVNRV9GT1JNQVRfQ1VCSUMsIHN0YXRpY19jYXN0PGRvdWJsZT4odm9sdW1lKSk7CiB9CiAK QEAgLTYxOCw3ICs2MjAsMTIgQEAgdm9pZCBNZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNl OjpzZXRTdHJlYW1Wb2x1bWVFbGVtZW50KEdzdFN0cmVhbVZvbHVtZSogdm8KICAgICBBU1NFUlQo IW1fdm9sdW1lRWxlbWVudCk7CiAgICAgbV92b2x1bWVFbGVtZW50ID0gdm9sdW1lOwogCi0gICAg Z19vYmplY3Rfc2V0KG1fdm9sdW1lRWxlbWVudC5nZXQoKSwgIm11dGUiLCBtX3BsYXllci0+bXV0 ZWQoKSwgInZvbHVtZSIsIG1fcGxheWVyLT52b2x1bWUoKSwgTlVMTCk7CisgICAgLy8gV2UgZG9u J3Qgc2V0IHRoZSBpbml0aWFsIHZvbHVtZSBiZWNhdXNlIHdlIHRydXN0IHRoZSBzaW5rIHRvIGtl ZXAgaXQgZm9yIHVzLiBTZWUKKyAgICAvLyBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MTE4OTc0IGZvciBtb3JlIGluZm9ybWF0aW9uLgorICAgIExPR19NRURJQV9NRVNT QUdFKCJOb3Qgc2V0dGluZyBzdHJlYW0gdm9sdW1lLCB0cnVzdGluZyBzeXN0ZW0gb25lIik7CisK KyAgICBMT0dfTUVESUFfTUVTU0FHRSgiU2V0dGluZyBzdHJlYW0gbXV0ZWQgJWQiLCAgbV9wbGF5 ZXItPm11dGVkKCkpOworICAgIGdfb2JqZWN0X3NldChtX3ZvbHVtZUVsZW1lbnQuZ2V0KCksICJt dXRlIiwgbV9wbGF5ZXItPm11dGVkKCksIE5VTEwpOwogCiAgICAgbV92b2x1bWVTaWduYWxIYW5k bGVyID0gZ19zaWduYWxfY29ubmVjdChtX3ZvbHVtZUVsZW1lbnQuZ2V0KCksICJub3RpZnk6OnZv bHVtZSIsIEdfQ0FMTEJBQ0sobWVkaWFQbGF5ZXJQcml2YXRlVm9sdW1lQ2hhbmdlZENhbGxiYWNr KSwgdGhpcyk7CiAgICAgbV9tdXRlU2lnbmFsSGFuZGxlciA9IGdfc2lnbmFsX2Nvbm5lY3QobV92 b2x1bWVFbGVtZW50LmdldCgpLCAibm90aWZ5OjptdXRlIiwgR19DQUxMQkFDSyhtZWRpYVBsYXll clByaXZhdGVNdXRlQ2hhbmdlZENhbGxiYWNrKSwgdGhpcyk7Cg== 209549 2013-08-24 11:19:47 -0700 2013-08-31 13:47:31 -0700 Patch bug-118974-20130824201944.patch text/plain 5675 calvaris U3VidmVyc2lvbiBSZXZpc2lvbjogMTU0NDM3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9o dG1sL0hUTUxNZWRpYUVsZW1lbnQuY3BwIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MTWVkaWFF bGVtZW50LmNwcAppbmRleCA3MTI2MDA1ZGRiODgxOGE2OTA3ZWJmNmI1ZDY2YWEzZDJlYzJlM2E2 Li4xNDlmNzY5MGUwYjhhOTI0OGNkOTljYTZhYmEwYzU0OGIzY2U2NTZkIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9odG1sL0hUTUxNZWRpYUVsZW1lbnQuY3BwCisrKyBiL1NvdXJjZS9XZWJD b3JlL2h0bWwvSFRNTE1lZGlhRWxlbWVudC5jcHAKQEAgLTI2NCw2ICsyNjQsNyBAQCBIVE1MTWVk aWFFbGVtZW50OjpIVE1MTWVkaWFFbGVtZW50KGNvbnN0IFF1YWxpZmllZE5hbWUmIHRhZ05hbWUs IERvY3VtZW50KiBkb2N1bQogICAgICwgbV9yZWFkeVN0YXRlKEhBVkVfTk9USElORykKICAgICAs IG1fcmVhZHlTdGF0ZU1heGltdW0oSEFWRV9OT1RISU5HKQogICAgICwgbV92b2x1bWUoMS4wZikK KyAgICAsIG1fdm9sdW1lSW5pdGlhbGl6ZWQoZmFsc2UpCiAgICAgLCBtX2xhc3RTZWVrVGltZSgw KQogICAgICwgbV9wcmV2aW91c1Byb2dyZXNzVGltZShudW1lcmljX2xpbWl0czxkb3VibGU+Ojpt YXgoKSkKICAgICAsIG1fY2xvY2tUaW1lQXRMYXN0VXBkYXRlRXZlbnQoMCkKQEAgLTI3MTUsNiAr MjcxNiw3IEBAIHZvaWQgSFRNTE1lZGlhRWxlbWVudDo6c2V0Vm9sdW1lKGRvdWJsZSB2b2wsIEV4 Y2VwdGlvbkNvZGUmIGVjKQogICAgIAogICAgIGlmIChtX3ZvbHVtZSAhPSB2b2wpIHsKICAgICAg ICAgbV92b2x1bWUgPSB2b2w7CisgICAgICAgIG1fdm9sdW1lSW5pdGlhbGl6ZWQgPSB0cnVlOwog ICAgICAgICB1cGRhdGVWb2x1bWUoKTsKICAgICAgICAgc2NoZWR1bGVFdmVudChldmVudE5hbWVz KCkudm9sdW1lY2hhbmdlRXZlbnQpOwogICAgIH0KQEAgLTM5NzksNyArMzk4MSw4IEBAIHZvaWQg SFRNTE1lZGlhRWxlbWVudDo6dXBkYXRlVm9sdW1lKCkKICAgICAgICAgfQogCiAgICAgICAgIG1f cGxheWVyLT5zZXRNdXRlZChzaG91bGRNdXRlKTsKLSAgICAgICAgbV9wbGF5ZXItPnNldFZvbHVt ZShtX3ZvbHVtZSAqIHZvbHVtZU11bHRpcGxpZXIpOworICAgICAgICBpZiAobV92b2x1bWVJbml0 aWFsaXplZCkKKyAgICAgICAgICAgIG1fcGxheWVyLT5zZXRWb2x1bWUobV92b2x1bWUgKiB2b2x1 bWVNdWx0aXBsaWVyKTsKICAgICB9CiAKICAgICBpZiAoaGFzTWVkaWFDb250cm9scygpKQpAQCAt NTA3OSw2ICs1MDgyLDExIEBAIHZvaWQgSFRNTE1lZGlhRWxlbWVudDo6bWVkaWFQbGF5ZXJQbGF5 KCkKICAgICBwbGF5KCk7CiB9CiAKK2Jvb2wgSFRNTE1lZGlhRWxlbWVudDo6bWVkaWFQbGF5ZXJW b2x1bWVXYXNJbml0aWFsaXplZCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIG1fdm9sdW1lSW5pdGlh bGl6ZWQ7Cit9CisKIGJvb2wgSFRNTE1lZGlhRWxlbWVudDo6bWVkaWFQbGF5ZXJJc1BhdXNlZCgp IGNvbnN0CiB7CiAgICAgcmV0dXJuIHBhdXNlZCgpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvaHRtbC9IVE1MTWVkaWFFbGVtZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxNZWRp YUVsZW1lbnQuaAppbmRleCA4NTk3ZmIyZGQ0ZTc4MGVhMWI2ZGFmZGI1NGQ5NzUzMWI2YjJkM2Fk Li5hZDczM2E1OTFhMGMwYWYzNmY4ZmUzZTk1ZjYwZGUyYzFmMjQ4ZDI4IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9odG1sL0hUTUxNZWRpYUVsZW1lbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9odG1sL0hUTUxNZWRpYUVsZW1lbnQuaApAQCAtNTA2LDYgKzUwNiw3IEBAIHByaXZhdGU6CiAg ICAgdmlydHVhbCB2b2lkIG1lZGlhUGxheWVyU2V0U2l6ZShjb25zdCBJbnRTaXplJikgT1ZFUlJJ REU7CiAgICAgdmlydHVhbCB2b2lkIG1lZGlhUGxheWVyUGF1c2UoKSBPVkVSUklERTsKICAgICB2 aXJ0dWFsIHZvaWQgbWVkaWFQbGF5ZXJQbGF5KCkgT1ZFUlJJREU7CisgICAgdmlydHVhbCBib29s IG1lZGlhUGxheWVyVm9sdW1lV2FzSW5pdGlhbGl6ZWQoKSBjb25zdCBPVkVSUklERTsKICAgICB2 aXJ0dWFsIGJvb2wgbWVkaWFQbGF5ZXJJc1BhdXNlZCgpIGNvbnN0IE9WRVJSSURFOwogICAgIHZp cnR1YWwgYm9vbCBtZWRpYVBsYXllcklzTG9vcGluZygpIGNvbnN0IE9WRVJSSURFOwogICAgIHZp cnR1YWwgSG9zdFdpbmRvdyogbWVkaWFQbGF5ZXJIb3N0V2luZG93KCkgT1ZFUlJJREU7CkBAIC02 MzcsNiArNjM4LDcgQEAgcHJpdmF0ZToKICAgICBSZWZQdHI8TWVkaWFFcnJvcj4gbV9lcnJvcjsK IAogICAgIGRvdWJsZSBtX3ZvbHVtZTsKKyAgICBib29sIG1fdm9sdW1lSW5pdGlhbGl6ZWQ7CiAg ICAgZG91YmxlIG1fbGFzdFNlZWtUaW1lOwogICAgIAogICAgIHVuc2lnbmVkIG1fcHJldmlvdXNQ cm9ncmVzczsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL01l ZGlhUGxheWVyLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9NZWRpYVBsYXll ci5oCmluZGV4IGIyNGFiNGFmMTcxMTMwMjc4MmQwODg0N2FiOWU3YTFlZjE3MDZmYjQuLjMxNTI1 ZjU4NDgxZjhiZjIzNTcyYTdmNWE3NWY1MWUwNzczZGYzZGIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL01lZGlhUGxheWVyLmgKKysrIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvTWVkaWFQbGF5ZXIuaApAQCAtMjE0LDYgKzIxNCw3IEBAIHB1 YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgbWVkaWFQbGF5ZXJTZXRTaXplKGNvbnN0IEludFNpemUm KSB7IH0KICAgICB2aXJ0dWFsIHZvaWQgbWVkaWFQbGF5ZXJQYXVzZSgpIHsgfQogICAgIHZpcnR1 YWwgdm9pZCBtZWRpYVBsYXllclBsYXkoKSB7IH0KKyAgICB2aXJ0dWFsIGJvb2wgbWVkaWFQbGF5 ZXJWb2x1bWVXYXNJbml0aWFsaXplZCgpIGNvbnN0IHsgcmV0dXJuIHRydWU7IH0KICAgICB2aXJ0 dWFsIGJvb2wgbWVkaWFQbGF5ZXJJc1BhdXNlZCgpIGNvbnN0IHsgcmV0dXJuIHRydWU7IH0KICAg ICB2aXJ0dWFsIGJvb2wgbWVkaWFQbGF5ZXJJc0xvb3BpbmcoKSBjb25zdCB7IHJldHVybiBmYWxz ZTsgfQogICAgIHZpcnR1YWwgSG9zdFdpbmRvdyogbWVkaWFQbGF5ZXJIb3N0V2luZG93KCkgeyBy ZXR1cm4gMDsgfQpAQCAtMzI4LDYgKzMyOSw3IEBAIHB1YmxpYzoKIAogICAgIGRvdWJsZSB2b2x1 bWUoKSBjb25zdDsKICAgICB2b2lkIHNldFZvbHVtZShkb3VibGUpOworICAgIGJvb2wgdm9sdW1l V2FzSW5pdGlhbGl6ZWQoKSBjb25zdCB7IHJldHVybiBtX21lZGlhUGxheWVyQ2xpZW50LT5tZWRp YVBsYXllclZvbHVtZVdhc0luaXRpYWxpemVkKCk7IH0KIAogICAgIGJvb2wgbXV0ZWQoKSBjb25z dDsKICAgICB2b2lkIHNldE11dGVkKGJvb2wpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL01lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJh c2UuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL01lZGlh UGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2UuY3BwCmluZGV4IGQ5ZDRiYTZlMzA5OTA3MThmNDg0 OTBiZjMzZjA4Y2I4YmI5ZmUyNDcuLjU3OGJmOWFhZjA2MzhhMGRiZGY0Y2Y3NjcyOTI3MmRjNjQy NTU1NTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJl YW1lci9NZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlLmNwcAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVh bWVyQmFzZS5jcHAKQEAgLTc2LDYgKzc2LDcgQEAgc3RhdGljIGludCBncmVhdGVzdENvbW1vbkRp dmlzb3IoaW50IGEsIGludCBiKQogc3RhdGljIHZvaWQgbWVkaWFQbGF5ZXJQcml2YXRlVm9sdW1l Q2hhbmdlZENhbGxiYWNrKEdPYmplY3QqLCBHUGFyYW1TcGVjKiwgTWVkaWFQbGF5ZXJQcml2YXRl R1N0cmVhbWVyQmFzZSogcGxheWVyKQogewogICAgIC8vIFRoaXMgaXMgY2FsbGVkIHdoZW4gbV92 b2x1bWVFbGVtZW50IHJlY2VpdmVzIHRoZSBub3RpZnk6OnZvbHVtZSBzaWduYWwuCisgICAgTE9H X01FRElBX01FU1NBR0UoIlZvbHVtZSBjaGFuZ2VkIHRvOiAlZiIsIHBsYXllci0+dm9sdW1lKCkp OwogICAgIHBsYXllci0+dm9sdW1lQ2hhbmdlZCgpOwogfQogCkBAIC0yMzQsNiArMjM1LDcgQEAg dm9pZCBNZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlOjpzZXRWb2x1bWUoZmxvYXQgdm9s dW1lKQogICAgIGlmICghbV92b2x1bWVFbGVtZW50KQogICAgICAgICByZXR1cm47CiAKKyAgICBM T0dfTUVESUFfTUVTU0FHRSgiU2V0dGluZyB2b2x1bWU6ICVmIiwgdm9sdW1lKTsKICAgICBnc3Rf c3RyZWFtX3ZvbHVtZV9zZXRfdm9sdW1lKG1fdm9sdW1lRWxlbWVudC5nZXQoKSwgR1NUX1NUUkVB TV9WT0xVTUVfRk9STUFUX0NVQklDLCBzdGF0aWNfY2FzdDxkb3VibGU+KHZvbHVtZSkpOwogfQog CkBAIC02MTgsNyArNjIwLDE2IEBAIHZvaWQgTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFz ZTo6c2V0U3RyZWFtVm9sdW1lRWxlbWVudChHc3RTdHJlYW1Wb2x1bWUqIHZvCiAgICAgQVNTRVJU KCFtX3ZvbHVtZUVsZW1lbnQpOwogICAgIG1fdm9sdW1lRWxlbWVudCA9IHZvbHVtZTsKIAotICAg IGdfb2JqZWN0X3NldChtX3ZvbHVtZUVsZW1lbnQuZ2V0KCksICJtdXRlIiwgbV9wbGF5ZXItPm11 dGVkKCksICJ2b2x1bWUiLCBtX3BsYXllci0+dm9sdW1lKCksIE5VTEwpOworICAgIC8vIFdlIGRv bid0IHNldCB0aGUgaW5pdGlhbCB2b2x1bWUgYmVjYXVzZSB3ZSB0cnVzdCB0aGUgc2luayB0byBr ZWVwIGl0IGZvciB1cy4gU2VlCisgICAgLy8gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTExODk3NCBmb3IgbW9yZSBpbmZvcm1hdGlvbi4KKyAgICBpZiAobV9wbGF5ZXIt PnZvbHVtZVdhc0luaXRpYWxpemVkKCkpIHsKKyAgICAgICAgTE9HX01FRElBX01FU1NBR0UoIlNl dHRpbmcgc3RyZWFtIHZvbHVtZSB0byAlZiIsIG1fcGxheWVyLT52b2x1bWUoKSk7CisgICAgICAg IGdfb2JqZWN0X3NldChtX3ZvbHVtZUVsZW1lbnQuZ2V0KCksICJ2b2x1bWUiLCBtX3BsYXllci0+ dm9sdW1lKCksIE5VTEwpOworICAgIH0gZWxzZQorICAgICAgICBMT0dfTUVESUFfTUVTU0FHRSgi Tm90IHNldHRpbmcgc3RyZWFtIHZvbHVtZSwgdHJ1c3Rpbmcgc3lzdGVtIG9uZSIpOworCisgICAg TE9HX01FRElBX01FU1NBR0UoIlNldHRpbmcgc3RyZWFtIG11dGVkICVkIiwgIG1fcGxheWVyLT5t dXRlZCgpKTsKKyAgICBnX29iamVjdF9zZXQobV92b2x1bWVFbGVtZW50LmdldCgpLCAibXV0ZSIs IG1fcGxheWVyLT5tdXRlZCgpLCBOVUxMKTsKIAogICAgIG1fdm9sdW1lU2lnbmFsSGFuZGxlciA9 IGdfc2lnbmFsX2Nvbm5lY3QobV92b2x1bWVFbGVtZW50LmdldCgpLCAibm90aWZ5Ojp2b2x1bWUi LCBHX0NBTExCQUNLKG1lZGlhUGxheWVyUHJpdmF0ZVZvbHVtZUNoYW5nZWRDYWxsYmFjayksIHRo aXMpOwogICAgIG1fbXV0ZVNpZ25hbEhhbmRsZXIgPSBnX3NpZ25hbF9jb25uZWN0KG1fdm9sdW1l RWxlbWVudC5nZXQoKSwgIm5vdGlmeTo6bXV0ZSIsIEdfQ0FMTEJBQ0sobWVkaWFQbGF5ZXJQcml2 YXRlTXV0ZUNoYW5nZWRDYWxsYmFjayksIHRoaXMpOwo= 210212 2013-08-31 13:47:37 -0700 2013-09-03 00:14:58 -0700 Patch bug-118974-20130831224735.patch text/plain 8021 calvaris U3VidmVyc2lvbiBSZXZpc2lvbjogMTU0ODA1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMDBkNGJkODU5MTlhYWQ0 NDg3MzdkYmJhNmIzNGQ0Mzg3MTFjZTAwYS4uYWU1MGJkYzAyM2Y0MGIwNGNhYTM2Y2Q5M2UxYjBl YTAzNjY3OTFhOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM4IEBACisyMDEzLTA4LTMxICBYYWJp ZXIgUm9kcmlndWV6IENhbHZhciAgPGNhbHZhcmlzQGlnYWxpYS5jb20+CisKKyAgICAgICAgW0dT dHJlYW1lcl0gVmlkZW8gcGxheWVyIHNldHMgc3lzdGVtIHZvbHVtZSB0byAxMDAlCisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMTg5NzQKKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBJbiBvcmRlciB0byBwcmVz ZXJ2ZSB0aGUgc3lzdGVtIHZvbHVtZSB3ZSBuZWVkIHRvIGtlZXAgdHJhY2sgb2YKKyAgICAgICAg dGhlIHZvbHVtZSBiZWluZyBpbml0aWFsaXplZCBpbiB0aGUgSFRNTE1lZGlhRWxlbWVudCBhbmQg dGhlbiBqdXN0CisgICAgICAgIHNldHRpbmcgdGhlIHZvbHVtZSB0byB0aGUgc2luayB3aGVuIGlu aXRpYWxpemluZyB0aGUgcGlwZWxpbmUgaWYKKyAgICAgICAgdGhhdCB2b2x1bWUgd2FzIGNoYW5n ZWQgYmVmb3JlLgorCisgICAgICAgICogaHRtbC9IVE1MTWVkaWFFbGVtZW50LmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OkhUTUxNZWRpYUVsZW1lbnQ6OkhUTUxNZWRpYUVsZW1lbnQpOiBJbml0aWFs aXplZAorICAgICAgICBhdHRyaWJ1dGUgdG8gZmFsc2UuCisgICAgICAgIChXZWJDb3JlOjpIVE1M TWVkaWFFbGVtZW50OjpzZXRWb2x1bWUpOiBTZXQgdGhlIGF0dHJpYnV0ZSB0byB0cnVlCisgICAg ICAgIHdoZW4gdm9sdW1lIGlzIGNoYW5nZWQuCisgICAgICAgIChXZWJDb3JlOjpIVE1MTWVkaWFF bGVtZW50Ojp1cGRhdGVWb2x1bWUpOiBTZXQgdGhlIHZvbHVtZSBvbmx5IGlmCisgICAgICAgIHZv bHVtZSB3YXMgaW5pdGlhbGl6ZWQuCisgICAgICAgIChXZWJDb3JlOjpIVE1MTWVkaWFFbGVtZW50 OjptZWRpYVBsYXllclBsYXRmb3JtVm9sdW1lQ29uZmlndXJhdGlvblJlcXVpcmVkKToKKyAgICAg ICAgUGxhdGZvcm0gdm9sdW1lIGNvbmZpZ3VyYXRpb24gaXMgcmVxdWlyZWQgb25seSBpZiB2b2x1 bWUgd2FzIG5vdAorICAgICAgICBpbml0aWFsaXplZCBiZWZvcmUuCisgICAgICAgICogaHRtbC9I VE1MTWVkaWFFbGVtZW50Lmg6IEFkZGVkIGF0dHJpYnV0ZSBhbmQgaW50ZXJmYWNlIG1ldGhvZC4K KyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9NZWRpYVBsYXllci5oOgorICAgICAgICAoV2Vi Q29yZTo6TWVkaWFQbGF5ZXJDbGllbnQ6Om1lZGlhUGxheWVyUGxhdGZvcm1Wb2x1bWVDb25maWd1 cmF0aW9uUmVxdWlyZWQpOgorICAgICAgICBEZWNsYXJlZCBhbmQgYWRkZWQgZGVmYXVsdCBpbXBs ZW1lbnRhdGlvbiBmb3IgdGhlIGludGVyZmFjZSBtZXRob2QuCisgICAgICAgIChXZWJDb3JlOjpN ZWRpYVBsYXllcjo6cGxhdGZvcm1Wb2x1bWVDb25maWd1cmF0aW9uUmVxdWlyZWQpOgorICAgICAg ICBBc2tlZCB0aGUgY2xpZW50LCBtZWFuaW5nIHRoZSBIVE1MTWVkaWFFbGVtZW50IGlmIHRoZSBw bGF0Zm9ybQorICAgICAgICB2b2x1bWUgY29uZmlndXJhdGlvbiBpcyByZXF1aXJlZC4KKyAgICAg ICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVh bWVyQmFzZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjptZWRpYVBsYXllclByaXZhdGVWb2x1bWVD aGFuZ2VkQ2FsbGJhY2spOiBBZGRlZCBsb2cuCisgICAgICAgIChXZWJDb3JlOjpNZWRpYVBsYXll clByaXZhdGVHU3RyZWFtZXJCYXNlOjpzZXRWb2x1bWUpOiBBZGRlZCBsb2cuCisgICAgICAgIChX ZWJDb3JlOjpNZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlOjpzZXRTdHJlYW1Wb2x1bWVF bGVtZW50KToKKyAgICAgICAgU2V0IHRoZSB2b2x1bWUgb25seSBpZiBub3QgcGxhdGZvcm0gdm9s dW1lIGlzIHJlcXVpcmVkIGFuZCBhZGRlZCBsb2cuCisKIDIwMTMtMDgtMjggIENocmlzIEZsZWl6 YWNoICA8Y2ZsZWl6YWNoQGFwcGxlLmNvbT4KIAogICAgICAgICBBWDogV2ViUHJvY2VzcyBhdCBj b20uYXBwbGUuV2ViQ29yZTogV2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6cm9vdE9iamVjdCArIDI3 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxNZWRpYUVsZW1lbnQuY3BwIGIv U291cmNlL1dlYkNvcmUvaHRtbC9IVE1MTWVkaWFFbGVtZW50LmNwcAppbmRleCAxZDE0YmVhNWNl NDNhMWNmYWM1NzBkYTA0NDlmNzU5MTNmMDQ5YzVjLi4yZTJkN2IzMWJiYzUyMWVkMGVjYTVkZWI4 NWUxOTMyOWJhNWQwOTFmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxNZWRp YUVsZW1lbnQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTE1lZGlhRWxlbWVudC5j cHAKQEAgLTI2NSw2ICsyNjUsNyBAQCBIVE1MTWVkaWFFbGVtZW50OjpIVE1MTWVkaWFFbGVtZW50 KGNvbnN0IFF1YWxpZmllZE5hbWUmIHRhZ05hbWUsIERvY3VtZW50KiBkb2N1bQogICAgICwgbV9y ZWFkeVN0YXRlKEhBVkVfTk9USElORykKICAgICAsIG1fcmVhZHlTdGF0ZU1heGltdW0oSEFWRV9O T1RISU5HKQogICAgICwgbV92b2x1bWUoMS4wZikKKyAgICAsIG1fdm9sdW1lSW5pdGlhbGl6ZWQo ZmFsc2UpCiAgICAgLCBtX2xhc3RTZWVrVGltZSgwKQogICAgICwgbV9wcmV2aW91c1Byb2dyZXNz VGltZShudW1lcmljX2xpbWl0czxkb3VibGU+OjptYXgoKSkKICAgICAsIG1fY2xvY2tUaW1lQXRM YXN0VXBkYXRlRXZlbnQoMCkKQEAgLTI3MDYsNiArMjcwNyw3IEBAIHZvaWQgSFRNTE1lZGlhRWxl bWVudDo6c2V0Vm9sdW1lKGRvdWJsZSB2b2wsIEV4Y2VwdGlvbkNvZGUmIGVjKQogICAgIAogICAg IGlmIChtX3ZvbHVtZSAhPSB2b2wpIHsKICAgICAgICAgbV92b2x1bWUgPSB2b2w7CisgICAgICAg IG1fdm9sdW1lSW5pdGlhbGl6ZWQgPSB0cnVlOwogICAgICAgICB1cGRhdGVWb2x1bWUoKTsKICAg ICAgICAgc2NoZWR1bGVFdmVudChldmVudE5hbWVzKCkudm9sdW1lY2hhbmdlRXZlbnQpOwogICAg IH0KQEAgLTM5NzYsNyArMzk3OCw4IEBAIHZvaWQgSFRNTE1lZGlhRWxlbWVudDo6dXBkYXRlVm9s dW1lKCkKICAgICAgICAgfQogCiAgICAgICAgIG1fcGxheWVyLT5zZXRNdXRlZChzaG91bGRNdXRl KTsKLSAgICAgICAgbV9wbGF5ZXItPnNldFZvbHVtZShtX3ZvbHVtZSAqIHZvbHVtZU11bHRpcGxp ZXIpOworICAgICAgICBpZiAobV92b2x1bWVJbml0aWFsaXplZCkKKyAgICAgICAgICAgIG1fcGxh eWVyLT5zZXRWb2x1bWUobV92b2x1bWUgKiB2b2x1bWVNdWx0aXBsaWVyKTsKICAgICB9CiAKICAg ICBpZiAoaGFzTWVkaWFDb250cm9scygpKQpAQCAtNTA3OSw2ICs1MDgyLDExIEBAIHZvaWQgSFRN TE1lZGlhRWxlbWVudDo6bWVkaWFQbGF5ZXJQbGF5KCkKICAgICBwbGF5KCk7CiB9CiAKK2Jvb2wg SFRNTE1lZGlhRWxlbWVudDo6bWVkaWFQbGF5ZXJQbGF0Zm9ybVZvbHVtZUNvbmZpZ3VyYXRpb25S ZXF1aXJlZCgpIGNvbnN0Cit7CisgICAgcmV0dXJuICFtX3ZvbHVtZUluaXRpYWxpemVkOworfQor CiBib29sIEhUTUxNZWRpYUVsZW1lbnQ6Om1lZGlhUGxheWVySXNQYXVzZWQoKSBjb25zdAogewog ICAgIHJldHVybiBwYXVzZWQoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRN TE1lZGlhRWxlbWVudC5oIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MTWVkaWFFbGVtZW50LmgK aW5kZXggMGQyMGQ0ZThlNDlmOGE0MTQxNzliZDk3MTQ3ZWVjYjg4NDg3MmY2Ny4uMDYxN2U0ZTgz NTM1Y2I2NzE0OWM3OTE5YTBlYjZlM2JkYzE5YWJkZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvaHRtbC9IVE1MTWVkaWFFbGVtZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1M TWVkaWFFbGVtZW50LmgKQEAgLTUwNyw2ICs1MDcsNyBAQCBwcml2YXRlOgogICAgIHZpcnR1YWwg dm9pZCBtZWRpYVBsYXllclNldFNpemUoY29uc3QgSW50U2l6ZSYpIE9WRVJSSURFOwogICAgIHZp cnR1YWwgdm9pZCBtZWRpYVBsYXllclBhdXNlKCkgT1ZFUlJJREU7CiAgICAgdmlydHVhbCB2b2lk IG1lZGlhUGxheWVyUGxheSgpIE9WRVJSSURFOworICAgIHZpcnR1YWwgYm9vbCBtZWRpYVBsYXll clBsYXRmb3JtVm9sdW1lQ29uZmlndXJhdGlvblJlcXVpcmVkKCkgY29uc3QgT1ZFUlJJREU7CiAg ICAgdmlydHVhbCBib29sIG1lZGlhUGxheWVySXNQYXVzZWQoKSBjb25zdCBPVkVSUklERTsKICAg ICB2aXJ0dWFsIGJvb2wgbWVkaWFQbGF5ZXJJc0xvb3BpbmcoKSBjb25zdCBPVkVSUklERTsKICAg ICB2aXJ0dWFsIEhvc3RXaW5kb3cqIG1lZGlhUGxheWVySG9zdFdpbmRvdygpIE9WRVJSSURFOwpA QCAtNjM4LDYgKzYzOSw3IEBAIHByaXZhdGU6CiAgICAgUmVmUHRyPE1lZGlhRXJyb3I+IG1fZXJy b3I7CiAKICAgICBkb3VibGUgbV92b2x1bWU7CisgICAgYm9vbCBtX3ZvbHVtZUluaXRpYWxpemVk OwogICAgIGRvdWJsZSBtX2xhc3RTZWVrVGltZTsKICAgICAKICAgICB1bnNpZ25lZCBtX3ByZXZp b3VzUHJvZ3Jlc3M7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9NZWRpYVBsYXllci5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvTWVkaWFQ bGF5ZXIuaAppbmRleCBiMjRhYjRhZjE3MTEzMDI3ODJkMDg4NDdhYjllN2ExZWYxNzA2ZmI0Li44 NjliZDVmN2E0OGNhNzBkMzhlNTYxYWFjZGZiNjFlOGJkODcxZjAwIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9NZWRpYVBsYXllci5oCisrKyBiL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL01lZGlhUGxheWVyLmgKQEAgLTIxNCw2ICsyMTQsNyBA QCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIG1lZGlhUGxheWVyU2V0U2l6ZShjb25zdCBJbnRT aXplJikgeyB9CiAgICAgdmlydHVhbCB2b2lkIG1lZGlhUGxheWVyUGF1c2UoKSB7IH0KICAgICB2 aXJ0dWFsIHZvaWQgbWVkaWFQbGF5ZXJQbGF5KCkgeyB9CisgICAgdmlydHVhbCBib29sIG1lZGlh UGxheWVyUGxhdGZvcm1Wb2x1bWVDb25maWd1cmF0aW9uUmVxdWlyZWQoKSBjb25zdCB7IHJldHVy biBmYWxzZTsgfQogICAgIHZpcnR1YWwgYm9vbCBtZWRpYVBsYXllcklzUGF1c2VkKCkgY29uc3Qg eyByZXR1cm4gdHJ1ZTsgfQogICAgIHZpcnR1YWwgYm9vbCBtZWRpYVBsYXllcklzTG9vcGluZygp IGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9CiAgICAgdmlydHVhbCBIb3N0V2luZG93KiBtZWRpYVBs YXllckhvc3RXaW5kb3coKSB7IHJldHVybiAwOyB9CkBAIC0zMjgsNiArMzI5LDcgQEAgcHVibGlj OgogCiAgICAgZG91YmxlIHZvbHVtZSgpIGNvbnN0OwogICAgIHZvaWQgc2V0Vm9sdW1lKGRvdWJs ZSk7CisgICAgYm9vbCBwbGF0Zm9ybVZvbHVtZUNvbmZpZ3VyYXRpb25SZXF1aXJlZCgpIGNvbnN0 IHsgcmV0dXJuIG1fbWVkaWFQbGF5ZXJDbGllbnQtPm1lZGlhUGxheWVyUGxhdGZvcm1Wb2x1bWVD b25maWd1cmF0aW9uUmVxdWlyZWQoKTsgfQogCiAgICAgYm9vbCBtdXRlZCgpIGNvbnN0OwogICAg IHZvaWQgc2V0TXV0ZWQoYm9vbCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyQmFzZS5jcHAg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5ZXJQ cml2YXRlR1N0cmVhbWVyQmFzZS5jcHAKaW5kZXggZDlkNGJhNmUzMDk5MDcxOGY0ODQ5MGJmMzNm MDhjYjhiYjlmZTI0Ny4uMDBlOTVmMmY3OGIyMjc0YTVhZDRlNTQ4N2Q0YTg1MGI1MWI4NzYyYSAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL01l ZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2UuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9NZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNl LmNwcApAQCAtNzYsNiArNzYsNyBAQCBzdGF0aWMgaW50IGdyZWF0ZXN0Q29tbW9uRGl2aXNvcihp bnQgYSwgaW50IGIpCiBzdGF0aWMgdm9pZCBtZWRpYVBsYXllclByaXZhdGVWb2x1bWVDaGFuZ2Vk Q2FsbGJhY2soR09iamVjdCosIEdQYXJhbVNwZWMqLCBNZWRpYVBsYXllclByaXZhdGVHU3RyZWFt ZXJCYXNlKiBwbGF5ZXIpCiB7CiAgICAgLy8gVGhpcyBpcyBjYWxsZWQgd2hlbiBtX3ZvbHVtZUVs ZW1lbnQgcmVjZWl2ZXMgdGhlIG5vdGlmeTo6dm9sdW1lIHNpZ25hbC4KKyAgICBMT0dfTUVESUFf TUVTU0FHRSgiVm9sdW1lIGNoYW5nZWQgdG86ICVmIiwgcGxheWVyLT52b2x1bWUoKSk7CiAgICAg cGxheWVyLT52b2x1bWVDaGFuZ2VkKCk7CiB9CiAKQEAgLTIzNCw2ICsyMzUsNyBAQCB2b2lkIE1l ZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lckJhc2U6OnNldFZvbHVtZShmbG9hdCB2b2x1bWUpCiAg ICAgaWYgKCFtX3ZvbHVtZUVsZW1lbnQpCiAgICAgICAgIHJldHVybjsKIAorICAgIExPR19NRURJ QV9NRVNTQUdFKCJTZXR0aW5nIHZvbHVtZTogJWYiLCB2b2x1bWUpOwogICAgIGdzdF9zdHJlYW1f dm9sdW1lX3NldF92b2x1bWUobV92b2x1bWVFbGVtZW50LmdldCgpLCBHU1RfU1RSRUFNX1ZPTFVN RV9GT1JNQVRfQ1VCSUMsIHN0YXRpY19jYXN0PGRvdWJsZT4odm9sdW1lKSk7CiB9CiAKQEAgLTYx OCw3ICs2MjAsMTYgQEAgdm9pZCBNZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXJCYXNlOjpzZXRT dHJlYW1Wb2x1bWVFbGVtZW50KEdzdFN0cmVhbVZvbHVtZSogdm8KICAgICBBU1NFUlQoIW1fdm9s dW1lRWxlbWVudCk7CiAgICAgbV92b2x1bWVFbGVtZW50ID0gdm9sdW1lOwogCi0gICAgZ19vYmpl Y3Rfc2V0KG1fdm9sdW1lRWxlbWVudC5nZXQoKSwgIm11dGUiLCBtX3BsYXllci0+bXV0ZWQoKSwg InZvbHVtZSIsIG1fcGxheWVyLT52b2x1bWUoKSwgTlVMTCk7CisgICAgLy8gV2UgZG9uJ3Qgc2V0 IHRoZSBpbml0aWFsIHZvbHVtZSBiZWNhdXNlIHdlIHRydXN0IHRoZSBzaW5rIHRvIGtlZXAgaXQg Zm9yIHVzLiBTZWUKKyAgICAvLyBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MTE4OTc0IGZvciBtb3JlIGluZm9ybWF0aW9uLgorICAgIGlmICghbV9wbGF5ZXItPnBsYXRm b3JtVm9sdW1lQ29uZmlndXJhdGlvblJlcXVpcmVkKCkpIHsKKyAgICAgICAgTE9HX01FRElBX01F U1NBR0UoIlNldHRpbmcgc3RyZWFtIHZvbHVtZSB0byAlZiIsIG1fcGxheWVyLT52b2x1bWUoKSk7 CisgICAgICAgIGdfb2JqZWN0X3NldChtX3ZvbHVtZUVsZW1lbnQuZ2V0KCksICJ2b2x1bWUiLCBt X3BsYXllci0+dm9sdW1lKCksIE5VTEwpOworICAgIH0gZWxzZQorICAgICAgICBMT0dfTUVESUFf TUVTU0FHRSgiTm90IHNldHRpbmcgc3RyZWFtIHZvbHVtZSwgdHJ1c3Rpbmcgc3lzdGVtIG9uZSIp OworCisgICAgTE9HX01FRElBX01FU1NBR0UoIlNldHRpbmcgc3RyZWFtIG11dGVkICVkIiwgIG1f cGxheWVyLT5tdXRlZCgpKTsKKyAgICBnX29iamVjdF9zZXQobV92b2x1bWVFbGVtZW50LmdldCgp LCAibXV0ZSIsIG1fcGxheWVyLT5tdXRlZCgpLCBOVUxMKTsKIAogICAgIG1fdm9sdW1lU2lnbmFs SGFuZGxlciA9IGdfc2lnbmFsX2Nvbm5lY3QobV92b2x1bWVFbGVtZW50LmdldCgpLCAibm90aWZ5 Ojp2b2x1bWUiLCBHX0NBTExCQUNLKG1lZGlhUGxheWVyUHJpdmF0ZVZvbHVtZUNoYW5nZWRDYWxs YmFjayksIHRoaXMpOwogICAgIG1fbXV0ZVNpZ25hbEhhbmRsZXIgPSBnX3NpZ25hbF9jb25uZWN0 KG1fdm9sdW1lRWxlbWVudC5nZXQoKSwgIm5vdGlmeTo6bXV0ZSIsIEdfQ0FMTEJBQ0sobWVkaWFQ bGF5ZXJQcml2YXRlTXV0ZUNoYW5nZWRDYWxsYmFjayksIHRoaXMpOwo=