205275 2019-12-16 07:55:28 -0800 [GStreamer] Make source aware of buffered time 2022-02-10 16:31:15 -0800 1 1 1 Unclassified WebKit New Bugs WebKit Nightly Build Unspecified Unspecified RESOLVED INVALID P2 Normal --- 1 calvaris calvaris benjamin cdumez cgarcia cmarcelo cturner dbates eric.carlson ews-watchlist glenn gustavo jer.noble menard philipj pnormand sergio tsaunier vjaquez oldest_to_newest 1598887 0 calvaris 2019-12-16 07:55:28 -0800 [GStreamer] Make source aware of buffered time 1598899 1 385769 calvaris 2019-12-16 08:13:10 -0800 Created attachment 385769 Patch 1599368 2 pnormand 2019-12-17 03:54:08 -0800 Before doing a review, I have a couple of questions :) Why adding so much buffering logic to the element? Shouldn't the stream/download buffering logic be fixed instead in the player? 1599741 3 calvaris 2019-12-18 03:56:03 -0800 (In reply to Philippe Normand from comment #2) > Before doing a review, I have a couple of questions :) > Why adding so much buffering logic to the element? Shouldn't the > stream/download buffering logic be fixed instead in the player? We might a bit of logic to the player, like the one checking how far we have buffered, but the logic to initiate and stop the load should be, IMHO, in the source because it is the source that knows when it gets buffers and when it pushes them, the one that can block on the streaming thread, etc. 1600221 4 385769 cturner 2019-12-19 04:18:30 -0800 Comment on attachment 385769 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=385769&action=review I agree with Phil at a high-level, this element looks to have too much knowledge of the rest of the pipeline configuration and the player. What concerns me is the added complexity, when we know souphttpsrc works well and doesn't have so much complication imo. I believe our buffering code in the player is what needs more attention, and that in turn would fix the pathological issues with this element. > Source/WebCore/ChangeLog:9 > + in pushing data downstream. We don't read fast buffers anymore What are fast buffers and fast data? > Source/WebCore/ChangeLog:30 > + (webKitWebSrcCreate): "Defast", otherwise we might be waiting for What is defast? > Source/WebCore/ChangeLog:39 > + adjustment improved. Please explain this. > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp:2285 > + m_didDownloadFinish = percentage == 100 && (!WEBKIT_IS_WEB_SRC(m_source.get()) || !webKitSrcIsWaitingForData(WEBKIT_WEB_SRC_CAST(m_source.get()))); I find the didDownloadFinish flag confusing. It seems we need to more clear about what posted the given percentage, if its a downloadbuffer then it makes sense, but if it's a queue somewhere in the pipeline it does not. I feel like these two concepts need to made more explicit in the player, and that would help our buffering bugs, since it looks like we mix these two modes up. It is easier to read this as percentage==100 && isWebSrcWaitingForData(), where the cast check is performed in its own function. Even further, it strongly suggests to me we need to refactor all the buffering code into something that is self-aware of what the pipeline configuration is, so that this logic is not so twisted in with the rest of the player logic. > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp:2294 > + if (percentage == 100) Ditto. > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp:2872 > + webKitWebSrcSetOnDiskBufferingEnabled(WEBKIT_WEB_SRC_CAST(m_source.get()), shouldDownload); It seems wrong for a source to need to know whether downstream is disk buffering or RAM buffering, souphttpsrc doesn't need to AFAICT, and doesn't have these behaviours. > Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:55 > +// Minimal buffered seconds. This comment is not helping me understand the purpose of these variables. > Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:84 > + static constexpr float s_reduceBlocksizeLimit { 0.5 }; These constants were taken from souphttpsrc, does that also stall out on the respective bugs? Because our block size algorithm is (should be) identical, so it concerns me that we're performing magic here and don't know exactly what is going wrong. > Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:361 > +static WTF::Optional<bool> WARN_UNUSED_RETURN areNextSecondsBuffered(WebKitWebSrc* src, const Seconds& seconds) This logic seems like it should be in the player. > Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:413 > + GST_TRACE_OBJECT(src, "is download suspented %s, does have EOS %s, does have size %s, is seekable %s, size %" G_GUINT64_FORMAT suspented typo > Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:417 > + if (priv->doesHaveEOS || !priv->haveSize || !priv->isSeekable || priv->size <= SMALL_MEDIA_RESOURCE_MAX_SIZE || !priv->readPosition Personal preference, but conditionals this long are a code smell for me, can we refactor it into more meaningful predicates? > Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:429 > + if (isEnoughTimeBuffered.hasValue()) { The ternary logic here is weird, we're not using the false case, only the true and unknown cases. > Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:467 > + if (isEnoughTimeBuffered.hasValue()) { Ditto. > Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:497 > + gst_adapter_clear(priv->adapter.get()); This changes seems like it invalidates the remaining comment? > Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:-387 > - return GST_FLOW_FLUSHING; A comment about the change in flushing behaviour should be in the changelog, is the flushing behaviour directly related to this bug? > Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:-400 > - size_t available = gst_adapter_available_fast(priv->adapter.get()); A comment about the switch from the fast to slow should be added. > Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:559 > + } else if (!priv->isDownloadSuspended && ++retries >= 10) This loop is very tricky, it would be a good idea to break it out into separate components if you can. > Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:-920 > - if (bytesRead >= blocksize * s_growBlocksizeLimit) { Why? > Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:1229 > + // Rough bandwidth calculation. We don't calculate since we issue the request because that would include sending the request, etc. This way we can "We don't calculate since we issue the request because that would include sending the request", please can you try to rephrase this? I'm not sure what you're trying to say. 1600223 5 cturner 2019-12-19 04:28:01 -0800 (In reply to Charlie Turner from comment #4) > > Source/WebCore/ChangeLog:9 > > + in pushing data downstream. We don't read fast buffers anymore > > What are fast buffers and fast data? > > > Source/WebCore/ChangeLog:30 > > + (webKitWebSrcCreate): "Defast", otherwise we might be waiting for > > What is defast? It just occurred to me these are buffers from the adapter's fast API, but lets make the language clearer :) 1600281 6 calvaris 2019-12-19 08:24:12 -0800 (In reply to Charlie Turner from comment #4) > Comment on attachment 385769 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=385769&action=review > > I agree with Phil at a high-level, this element looks to have too much > knowledge of the rest of the pipeline configuration and the player. What > concerns me is the added complexity, when we know souphttpsrc works well and > doesn't have so much complication imo. I believe our buffering code in the > player is what needs more attention, and that in turn would fix the > pathological issues with this element. I agree we could do more things in the player and I am open to change this to do that but there are some others that should be done in the source. Examples of things are: * Removing the using fast API of the adapter. This was causing the source to wait for data when it was clearly able to provide more. * We need to increase the wait. There are certain cases where we will be getting EOS from the source while waiting for data and 400ms are clearly not enough during network load. * Blocking the main thread and allowing an empty adapter because sometimes we have data that are not pushing. I'll comment on the things I DON'T agree with. > > Source/WebCore/ChangeLog:9 > > + in pushing data downstream. We don't read fast buffers anymore > > What are fast buffers and fast data? The "fast" adapter API, yes. > > Source/WebCore/ChangeLog:30 > > + (webKitWebSrcCreate): "Defast", otherwise we might be waiting for > > What is defast? > > > Source/WebCore/ChangeLog:39 > > + adjustment improved. > > Please explain this. In changelog or here? I adjusted the parameters by needing to pass the read limit twice instead of one and considering that we are going to reduce the blocksize when we go down half of the block size by when reading (twice already). > > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp:2285 > > + m_didDownloadFinish = percentage == 100 && (!WEBKIT_IS_WEB_SRC(m_source.get()) || !webKitSrcIsWaitingForData(WEBKIT_WEB_SRC_CAST(m_source.get()))); > > I find the didDownloadFinish flag confusing. It seems we need to more clear > about what posted the given percentage, if its a downloadbuffer then it > makes sense, but if it's a queue somewhere in the pipeline it does not. I > feel like these two concepts need to made more explicit in the player, and > that would help our buffering bugs, since it looks like we mix these two > modes up. > > It is easier to read this as percentage==100 && isWebSrcWaitingForData(), > where the cast check is performed in its own function. Even further, it > strongly suggests to me we need to refactor all the buffering code into > something that is self-aware of what the pipeline configuration is, so that > this logic is not so twisted in with the rest of the player logic. > > > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp:2294 > > + if (percentage == 100) > > Ditto. The problem of all this is that the percentages are a bit confusing. Percents are sent in a different way depending on the download mode. If it is inactive it is the queue just downstream the source that answers that and it is 100% when it is full, which is different from having download enabled. > > Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp:2872 > > + webKitWebSrcSetOnDiskBufferingEnabled(WEBKIT_WEB_SRC_CAST(m_source.get()), shouldDownload); > > It seems wrong for a source to need to know whether downstream is disk > buffering or RAM buffering, souphttpsrc doesn't need to AFAICT, and doesn't > have these behaviours. If we don't have download enabled, any logic based on something different than percentages is useless because it is the queue that is going to limit us. That's why I introduced this. I prefer a timed logic because it is what MSE providers do, by wanting to have always 30s, which motivated my limits as well. > > Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:55 > > +// Minimal buffered seconds. > > This comment is not helping me understand the purpose of these variables. Again, do you want me to change the comment or an explanation here? These are the limits that the stop/restart functions are going to use: * 15s for initial playback, otherwise the chrome is going to take too long to "fill the download slider". * we stop when we have 30s or more and we restart when we have less than 25s. > > Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:84 > > + static constexpr float s_reduceBlocksizeLimit { 0.5 }; > > These constants were taken from souphttpsrc, does that also stall out on the > respective bugs? Because our block size algorithm is (should be) identical, > so it concerns me that we're performing magic here and don't know exactly > what is going wrong. From the behavior I saw while debugging this bug, I had the empirical impression that these values make more sente because otherwise the blocksize can be increased quite quickly and we are not able to fulfill it almost ever. I don't think this has a big impact as I think modifying some other pieces was more important to achieve a better behavior. > > Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:429 > > + if (isEnoughTimeBuffered.hasValue()) { > > The ternary logic here is weird, we're not using the false case, only the > true and unknown cases. > > > Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:467 > > + if (isEnoughTimeBuffered.hasValue()) { > > Ditto. We are using it! If we don't have a duration we fallback to queue sizes. If we have it, we bail out if we are inside parameters, otherwise we don't bail out and to the bottom of the function. > > Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:-387 > > - return GST_FLOW_FLUSHING; > > A comment about the change in flushing behaviour should be in the changelog, > is the flushing behaviour directly related to this bug? No, the behavior is not changed. I only move it because with my changes it might happen that we are blocking the streaming thread while a seek or flush comes and when that happens we don't want to continue, we want to flush, and continuing is what was happening before. > > Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:-400 > > - size_t available = gst_adapter_available_fast(priv->adapter.get()); > > A comment about the switch from the fast to slow should be added. I can do it if necessary but an detailed read to the fast API makes you realize that for some cases it is not that fast and I think we were using it wrong before. I don't think it is needed. > > Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:559 > > + } else if (!priv->isDownloadSuspended && ++retries >= 10) > > This loop is very tricky, it would be a good idea to break it out into > separate components if you can. I tried to respect the former structure but sure I can try it. > > Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:-920 > > - if (bytesRead >= blocksize * s_growBlocksizeLimit) { > > Why? For me it makes no sense to increase something that it's inside limits. = is inside limits. > > Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:1229 > > + // Rough bandwidth calculation. We don't calculate since we issue the request because that would include sending the request, etc. This way we can > > "We don't calculate since we issue the request because that would include > sending the request", please can you try to rephrase this? I'm not sure what > you're trying to say. Yes, I can, I guess you want it in the comment as well but the the case is that I don't know when the first batch of data is sent by the server, only when we receive data or when we request it so if reset the counters when I issue the request I will be including the time of sending the request to the server and I am interested in getting only the bandwidth from the server to us. For that I discard the first data pack and begin to count from there. It's just an aproximation but it is better aproximated this way, I think. 1600300 7 385769 cturner 2019-12-19 09:07:47 -0800 Comment on attachment 385769 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=385769&action=review >>> Source/WebCore/ChangeLog:9 >>> + in pushing data downstream. We don't read fast buffers anymore >> >> What are fast buffers and fast data? > > The "fast" adapter API, yes. OK, this all makes sense now. >>> Source/WebCore/ChangeLog:30 >>> + (webKitWebSrcCreate): "Defast", otherwise we might be waiting for >> >> What is defast? > > In changelog or here? I adjusted the parameters by needing to pass the read limit twice instead of one and considering that we are going to reduce the blocksize when we go down half of the block size by when reading (twice already). I think this is in response to something else, but please use the API names rather than "Defast" which at first I read as a typo. >> Source/WebCore/ChangeLog:39 >> + adjustment improved. > > Please explain this. Think this was what you were referring to. In the ChangeLog would be great so we have a record of the reasons for our algorithm changes. >>> Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp:2285 >>> + m_didDownloadFinish = percentage == 100 && (!WEBKIT_IS_WEB_SRC(m_source.get()) || !webKitSrcIsWaitingForData(WEBKIT_WEB_SRC_CAST(m_source.get()))); >> >> I find the didDownloadFinish flag confusing. It seems we need to more clear about what posted the given percentage, if its a downloadbuffer then it makes sense, but if it's a queue somewhere in the pipeline it does not. I feel like these two concepts need to made more explicit in the player, and that would help our buffering bugs, since it looks like we mix these two modes up. >> >> It is easier to read this as percentage==100 && isWebSrcWaitingForData(), where the cast check is performed in its own function. Even further, it strongly suggests to me we need to refactor all the buffering code into something that is self-aware of what the pipeline configuration is, so that this logic is not so twisted in with the rest of the player logic. > > The problem of all this is that the percentages are a bit confusing. Percents are sent in a different way depending on the download mode. If it is inactive it is the queue just downstream the source that answers that and it is 100% when it is full, which is different from having download enabled. I agree, perhaps we can use better variable names to help keep this clear in the code. >>> Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp:2872 >>> + webKitWebSrcSetOnDiskBufferingEnabled(WEBKIT_WEB_SRC_CAST(m_source.get()), shouldDownload); >> >> It seems wrong for a source to need to know whether downstream is disk buffering or RAM buffering, souphttpsrc doesn't need to AFAICT, and doesn't have these behaviours. > > If we don't have download enabled, any logic based on something different than percentages is useless because it is the queue that is going to limit us. That's why I introduced this. I prefer a timed logic because it is what MSE providers do, by wanting to have always 30s, which motivated my limits as well. My understanding is that the pipeline should be giving us enough information through BUFFERING messages to keep the pipeline from stalling out, if it is not then I would say that's a bug in GStreamer. I don't think the web src should need knowledge of MSE at all, it's not its responsibility. If we need specific amounts of queued data for that case, why can't we configure the GstQueue2 appropriately rather than modifying the source? >>> Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:55 >>> +// Minimal buffered seconds. >> >> This comment is not helping me understand the purpose of these variables. > > Again, do you want me to change the comment or an explanation here? > > These are the limits that the stop/restart functions are going to use: > * 15s for initial playback, otherwise the chrome is going to take too long to "fill the download slider". > * we stop when we have 30s or more and we restart when we have less than 25s. In the code please. An explanation of the higher-level algorithmic changes can go in the ChangeLog. >>> Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:84 >>> + static constexpr float s_reduceBlocksizeLimit { 0.5 }; >> >> These constants were taken from souphttpsrc, does that also stall out on the respective bugs? Because our block size algorithm is (should be) identical, so it concerns me that we're performing magic here and don't know exactly what is going wrong. > > From the behavior I saw while debugging this bug, I had the empirical impression that these values make more sente because otherwise the blocksize can be increased quite quickly and we are not able to fulfill it almost ever. > > I don't think this has a big impact as I think modifying some other pieces was more important to achieve a better behavior. I'm a little concerned we can't keep the buffers full, strange that soup can be I can accept we perhaps have differences in our net code and the direct use of the soup API in gstsouphttpsrc. >>> Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:429 >>> + if (isEnoughTimeBuffered.hasValue()) { >> >> The ternary logic here is weird, we're not using the false case, only the true and unknown cases. > > We are using it! If we don't have a duration we fallback to queue sizes. If we have it, we bail out if we are inside parameters, otherwise we don't bail out and to the bottom of the function. OK >>> Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:-387 >>> - return GST_FLOW_FLUSHING; >> >> A comment about the change in flushing behaviour should be in the changelog, is the flushing behaviour directly related to this bug? > > No, the behavior is not changed. I only move it because with my changes it might happen that we are blocking the streaming thread while a seek or flush comes and when that happens we don't want to continue, we want to flush, and continuing is what was happening before. OK, it looks like the old implementation was not respecting flushes while waiting for the adaptor to fill up, but now we are which seems like a good thing. >>> Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:-400 >>> - size_t available = gst_adapter_available_fast(priv->adapter.get()); >> >> A comment about the switch from the fast to slow should be added. > > I can do it if necessary but an detailed read to the fast API makes you realize that for some cases it is not that fast and I think we were using it wrong before. I don't think it is needed. I would add a note, it will save the next programmer from having to do a detailed read of the fast API ;) >>> Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:1229 >>> + // Rough bandwidth calculation. We don't calculate since we issue the request because that would include sending the request, etc. This way we can >> >> "We don't calculate since we issue the request because that would include sending the request", please can you try to rephrase this? I'm not sure what you're trying to say. > > Yes, I can, I guess you want it in the comment as well but the the case is that I don't know when the first batch of data is sent by the server, only when we receive data or when we request it so if reset the counters when I issue the request I will be including the time of sending the request to the server and I am interested in getting only the bandwidth from the server to us. For that I discard the first data pack and begin to count from there. It's just an aproximation but it is better aproximated this way, I think. Gotcha, bandwidth approximation is tricky, seems like something our network code in WebKit should be providing for us (ResourceLoadStatistics?). Anyway, not a big deal for now, just again it feels like the wrong place for this. 1600660 8 calvaris 2019-12-20 02:41:31 -0800 (In reply to Charlie Turner from comment #7) > >>> Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp:2872 > >>> + webKitWebSrcSetOnDiskBufferingEnabled(WEBKIT_WEB_SRC_CAST(m_source.get()), shouldDownload); > >> > >> It seems wrong for a source to need to know whether downstream is disk buffering or RAM buffering, souphttpsrc doesn't need to AFAICT, and doesn't have these behaviours. > > > > If we don't have download enabled, any logic based on something different than percentages is useless because it is the queue that is going to limit us. That's why I introduced this. I prefer a timed logic because it is what MSE providers do, by wanting to have always 30s, which motivated my limits as well. > > My understanding is that the pipeline should be giving us enough information > through BUFFERING messages to keep the pipeline from stalling out, if it is > not then I would say that's a bug in GStreamer. I don't think the web src > should need knowledge of MSE at all, it's not its responsibility. If we need > specific amounts of queued data for that case, why can't we configure the > GstQueue2 appropriately rather than modifying the source? When I talk about MSE is just an example of how MSE players behave, they try to keep a certain amount of time buffered instead of relying just on percentages. For me this is the proper behavior because we get percentages of the queue2 size and in the two use cases: * Having download enabled, we might not stop the downloading because the queue is rarely full, meaning that we are going to download the full file and keep it on disk, increasing the disk size and maybe using a lot of bandwidth. Imagine the case of two hours 1080p video. We could certainly download that, keep it on disk and then play it without relying on the network but the user could decide after 15 minutes that they are not interested. We have misused the bandwidth and maybe we got (if network is fast enough) the whole movie). MSE players keep 30s ahead. * Having download disabled would mean that we would rely on the queue size that can be a problem as well because the queue size can be very small and some videos that be not enough and we might stall. Actually this patch does not fix this because I found some problem that prevented me to trust this calculation. I might revisit this topic. > >>> Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:84 > >>> + static constexpr float s_reduceBlocksizeLimit { 0.5 }; > >> > >> These constants were taken from souphttpsrc, does that also stall out on the respective bugs? Because our block size algorithm is (should be) identical, so it concerns me that we're performing magic here and don't know exactly what is going wrong. > > > > From the behavior I saw while debugging this bug, I had the empirical impression that these values make more sente because otherwise the blocksize can be increased quite quickly and we are not able to fulfill it almost ever. > > > > I don't think this has a big impact as I think modifying some other pieces was more important to achieve a better behavior. > > I'm a little concerned we can't keep the buffers full, strange that soup can > be I can accept we perhaps have differences in our net code and the direct > use of the soup API in gstsouphttpsrc. I didn't read soupsrc code but if it behaves the same (or similar) to what we did, in the cases I tried we almost never provide full buffers for two reasons, size grows too fast and they have a hard time to be reduced but with the behavior of "waiting a bit and then pushing what we have" you have the impression of being pumping all the time. I don't know if they use the fast API, but not using it also helps. > >>> Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:1229 > >>> + // Rough bandwidth calculation. We don't calculate since we issue the request because that would include sending the request, etc. This way we can > >> > >> "We don't calculate since we issue the request because that would include sending the request", please can you try to rephrase this? I'm not sure what you're trying to say. > > > > Yes, I can, I guess you want it in the comment as well but the the case is that I don't know when the first batch of data is sent by the server, only when we receive data or when we request it so if reset the counters when I issue the request I will be including the time of sending the request to the server and I am interested in getting only the bandwidth from the server to us. For that I discard the first data pack and begin to count from there. It's just an aproximation but it is better aproximated this way, I think. > > Gotcha, bandwidth approximation is tricky, seems like something our network > code in WebKit should be providing for us (ResourceLoadStatistics?). Anyway, > not a big deal for now, just again it feels like the wrong place for this. Well, I guess I could try to investigate that but in this case, for me the important thing here was able to provide an idea of it is was the source that was not pushing things fast enough (which happened with the fast API) or it was the network thas was lagging behind. 1601606 9 386442 calvaris 2019-12-27 06:48:00 -0800 Created attachment 386442 Patch Honored some style comments 1601969 10 385769 tsaunier 2019-12-31 04:27:12 -0800 Comment on attachment 385769 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=385769&action=review >>>> Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp:2285 >>>> + m_didDownloadFinish = percentage == 100 && (!WEBKIT_IS_WEB_SRC(m_source.get()) || !webKitSrcIsWaitingForData(WEBKIT_WEB_SRC_CAST(m_source.get()))); >>> >>> I find the didDownloadFinish flag confusing. It seems we need to more clear about what posted the given percentage, if its a downloadbuffer then it makes sense, but if it's a queue somewhere in the pipeline it does not. I feel like these two concepts need to made more explicit in the player, and that would help our buffering bugs, since it looks like we mix these two modes up. >>> >>> It is easier to read this as percentage==100 && isWebSrcWaitingForData(), where the cast check is performed in its own function. Even further, it strongly suggests to me we need to refactor all the buffering code into something that is self-aware of what the pipeline configuration is, so that this logic is not so twisted in with the rest of the player logic. >> >> The problem of all this is that the percentages are a bit confusing. Percents are sent in a different way depending on the download mode. If it is inactive it is the queue just downstream the source that answers that and it is 100% when it is full, which is different from having download enabled. > > I agree, perhaps we can use better variable names to help keep this clear in the code. Note that I wrote a commit on top of yours: https://github.com/thiblahute/webkit/commit/245e80aadf35ee1e6a731c613e793c03a3d7f840 I am not proposing as it is quite integrated with your changes but I think we should discuss both commits here. My approach here is to remove WebkitWebSrc specific code here as it is not needed anymore: https://github.com/thiblahute/webkit/commit/245e80aadf35ee1e6a731c613e793c03a3d7f840#diff-5ee59a48f2b7b824ae265766f42c0752R2307 The main issue you are working around is something I fixed in that on top commit, see the ChangeLog there: > (WebCore::MediaPlayerPrivateGStreamer::fillTimerFired): Query buffering on the pipeline not the source > otherwise GstBaseSrc returns some useless values before `downloadbuffer` actually gives us the > info about DOWNLOAD buffering status. Also ignores response if they are not in DOWNLOAD mode as those > will end up screwing our buffering management algorithm. Before that change we were dealing with meaningless values here and our buffering algorithm was breaking badly. >>>> Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp:2872 >>>> + webKitWebSrcSetOnDiskBufferingEnabled(WEBKIT_WEB_SRC_CAST(m_source.get()), shouldDownload); >>> >>> It seems wrong for a source to need to know whether downstream is disk buffering or RAM buffering, souphttpsrc doesn't need to AFAICT, and doesn't have these behaviours. >> >> If we don't have download enabled, any logic based on something different than percentages is useless because it is the queue that is going to limit us. That's why I introduced this. I prefer a timed logic because it is what MSE providers do, by wanting to have always 30s, which motivated my limits as well. > > My understanding is that the pipeline should be giving us enough information through BUFFERING messages to keep the pipeline from stalling out, if it is not then I would say that's a bug in GStreamer. I don't think the web src should need knowledge of MSE at all, it's not its responsibility. If we need specific amounts of queued data for that case, why can't we configure the GstQueue2 appropriately rather than modifying the source? In my commit on top I kept the idea of having a different behavior based on whether we are using `downloadbuffer` or not, but drastically simplified the logic by saying that if we are buffering on disk, we can download as fast as possible as downstream will never block as it will just save the stream on disk as fast as possible. >> Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:361 >> +static WTF::Optional<bool> WARN_UNUSED_RETURN areNextSecondsBuffered(WebKitWebSrc* src, const Seconds& seconds) > > This logic seems like it should be in the player. In my commit I just removed that logic all together as previously explained. >> Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:413 >> + GST_TRACE_OBJECT(src, "is download suspented %s, does have EOS %s, does have size %s, is seekable %s, size %" G_GUINT64_FORMAT > > suspented typo s/suspented/suspended/ >>>> Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:-400 >>>> - size_t available = gst_adapter_available_fast(priv->adapter.get()); >>> >>> A comment about the switch from the fast to slow should be added. >> >> I can do it if necessary but an detailed read to the fast API makes you realize that for some cases it is not that fast and I think we were using it wrong before. I don't think it is needed. > > I would add a note, it will save the next programmer from having to do a detailed read of the fast API ;) I do not think using the fast > Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:535 > + // Position is not going to move when download is suspended and we are PAUSED, so we can block here without checking the position. In PAUSED with a `downloadbuffer` we should not block at all as the stream will just be downloaded on disk, I do not think that condition is a good idea. 1602764 11 385769 pnormand 2020-01-04 08:55:07 -0800 Comment on attachment 385769 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=385769&action=review >>>>> Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:-400 >>>>> - size_t available = gst_adapter_available_fast(priv->adapter.get()); >>>> >>>> A comment about the switch from the fast to slow should be added. >>> >>> I can do it if necessary but an detailed read to the fast API makes you realize that for some cases it is not that fast and I think we were using it wrong before. I don't think it is needed. >> >> I would add a note, it will save the next programmer from having to do a detailed read of the fast API ;) > > I do not think using the fast The suspense is killing me. Can you finish the sentence? :) 1603004 12 tsaunier 2020-01-06 05:10:32 -0800 (In reply to Philippe Normand from comment #11) > Comment on attachment 385769 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=385769&action=review > > >>>>> Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:-400 > >>>>> - size_t available = gst_adapter_available_fast(priv->adapter.get()); > >>>> > >>>> A comment about the switch from the fast to slow should be added. > >>> > >>> I can do it if necessary but an detailed read to the fast API makes you realize that for some cases it is not that fast and I think we were using it wrong before. I don't think it is needed. > >> > >> I would add a note, it will save the next programmer from having to do a detailed read of the fast API ;) > > > > I do not think using the fast > > The suspense is killing me. Can you finish the sentence? :) hehe, I think the idea was that I do not see why we use that API here, but then decided that I would just not comment here but forgot to remove the start of my sentence :-) 1604079 13 calvaris 2020-01-08 07:06:15 -0800 (In reply to Thibault Saunier from comment #10) > In my commit on top I kept the idea of having a different behavior based on > whether we are using `downloadbuffer` or not, but drastically simplified the > logic by saying that if we are buffering on disk, we can download as fast as > possible as downstream will never block as it will just save the stream on > disk as fast as possible. And here is where I disagree. I don't think we want to download as fast as possible and that's why I implemented the time based solution. I think downloading as fast as possible can be a problem in disk limited devices. 1604604 14 calvaris 2020-01-09 07:15:02 -0800 Reopening to attach new patch. 1604605 15 387223 calvaris 2020-01-09 07:15:05 -0800 Created attachment 387223 Patch 1604606 16 calvaris 2020-01-09 07:15:51 -0800 Wrong bug, webkit-patch tricked me. Sorry for the noise 385769 2019-12-16 08:13:10 -0800 2019-12-27 06:47:56 -0800 Patch bug-205275-20191216171309.patch text/plain 28637 calvaris U3VidmVyc2lvbiBSZXZpc2lvbjogMjUzNTUwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDRiYThlMGE3YjE3NDYwMTA3N2U2NTNi ZmVmZmRhMWVlNDM4YjRjYWQuLjYyZjY5ZjFlOWE1YjdkNzRkNzU2MDQ2ZWE0OTdlMzQwMGExMmRh ZjIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTIgQEAKKzIwMTktMTItMTYgIFhhYmllciBSb2RyaWd1ZXogQ2Fs dmFyICA8Y2FsdmFyaXNAaWdhbGlhLmNvbT4KKworICAgICAgICBbR1N0cmVhbWVyXSBNYWtlIHNv dXJjZSBhd2FyZSBvZiBidWZmZXJlZCB0aW1lCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0yMDUyNzUKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICAqIHd0Zi9NZWRpYVRpbWUuaDogQWRkZWQgb3BlcmF0b3JzIHRv IG9wZXJhdGUgd2l0aCBTZWNvbmRzLgorCiAyMDE5LTEyLTEzICBTYWFtIEJhcmF0aSAgPHNiYXJh dGlAYXBwbGUuY29tPgogCiAgICAgICAgIEFkZCBhIEhlYXA6OmZpbmFsaXplIGZ1bmN0aW9uIHRo YXQgdGFrZXMgV1RGOjpGdW5jdGlvbjx2b2lkKCk+CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYTQyZGYyNTgxNzg3 NzE1YWY0MWNlMDE4NWM0YjE0ZTJmZjQxZTRmNS4uOTk1NDhlNjQyYmU5YWE4ZDAwNTMwMWM0ZDI3 NGNlMjE4ZDNiMTcxOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBi L1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQ3IEBACisyMDE5LTEyLTE2ICBY YWJpZXIgUm9kcmlndWV6IENhbHZhciAgPGNhbHZhcmlzQGlnYWxpYS5jb20+CisKKyAgICAgICAg W0dTdHJlYW1lcl0gTWFrZSBzb3VyY2UgYXdhcmUgb2YgYnVmZmVyZWQgdGltZQorICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjA1Mjc1CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUmV3b3JrZWQgaG93IHRoZSB3 ZWIgc291cmNlIGRlYWxzIHdpdGggZGF0YS4gSXQncyBtb3JlIGVhZ2VyIG5vdworICAgICAgICBp biBwdXNoaW5nIGRhdGEgZG93bnN0cmVhbS4gV2UgZG9uJ3QgcmVhZCBmYXN0IGJ1ZmZlcnMgYW55 bW9yZQorICAgICAgICBiZWNhdXNlIHNvbWV0aW1lcyBpdCB3YXMgc2xvd2VyIGFzIHdlIHdlcmUg d2FpdGluZyBmb3IgbW9yZSAiZmFzdAorICAgICAgICBkYXRhIiB0byBiZSBhdmFpbGFibGUgYW5k IHdlIGhhZCBlbm91Z2ggaW4gbm9uIGZhc3QgYnVmZmVycy4KKworICAgICAgICBUaGUgc3RyZWFt aW5nIHRocmVhZCBsb2NrcyBub3cgd2hlbiBpdCBoYXMgbm8gZGF0YSB0byBwdXNoCisgICAgICAg IGRvd25zdHJlYW0gYW5kIHJlc3RhcnRzIHRoZSBkb3dubG9hZCBpZiBuZWVkZWQuCisKKyAgICAg ICAgQnVmZmVyZWQgdGltZSByYW5nZXMgYXJlIG5vdyB1c2VkIHRvIHNlZSBpZiB3ZSBoYXZlIHRv CisgICAgICAgIHN0b3AvcmVzdGFydCB0aGUgZG93bmxvYWQuCisKKyAgICAgICAgKiBwbGF0Zm9y bS9ncmFwaGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyLmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6Ok1lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lcjo6dXBkYXRlQnVmZmVy aW5nU3RhdHVzKToKKyAgICAgICAgRG93bmxvYWQgaXMgbm90IGZpbmlzaGVkIGlmIHRoZSBzb3Vy Y2UgaXMgd2FpdGluZy4KKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhUGxheWVyUHJpdmF0ZUdTdHJl YW1lcjo6dXBkYXRlU3RhdGVzKTogQWRkZWQgRkFMTFRIUk9VR0guCisgICAgICAgIChXZWJDb3Jl OjpNZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXI6OnVwZGF0ZURvd25sb2FkQnVmZmVyaW5nRmxh Zyk6CisgICAgICAgIE1ha2Ugc291cmNlIGF3YXJlIG9mIHBpcGVsaW5lIGJ1ZmZlcmluZyBzdHJh dGVneS4KKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvV2ViS2l0V2ViU291 cmNlR1N0cmVhbWVyLmNwcDoKKyAgICAgICAgKGFyZU5leHRTZWNvbmRzQnVmZmVyZWQpOiBDaGVj a3MgaWYgYSBjZXJ0YWluIGFtb3V0IG9mIHNlY29uZHMgYXJlCisgICAgICAgIGFscmVhZHkgYnVm ZmVyZWQuCisgICAgICAgIChyZXN0YXJ0TG9hZGVySWZOZWVkZWQpOiBBZGRlZCwgYmFzZWQgb24g YnVmZmVyZWQgc2Vjb25kcy4KKyAgICAgICAgKHN0b3BMb2FkZXJJZk5lZWRlZCk6ICBBZGRlZCwg YmFzZWQgb24gYnVmZmVyZWQgc2Vjb25kcy4KKyAgICAgICAgKHdlYktpdFdlYlNyY0NyZWF0ZSk6 ICJEZWZhc3QiLCBvdGhlcndpc2Ugd2UgbWlnaHQgYmUgd2FpdGluZyBmb3IKKyAgICAgICAgZGF0 YSB3ZSBhbHJlYWR5IGhhdmUuIFN0cmVhbWluZyB0aHJlYWQgaXMgbm93IGdvaW5nIHRvIGxvY2sK KyAgICAgICAgd2FpdGluZyBmb3IgZGF0YSBhbmQgaXMgbW9yZSBlYWdlciBpbiBwdXNoaW5nIGRh dGEgZG93bnN0cmVhbS4KKyAgICAgICAgKHdlYktpdFdlYlNyY1N0b3ApOiBObyBtb3JlIHF1ZXVl U2l6ZS4KKyAgICAgICAgKHdlYktpdFdlYlNyY0RvU2Vlayk6CisgICAgICAgICh3ZWJLaXRXZWJT cmNVbkxvY2spOgorICAgICAgICAod2ViS2l0V2ViU3JjQ2hhbmdlU3RhdGUpOiBOb3RpZnkgc3Ry ZWFtaW5nIHRocmVhZC4KKyAgICAgICAgKHdlYktpdFdlYlNyY1NldE9uRGlza0J1ZmZlcmluZ0Vu YWJsZWQpOiBBZGRlZC4KKyAgICAgICAgKENhY2hlZFJlc291cmNlU3RyZWFtaW5nQ2xpZW50Ojpj aGVja1VwZGF0ZUJsb2Nrc2l6ZSk6IEJsb2Nrc2l6ZQorICAgICAgICBhZGp1c3RtZW50IGltcHJv dmVkLgorICAgICAgICAoQ2FjaGVkUmVzb3VyY2VTdHJlYW1pbmdDbGllbnQ6OmRhdGFSZWNlaXZl ZCk6IEFkZGVkIHJ1ZGltZW50YXJ5CisgICAgICAgIGJhbmR3aXRoIGNhbGN1bGF0aW9uIGFuZCB1 c2Ugc3RvcExvYWRlcklmTmVlZGVkLgorICAgICAgICAod2ViS2l0U3JjSXNXYWl0aW5nRm9yRGF0 YSk6IEFkZGVkLgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9XZWJLaXRX ZWJTb3VyY2VHU3RyZWFtZXIuaDoKKwogMjAxOS0xMi0xNiAgWmFsYW4gQnVqdGFzICA8emFsYW5A YXBwbGUuY29tPgogCiAgICAgICAgIFtMRkNdW0lGQ10gUmVuYW1lIExpbmVCdWlsZGVyOjptX3Nr aXBBbGlnbm1lbnQgdG8gTGluZUJ1aWxkZXI6Om1faW50cmluc2ljV2lkdGhMaW5lCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV1RGL3d0Zi9NZWRpYVRpbWUuaCBiL1NvdXJjZS9XVEYvd3RmL01lZGlhVGlt ZS5oCmluZGV4IDU2ZjU1YjBmYjBmMDFkNjYxODk0OTljMmMxYWI0OGU3YTNhY2ViZTguLjgyNWYw OTMwYThjMTlmNzM2ZDA0MjQxMmJkZWNjZGJiYzJhYzI3ODAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X VEYvd3RmL01lZGlhVGltZS5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL01lZGlhVGltZS5oCkBAIC02 NywxMiArNjcsMTQgQEAgcHVibGljOgogICAgIGRvdWJsZSB0b0RvdWJsZSgpIGNvbnN0OwogCiAg ICAgTWVkaWFUaW1lJiBvcGVyYXRvcj0oY29uc3QgTWVkaWFUaW1lJiByaHMpOwotICAgIE1lZGlh VGltZSYgb3BlcmF0b3IrPShjb25zdCBNZWRpYVRpbWUmIHJocykgeyByZXR1cm4gKnRoaXMgPSAq dGhpcyArIHJoczsgfQotICAgIE1lZGlhVGltZSYgb3BlcmF0b3ItPShjb25zdCBNZWRpYVRpbWUm IHJocykgeyByZXR1cm4gKnRoaXMgPSAqdGhpcyAtIHJoczsgfQorICAgIHRlbXBsYXRlPHR5cGVu YW1lIFQ+IE1lZGlhVGltZSYgb3BlcmF0b3IrPShjb25zdCBUJiByaHMpIHsgcmV0dXJuICp0aGlz ID0gKnRoaXMgKyByaHM7IH0KKyAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBUPiBNZWRpYVRpbWUmIG9w ZXJhdG9yLT0oY29uc3QgVCYgcmhzKSB7IHJldHVybiAqdGhpcyA9ICp0aGlzIC0gcmhzOyB9CiAg ICAgTWVkaWFUaW1lIG9wZXJhdG9yKyhjb25zdCBNZWRpYVRpbWUmIHJocykgY29uc3Q7CiAgICAg TWVkaWFUaW1lIG9wZXJhdG9yLShjb25zdCBNZWRpYVRpbWUmIHJocykgY29uc3Q7CiAgICAgTWVk aWFUaW1lIG9wZXJhdG9yLSgpIGNvbnN0OwogICAgIE1lZGlhVGltZSBvcGVyYXRvciooaW50MzJf dCkgY29uc3Q7CisgICAgTWVkaWFUaW1lIG9wZXJhdG9yKyhjb25zdCBTZWNvbmRzJiBzZWNvbmRz KSBjb25zdCB7IHJldHVybiAqdGhpcyArIE1lZGlhVGltZTo6Y3JlYXRlV2l0aERvdWJsZShzZWNv bmRzLnNlY29uZHMoKSk7IH07CisgICAgTWVkaWFUaW1lIG9wZXJhdG9yLShjb25zdCBTZWNvbmRz JiBzZWNvbmRzKSBjb25zdCB7IHJldHVybiAqdGhpcyAtIE1lZGlhVGltZTo6Y3JlYXRlV2l0aERv dWJsZShzZWNvbmRzLnNlY29uZHMoKSk7IH07CiAgICAgYm9vbCBvcGVyYXRvcjwoY29uc3QgTWVk aWFUaW1lJiByaHMpIGNvbnN0IHsgcmV0dXJuIGNvbXBhcmUocmhzKSA9PSBMZXNzVGhhbjsgfQog ICAgIGJvb2wgb3BlcmF0b3I+KGNvbnN0IE1lZGlhVGltZSYgcmhzKSBjb25zdCB7IHJldHVybiBj b21wYXJlKHJocykgPT0gR3JlYXRlclRoYW47IH0KICAgICBib29sIG9wZXJhdG9yIT0oY29uc3Qg TWVkaWFUaW1lJiByaHMpIGNvbnN0IHsgcmV0dXJuIGNvbXBhcmUocmhzKSAhPSBFcXVhbFRvOyB9 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIv TWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2dzdHJlYW1lci9NZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXIuY3BwCmluZGV4 IDUzZDU2ZjhlOTUwODM0Mjg4MzdjZWMxOGE0MTBhYzU4NDFiMGUwMjYuLmI1MGE3NGNkNjFiNmJl MzhjZTgwMDI2OWYzNzQ0NDU1ZmI1OTNiMzQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9NZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXIuY3Bw CisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9NZWRpYVBs YXllclByaXZhdGVHU3RyZWFtZXIuY3BwCkBAIC0yMjgyLDcgKzIyODIsOCBAQCB2b2lkIE1lZGlh UGxheWVyUHJpdmF0ZUdTdHJlYW1lcjo6dXBkYXRlQnVmZmVyaW5nU3RhdHVzKEdzdEJ1ZmZlcmlu Z01vZGUgbW9kZSwgZAogewogICAgIEdTVF9ERUJVR19PQkpFQ1QocGlwZWxpbmUoKSwgIltCdWZm ZXJpbmddIG1vZGU6ICVzLCBzdGF0dXM6ICVmJSUiLCBlbnVtVG9TdHJpbmcoR1NUX1RZUEVfQlVG RkVSSU5HX01PREUsIG1vZGUpLmRhdGEoKSwgcGVyY2VudGFnZSk7CiAKLSAgICBtX2RpZERvd25s b2FkRmluaXNoID0gcGVyY2VudGFnZSA9PSAxMDA7CisgICAgbV9kaWREb3dubG9hZEZpbmlzaCA9 IHBlcmNlbnRhZ2UgPT0gMTAwICYmICghV0VCS0lUX0lTX1dFQl9TUkMobV9zb3VyY2UuZ2V0KCkp IHx8ICF3ZWJLaXRTcmNJc1dhaXRpbmdGb3JEYXRhKFdFQktJVF9XRUJfU1JDX0NBU1QobV9zb3Vy Y2UuZ2V0KCkpKSk7CisgICAgR1NUX1RSQUNFX09CSkVDVChwaXBlbGluZSgpLCAiZGlkIGRvd25s b2FkIGZpbmlzaCAlcyIsIGJvb2xGb3JQcmludGluZyhtX2RpZERvd25sb2FkRmluaXNoKSk7CiAg ICAgbV9pc0J1ZmZlcmluZyA9ICFtX2RpZERvd25sb2FkRmluaXNoOwogCiAgICAgc3dpdGNoICht b2RlKSB7CkBAIC0yMjkwLDcgKzIyOTEsNyBAQCB2b2lkIE1lZGlhUGxheWVyUHJpdmF0ZUdTdHJl YW1lcjo6dXBkYXRlQnVmZmVyaW5nU3RhdHVzKEdzdEJ1ZmZlcmluZ01vZGUgbW9kZSwgZAogICAg ICAgICB1cGRhdGVNYXhUaW1lTG9hZGVkKHBlcmNlbnRhZ2UpOwogCiAgICAgICAgIG1fYnVmZmVy aW5nUGVyY2VudGFnZSA9IHBlcmNlbnRhZ2U7Ci0gICAgICAgIGlmIChtX2RpZERvd25sb2FkRmlu aXNoKQorICAgICAgICBpZiAocGVyY2VudGFnZSA9PSAxMDApCiAgICAgICAgICAgICB1cGRhdGVT dGF0ZXMoKTsKIAogICAgICAgICBicmVhazsKQEAgLTI1NjIsNiArMjU2Myw3IEBAIHZvaWQgTWVk aWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyOjp1cGRhdGVTdGF0ZXMoKQogICAgICAgICAgICAgbV9u ZXR3b3JrU3RhdGUgPSBNZWRpYVBsYXllcjo6TmV0d29ya1N0YXRlOjpFbXB0eTsKICAgICAgICAg ICAgIGJyZWFrOwogICAgICAgICBjYXNlIEdTVF9TVEFURV9QQVVTRUQ6CisgICAgICAgICAgICBG QUxMVEhST1VHSDsKICAgICAgICAgY2FzZSBHU1RfU1RBVEVfUExBWUlORzoKICAgICAgICAgICAg IGlmIChtX2lzQnVmZmVyaW5nKSB7CiAgICAgICAgICAgICAgICAgaWYgKG1fYnVmZmVyaW5nUGVy Y2VudGFnZSA9PSAxMDApIHsKQEAgLTI4NjUsNiArMjg2Nyw5IEBAIHZvaWQgTWVkaWFQbGF5ZXJQ cml2YXRlR1N0cmVhbWVyOjp1cGRhdGVEb3dubG9hZEJ1ZmZlcmluZ0ZsYWcoKQogICAgIH0KIAog ICAgIGJvb2wgc2hvdWxkRG93bmxvYWQgPSAhbV9pc0xpdmVTdHJlYW0gJiYgbV9wcmVsb2FkID09 IE1lZGlhUGxheWVyOjpQcmVsb2FkOjpBdXRvOworICAgIEFTU0VSVChtX3NvdXJjZSk7CisgICAg aWYgKFdFQktJVF9JU19XRUJfU1JDKG1fc291cmNlLmdldCgpKSkKKyAgICAgICAgd2ViS2l0V2Vi U3JjU2V0T25EaXNrQnVmZmVyaW5nRW5hYmxlZChXRUJLSVRfV0VCX1NSQ19DQVNUKG1fc291cmNl LmdldCgpKSwgc2hvdWxkRG93bmxvYWQpOwogICAgIGlmIChzaG91bGREb3dubG9hZCkgewogICAg ICAgICBHU1RfSU5GT19PQkpFQ1QocGlwZWxpbmUoKSwgIkVuYWJsaW5nIG9uLWRpc2sgYnVmZmVy aW5nIik7CiAgICAgICAgIGdfb2JqZWN0X3NldChtX3BpcGVsaW5lLmdldCgpLCAiZmxhZ3MiLCBm bGFncyB8IGZsYWdEb3dubG9hZCwgbnVsbHB0cik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvV2ViS2l0V2ViU291cmNlR1N0cmVhbWVyLmNw cCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9XZWJLaXRXZWJT b3VyY2VHU3RyZWFtZXIuY3BwCmluZGV4IGFlZGJmNjg2ZjA0YmYwOWU3MmQyZDNiNDc0N2M4YmQ5 ZTdmNDllNzAuLmRiNDRiNmQzZGI1ODY3YzJjMWNjZjViZDQ5NDk4ZWYzYjFiOWMzZmMgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9XZWJLaXRX ZWJTb3VyY2VHU3RyZWFtZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2dzdHJlYW1lci9XZWJLaXRXZWJTb3VyY2VHU3RyZWFtZXIuY3BwCkBAIC0yOCwxMiArMjgs MTQgQEAKICNpbmNsdWRlICJNYWluVGhyZWFkTm90aWZpZXIuaCIKICNpbmNsdWRlICJNZWRpYVBs YXllci5oIgogI2luY2x1ZGUgIlBsYXRmb3JtTWVkaWFSZXNvdXJjZUxvYWRlci5oIgorI2luY2x1 ZGUgIlBsYXRmb3JtVGltZVJhbmdlcy5oIgogI2luY2x1ZGUgIlJlc291cmNlRXJyb3IuaCIKICNp bmNsdWRlICJSZXNvdXJjZVJlcXVlc3QuaCIKICNpbmNsdWRlICJSZXNvdXJjZVJlc3BvbnNlLmgi CiAjaW5jbHVkZSA8Y3N0ZGludD4KICNpbmNsdWRlIDx3dGYvQ29uZGl0aW9uLmg+CiAjaW5jbHVk ZSA8d3RmL1Njb3BlLmg+CisjaW5jbHVkZSA8d3RmL1N0cmluZ1ByaW50U3RyZWFtLmg+CiAjaW5j bHVkZSA8d3RmL2dsaWIvV1RGR1R5cGUuaD4KICNpbmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+ CiAKQEAgLTUwLDYgKzUyLDExIEBAIHVzaW5nIG5hbWVzcGFjZSBXZWJDb3JlOwogLy8gcmVhY2hl ZCwgdGhlIGRvd25sb2FkIHRhc2sgcmVzdW1lcy4KICNkZWZpbmUgTE9XX1FVRVVFX0ZBQ1RPUl9U SFJFU0hPTEQgMC4yCiAKKy8vIE1pbmltYWwgYnVmZmVyZWQgc2Vjb25kcy4KK3N0YXRpYyBTZWNv bmRzIHNfaW5pdGlhbFdhdGVyTWFya0J1ZmZlcmVkU2Vjb25kcyA9IDE1X3M7CitzdGF0aWMgU2Vj b25kcyBzX2xvd1dhdGVyTWFya0J1ZmZlcmVkU2Vjb25kcyA9IDI1X3M7CitzdGF0aWMgU2Vjb25k cyBzX2hpZ2hXYXRlck1hcmtCdWZmZXJlZFNlY29uZHMgPSAzMF9zOworCiBjbGFzcyBDYWNoZWRS ZXNvdXJjZVN0cmVhbWluZ0NsaWVudCBmaW5hbCA6IHB1YmxpYyBQbGF0Zm9ybU1lZGlhUmVzb3Vy Y2VDbGllbnQgewogICAgIFdURl9NQUtFX0ZBU1RfQUxMT0NBVEVEOwogICAgIFdURl9NQUtFX05P TkNPUFlBQkxFKENhY2hlZFJlc291cmNlU3RyZWFtaW5nQ2xpZW50KTsKQEAgLTcyLDkgKzc5LDkg QEAgcHJpdmF0ZToKICAgICB2b2lkIGxvYWRGaW5pc2hlZChQbGF0Zm9ybU1lZGlhUmVzb3VyY2Um KSBvdmVycmlkZTsKIAogICAgIHN0YXRpYyBjb25zdGV4cHIgaW50IHNfZ3Jvd0Jsb2Nrc2l6ZUxp bWl0IHsgMSB9OwotICAgIHN0YXRpYyBjb25zdGV4cHIgaW50IHNfZ3Jvd0Jsb2Nrc2l6ZUNvdW50 IHsgMSB9OworICAgIHN0YXRpYyBjb25zdGV4cHIgaW50IHNfZ3Jvd0Jsb2Nrc2l6ZUNvdW50IHsg MiB9OwogICAgIHN0YXRpYyBjb25zdGV4cHIgaW50IHNfZ3Jvd0Jsb2Nrc2l6ZUZhY3RvciB7IDIg fTsKLSAgICBzdGF0aWMgY29uc3RleHByIGZsb2F0IHNfcmVkdWNlQmxvY2tzaXplTGltaXQgeyAw LjIwIH07CisgICAgc3RhdGljIGNvbnN0ZXhwciBmbG9hdCBzX3JlZHVjZUJsb2Nrc2l6ZUxpbWl0 IHsgMC41IH07CiAgICAgc3RhdGljIGNvbnN0ZXhwciBpbnQgc19yZWR1Y2VCbG9ja3NpemVDb3Vu dCB7IDIgfTsKICAgICBzdGF0aWMgY29uc3RleHByIGZsb2F0IHNfcmVkdWNlQmxvY2tzaXplRmFj dG9yIHsgMC41IH07CiAgICAgaW50IG1fcmVkdWNlQmxvY2tzaXplQ291bnQgeyAwIH07CkBAIC0x MzcsMTQgKzE0NCwxOCBAQCBzdHJ1Y3QgX1dlYktpdFdlYlNyY1ByaXZhdGUgewogICAgIGJvb2wg aXNTZWVrYWJsZTsKICAgICBib29sIGlzU2Vla2luZzsKICAgICBib29sIHdhc1NlZWtpbmcgeyBm YWxzZSB9OworICAgIGJvb2wgaXNPbkRpc2tCdWZmZXJpbmdFbmFibGVkIHsgZmFsc2UgfTsKKyAg ICBib29sIGlzSW5pdGlhbExvYWQgeyB0cnVlIH07CiAgICAgdW5zaWduZWQgbWluaW11bUJsb2Nr c2l6ZTsKICAgICBMb2NrIGFkYXB0ZXJMb2NrOwogICAgIENvbmRpdGlvbiBhZGFwdGVyQ29uZGl0 aW9uOwotICAgIHVpbnQ2NF90IHF1ZXVlU2l6ZSB7IDAgfTsKICAgICBib29sIGlzRG93bmxvYWRT dXNwZW5kZWQgeyBmYWxzZSB9OwogICAgIEdSZWZQdHI8R3N0QWRhcHRlcj4gYWRhcHRlcjsKICAg ICBHUmVmUHRyPEdzdEV2ZW50PiBodHRwSGVhZGVyc0V2ZW50OwogICAgIEdVbmlxdWVQdHI8R3N0 U3RydWN0dXJlPiBodHRwSGVhZGVyczsKKyAgICBXYWxsVGltZSBkb3dubG9hZFN0YXJ0VGltZSB7 IFdhbGxUaW1lKCkgfTsKKyAgICBndWludCB0b3RhbERvd25sb2FkZWRCeXRlcyB7IDAgfTsKKyAg ICBib29sIGlzV2FpdGluZ0ZvckRhdGEgeyBmYWxzZSB9OwogfTsKIAogZW51bSB7CkBAIC0xNzks NiArMTkwLDkgQEAgc3RhdGljIGdib29sZWFuIHdlYktpdFdlYlNyY1F1ZXJ5KEdzdEJhc2VTcmMq LCBHc3RRdWVyeSopOwogc3RhdGljIGdib29sZWFuIHdlYktpdFdlYlNyY1VuTG9jayhHc3RCYXNl U3JjKik7CiBzdGF0aWMgZ2Jvb2xlYW4gd2ViS2l0V2ViU3JjVW5Mb2NrU3RvcChHc3RCYXNlU3Jj Kik7CiBzdGF0aWMgdm9pZCB3ZWJLaXRXZWJTcmNTZXRDb250ZXh0KEdzdEVsZW1lbnQqLCBHc3RD b250ZXh0Kik7CitzdGF0aWMgdm9pZCByZXN0YXJ0TG9hZGVySWZOZWVkZWQoV2ViS2l0V2ViU3Jj Kik7CitzdGF0aWMgdm9pZCBzdG9wTG9hZGVySWZOZWVkZWQoV2ViS2l0V2ViU3JjKik7CitzdGF0 aWMgV1RGOjpPcHRpb25hbDxib29sPiBXQVJOX1VOVVNFRF9SRVRVUk4gYXJlTmV4dFNlY29uZHNC dWZmZXJlZChXZWJLaXRXZWJTcmMqLCBjb25zdCBTZWNvbmRzJik7CiAKICNkZWZpbmUgd2Via2l0 X3dlYl9zcmNfcGFyZW50X2NsYXNzIHBhcmVudF9jbGFzcwogV0VCS0lUX0RFRklORV9UWVBFX1dJ VEhfQ09ERShXZWJLaXRXZWJTcmMsIHdlYmtpdF93ZWJfc3JjLCBHU1RfVFlQRV9QVVNIX1NSQywK QEAgLTM0NCw2ICszNTgsMTI5IEBAIHN0YXRpYyB2b2lkIHdlYktpdFdlYlNyY1NldENvbnRleHQo R3N0RWxlbWVudCogZWxlbWVudCwgR3N0Q29udGV4dCogY29udGV4dCkKICAgICBHU1RfRUxFTUVO VF9DTEFTUyhwYXJlbnRfY2xhc3MpLT5zZXRfY29udGV4dChlbGVtZW50LCBjb250ZXh0KTsKIH0K IAorc3RhdGljIFdURjo6T3B0aW9uYWw8Ym9vbD4gV0FSTl9VTlVTRURfUkVUVVJOIGFyZU5leHRT ZWNvbmRzQnVmZmVyZWQoV2ViS2l0V2ViU3JjKiBzcmMsIGNvbnN0IFNlY29uZHMmIHNlY29uZHMp Cit7CisgICAgV2ViS2l0V2ViU3JjUHJpdmF0ZSogcHJpdiA9IHNyYy0+cHJpdjsKKworICAgIGlm ICghcHJpdi0+aXNPbkRpc2tCdWZmZXJpbmdFbmFibGVkKQorICAgICAgICByZXR1cm4gV1RGOjpu dWxsb3B0OworCisgICAgTWVkaWFUaW1lIGN1cnJlbnRUaW1lID0gcHJpdi0+cGxheWVyLT5jdXJy ZW50VGltZSgpOworICAgIE1lZGlhVGltZSBkZXNpcmVkQnVmZmVyZWRUaW1lRW5kID0gY3VycmVu dFRpbWUgKyBzZWNvbmRzOworICAgIE1lZGlhVGltZSBkdXJhdGlvbiA9IHByaXYtPnBsYXllci0+ ZHVyYXRpb24oKTsKKyAgICBpZiAoZHVyYXRpb24pCisgICAgICAgIGRlc2lyZWRCdWZmZXJlZFRp bWVFbmQgPSBzdGQ6Om1pbihkdXJhdGlvbiwgZGVzaXJlZEJ1ZmZlcmVkVGltZUVuZCk7CisgICAg YXV0byBidWZmZXJlZFJhbmdlcyA9IHByaXYtPnBsYXllci0+YnVmZmVyZWQoKTsKKworICAgIC8v IEl0IHdvdWxkIGJlIG5pY2UgdG8gY2hlY2sgaWYgdGhlIHdob2xlIHJhbmdlIGlzIGNvbnRhaW5l ZCBpbnN0ZWFkIG9mIHRoaXMgYnV0IHRoZXJlIGFyZSBkZW11eGVycyB0aGF0IHNlZWsgdGhlIHNv dXJjZSBhbmQgbGVhdmUgc29tZSBob2xlcyBldmVuCisgICAgLy8gd2hlbiB0aGV5IGNhbiBwbGF5 LgorICAgIGJvb2wgcmVzdWx0ID0gYnVmZmVyZWRSYW5nZXMtPmNvbnRhaW4oY3VycmVudFRpbWUp ICYmIGJ1ZmZlcmVkUmFuZ2VzLT5jb250YWluKGRlc2lyZWRCdWZmZXJlZFRpbWVFbmQpOworCisg ICAgLy8gUHJpbnRpbmcgdGhpcyBpcyBuaWNlIGJ1dCBjb3N0bHkgc28gbGV0J3MgYXZvaWQgaWYg aXQgaXMgb3V0IG9mIHRoZSB0aHJlc2hvbGQuCisgICAgc3RhdGljIEdzdERlYnVnTGV2ZWwgZ3N0 RGVidWdMZXZlbCA9IGdzdF9kZWJ1Z19jYXRlZ29yeV9nZXRfdGhyZXNob2xkKHdlYmtpdF93ZWJf c3JjX2RlYnVnKTsKKyAgICBpZiAoZ3N0RGVidWdMZXZlbCA+PSBHU1RfTEVWRUxfVFJBQ0UpIHsK KyAgICAgICAgU3RyaW5nUHJpbnRTdHJlYW0gc3RyZWFtOworICAgICAgICBzdHJlYW0ucHJpbnQo ImN1cnJlbnQgdGltZSAiKTsKKyAgICAgICAgc3RyZWFtLnByaW50KGN1cnJlbnRUaW1lKTsKKyAg ICAgICAgc3RyZWFtLnByaW50KCIsICgrIik7CisgICAgICAgIHN0cmVhbS5wcmludChzZWNvbmRz KTsKKyAgICAgICAgc3RyZWFtLnByaW50KCI9KSAiKTsKKyAgICAgICAgc3RyZWFtLnByaW50KGN1 cnJlbnRUaW1lICsgc2Vjb25kcyk7CisgICAgICAgIHN0cmVhbS5wcmludCgiLCBkdXJhdGlvbiAi KTsKKyAgICAgICAgc3RyZWFtLnByaW50KHByaXYtPnBsYXllci0+ZHVyYXRpb24oKSk7CisgICAg ICAgIHN0cmVhbS5wcmludCgiLCBkZXNpcmVkIHRpbWUgZW5kICIpOworICAgICAgICBzdHJlYW0u cHJpbnQoZGVzaXJlZEJ1ZmZlcmVkVGltZUVuZCk7CisgICAgICAgIHN0cmVhbS5wcmludCgiLCBi dWZmZXJlZCAiKTsKKyAgICAgICAgYnVmZmVyZWRSYW5nZXMtPmR1bXAoc3RyZWFtKTsKKyAgICAg ICAgc3RyZWFtLnByaW50KCIsIHJlc3VsdCAiKTsKKyAgICAgICAgc3RyZWFtLnByaW50KHJlc3Vs dCk7CisKKyAgICAgICAgR1NUX1RSQUNFX09CSkVDVChzcmMsICIlcyIsIHN0cmVhbS50b0NTdHJp bmcoKS5kYXRhKCkpOworICAgIH0KKworICAgIHJldHVybiBtYWtlT3B0aW9uYWwocmVzdWx0KTsK K30KKworc3RhdGljIHZvaWQgcmVzdGFydExvYWRlcklmTmVlZGVkKFdlYktpdFdlYlNyYyogc3Jj KQoreworICAgIFdlYktpdFdlYlNyY1ByaXZhdGUqIHByaXYgPSBzcmMtPnByaXY7CisKKyAgICBp ZiAoIXByaXYtPmlzRG93bmxvYWRTdXNwZW5kZWQpIHsKKyAgICAgICAgR1NUX1RSQUNFX09CSkVD VChzcmMsICJkb3dubG9hZCBhbHJlYWR5IGFjdGl2ZSIpOworICAgICAgICByZXR1cm47CisgICAg fQorCisgICAgR1NUX1RSQUNFX09CSkVDVChzcmMsICJpcyBkb3dubG9hZCBzdXNwZW50ZWQgJXMs IGRvZXMgaGF2ZSBFT1MgJXMsIGRvZXMgaGF2ZSBzaXplICVzLCBpcyBzZWVrYWJsZSAlcywgc2l6 ZSAlIiBHX0dVSU5UNjRfRk9STUFUCisgICAgICAgICIgKG1pbiAldSksIHJlYWQgcG9zaXRpb24g JSIgR19HVUlOVDY0X0ZPUk1BVCAiLCBzdGF0ZSAlcyIsIGJvb2xGb3JQcmludGluZyhwcml2LT5p c0Rvd25sb2FkU3VzcGVuZGVkKSwgYm9vbEZvclByaW50aW5nKHByaXYtPmRvZXNIYXZlRU9TKQor ICAgICAgICAsIGJvb2xGb3JQcmludGluZyhwcml2LT5oYXZlU2l6ZSksIGJvb2xGb3JQcmludGlu Zyhwcml2LT5pc1NlZWthYmxlKSwgcHJpdi0+c2l6ZSwgU01BTExfTUVESUFfUkVTT1VSQ0VfTUFY X1NJWkUsIHByaXYtPnJlYWRQb3NpdGlvbgorICAgICAgICAsIGdzdF9lbGVtZW50X3N0YXRlX2dl dF9uYW1lKEdTVF9TVEFURShzcmMpKSk7CisgICAgaWYgKHByaXYtPmRvZXNIYXZlRU9TIHx8ICFw cml2LT5oYXZlU2l6ZSB8fCAhcHJpdi0+aXNTZWVrYWJsZSB8fCBwcml2LT5zaXplIDw9IFNNQUxM X01FRElBX1JFU09VUkNFX01BWF9TSVpFIHx8ICFwcml2LT5yZWFkUG9zaXRpb24KKyAgICAgICAg fHwgcHJpdi0+cmVhZFBvc2l0aW9uID09IHByaXYtPnNpemUgfHwgR1NUX1NUQVRFKHNyYykgPCBH U1RfU1RBVEVfUEFVU0VEKSB7CisgICAgICAgIEdTVF9UUkFDRV9PQkpFQ1Qoc3JjLCAiY2FuJ3Qg cmVzdGFydCBkb3dubG9hZCIpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgYXV0byBp c0Vub3VnaFRpbWVCdWZmZXJlZCA9IGFyZU5leHRTZWNvbmRzQnVmZmVyZWQoc3JjLCBzX2xvd1dh dGVyTWFya0J1ZmZlcmVkU2Vjb25kcyk7CisgICAgc2l6ZV90IHF1ZXVlU2l6ZSA9IGdzdF9hZGFw dGVyX2F2YWlsYWJsZShwcml2LT5hZGFwdGVyLmdldCgpKTsKKyAgICBHU1RfVFJBQ0VfT0JKRUNU KHNyYywgImlzIGVub3VnaCB0aW1lIGJ1ZmZlcmVkICVzLCBxdWV1ZSBzaXplICUiIEdfR1VJTlQ2 NF9GT1JNQVQgIiAobWluICUxLjBsZikiCisgICAgICAgICwgaXNFbm91Z2hUaW1lQnVmZmVyZWQu aGFzVmFsdWUoKSA/IGJvb2xGb3JQcmludGluZyhpc0Vub3VnaFRpbWVCdWZmZXJlZC52YWx1ZSgp KSA6ICJ1bmtub3duIiwgcXVldWVTaXplCisgICAgICAgICwgcHJpdi0+c2l6ZSAqIEhJR0hfUVVF VUVfRkFDVE9SX1RIUkVTSE9MRCAqIExPV19RVUVVRV9GQUNUT1JfVEhSRVNIT0xEKTsKKworICAg IGlmIChpc0Vub3VnaFRpbWVCdWZmZXJlZC5oYXNWYWx1ZSgpKSB7CisgICAgICAgIGlmIChpc0Vu b3VnaFRpbWVCdWZmZXJlZC52YWx1ZSgpKSB7CisgICAgICAgICAgICBHU1RfVFJBQ0VfT0JKRUNU KHNyYywgImVub3VnaCBidWZmZXJlZCwgbm90IHJlc3RhcnRpbmcgZG93bmxvYWQiKTsKKyAgICAg ICAgICAgIHJldHVybjsKKyAgICAgICAgfQorICAgIH0gZWxzZSBpZiAocXVldWVTaXplID49IHBy aXYtPnNpemUgKiBISUdIX1FVRVVFX0ZBQ1RPUl9USFJFU0hPTEQgKiBMT1dfUVVFVUVfRkFDVE9S X1RIUkVTSE9MRCkgeworICAgICAgICBHU1RfVFJBQ0VfT0JKRUNUKHNyYywgInF1ZXVlIHNpemUg YWJvdmUgbG93IHdhdGVybWFyaywgbm90IHJlc3RhcnRpbmcgZG93bmxvYWQiKTsKKyAgICAgICAg cmV0dXJuOworICAgIH0KKworICAgIEdTVF9ERUJVR19PQkpFQ1Qoc3JjLCAicmVzdGFydGluZyBk b3dubG9hZCIpOworICAgIHByaXYtPmlzRG93bmxvYWRTdXNwZW5kZWQgPSBmYWxzZTsKKyAgICB3 ZWJLaXRXZWJTcmNNYWtlUmVxdWVzdChHU1RfQkFTRV9TUkNfQ0FTVChzcmMpLCBmYWxzZSk7Cit9 CisKKworc3RhdGljIHZvaWQgc3RvcExvYWRlcklmTmVlZGVkKFdlYktpdFdlYlNyYyogc3JjKQor eworICAgIFdlYktpdFdlYlNyY1ByaXZhdGUqIHByaXYgPSBzcmMtPnByaXY7CisKKyAgICBpZiAo cHJpdi0+aXNEb3dubG9hZFN1c3BlbmRlZCkgeworICAgICAgICBHU1RfVFJBQ0VfT0JKRUNUKHNy YywgImRvd25sb2FkIGFscmVhZHkgc3VzcGVuZGVkIik7CisgICAgICAgIHJldHVybjsKKyAgICB9 CisKKyAgICBHU1RfVFJBQ0VfT0JKRUNUKHNyYywgImlzIGRvd25sb2FkIHN1c3BlbmRlZCAlcywg ZG9lcyBoYXZlIHNpemUgJXMsIGlzIHNlZWthYmxlICVzLCBzaXplICUiIEdfR1VJTlQ2NF9GT1JN QVQgIiAobWluICV1KSIKKyAgICAgICAgLCBib29sRm9yUHJpbnRpbmcocHJpdi0+aXNEb3dubG9h ZFN1c3BlbmRlZCksIGJvb2xGb3JQcmludGluZyhwcml2LT5oYXZlU2l6ZSksIGJvb2xGb3JQcmlu dGluZyhwcml2LT5pc1NlZWthYmxlKSwgcHJpdi0+c2l6ZQorICAgICAgICAsIFNNQUxMX01FRElB X1JFU09VUkNFX01BWF9TSVpFKTsKKyAgICBpZiAoIXByaXYtPmhhdmVTaXplIHx8ICFwcml2LT5p c1NlZWthYmxlIHx8IHByaXYtPnNpemUgPD0gU01BTExfTUVESUFfUkVTT1VSQ0VfTUFYX1NJWkUp IHsKKyAgICAgICAgR1NUX1RSQUNFX09CSkVDVChzcmMsICJub3Qgc3RvcHBpbmcgZG93bmxvYWQi KTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIGF1dG8gaXNFbm91Z2hUaW1lQnVmZmVy ZWQgPSBhcmVOZXh0U2Vjb25kc0J1ZmZlcmVkKHNyYywgcHJpdi0+aXNJbml0aWFsTG9hZCA/IHNf aW5pdGlhbFdhdGVyTWFya0J1ZmZlcmVkU2Vjb25kcyA6IHNfaGlnaFdhdGVyTWFya0J1ZmZlcmVk U2Vjb25kcyk7CisgICAgc2l6ZV90IHF1ZXVlU2l6ZSA9IGdzdF9hZGFwdGVyX2F2YWlsYWJsZShw cml2LT5hZGFwdGVyLmdldCgpKTsKKyAgICBHU1RfVFJBQ0VfT0JKRUNUKHNyYywgImlzIGVub3Vn aCB0aW1lIGJ1ZmZlcmVkICVzIChpcyBpbml0aWFsIGxvYWQgJXMpLCBxdWV1ZSBzaXplICUiIEdf R1VJTlQ2NF9GT1JNQVQgIiAobWF4ICUxLjBsZikiCisgICAgICAgICwgaXNFbm91Z2hUaW1lQnVm ZmVyZWQuaGFzVmFsdWUoKSA/IGJvb2xGb3JQcmludGluZyhpc0Vub3VnaFRpbWVCdWZmZXJlZC52 YWx1ZSgpKSA6ICJ1bmtub3duIiwgYm9vbEZvclByaW50aW5nKHByaXYtPmlzSW5pdGlhbExvYWQp CisgICAgICAgICwgcXVldWVTaXplLCBwcml2LT5zaXplICogSElHSF9RVUVVRV9GQUNUT1JfVEhS RVNIT0xEKTsKKyAgICBpZiAoaXNFbm91Z2hUaW1lQnVmZmVyZWQuaGFzVmFsdWUoKSkgeworICAg ICAgICBpZiAoIWlzRW5vdWdoVGltZUJ1ZmZlcmVkLnZhbHVlKCkpIHsKKyAgICAgICAgICAgIEdT VF9UUkFDRV9PQkpFQ1Qoc3JjLCAibm90IGVub3VnaCBidWZmZXJlZCwgbm90IHN0b3BwaW5nIGRv d25sb2FkIik7CisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0KKyAgICB9IGVsc2UgaWYg KHF1ZXVlU2l6ZSA8PSBwcml2LT5zaXplICogSElHSF9RVUVVRV9GQUNUT1JfVEhSRVNIT0xEKSB7 CisgICAgICAgIEdTVF9UUkFDRV9PQkpFQ1Qoc3JjLCAicXVldWUgc2l6ZSB1bmRlciBoaWdoIHdh dGVybWFyaywgbm90IHN0b3BwaW5nIGRvd25sb2FkIik7CisgICAgICAgIHJldHVybjsKKyAgICB9 CisKKyAgICBHU1RfREVCVUdfT0JKRUNUKHNyYywgInN0b3BwaW5nIGRvd25sb2FkIik7CisgICAg cHJpdi0+aXNJbml0aWFsTG9hZCA9IGZhbHNlOworICAgIHByaXYtPmlzRG93bmxvYWRTdXNwZW5k ZWQgPSB0cnVlOworICAgIHByaXYtPnJlc291cmNlLT5zdG9wKCk7CisgICAgcHJpdi0+ZG93bmxv YWRTdGFydFRpbWUgPSBXYWxsVGltZSgpOworfQorCiBzdGF0aWMgR3N0Rmxvd1JldHVybiB3ZWJL aXRXZWJTcmNDcmVhdGUoR3N0UHVzaFNyYyogcHVzaFNyYywgR3N0QnVmZmVyKiogYnVmZmVyKQog ewogICAgIEdzdEJhc2VTcmMqIGJhc2VTcmMgPSBHU1RfQkFTRV9TUkNfQ0FTVChwdXNoU3JjKTsK QEAgLTM1Nyw4ICs0OTQsNyBAQCBzdGF0aWMgR3N0Rmxvd1JldHVybiB3ZWJLaXRXZWJTcmNDcmVh dGUoR3N0UHVzaFNyYyogcHVzaFNyYywgR3N0QnVmZmVyKiogYnVmZmVyKQogICAgICAgICAgICAg TG9ja0hvbGRlciBhZGFwdGVyTG9ja2VyKHByaXYtPmFkYXB0ZXJMb2NrKTsKICAgICAgICAgICAg IEdTVF9ERUJVR19PQkpFQ1Qoc3JjLCAiU2Vla2luZywgZmx1c2hpbmcgYWRhcHRlciIpOwogICAg ICAgICAgICAgLy8gRGlzY2FyZCBhbGwgdGhlIGJ1ZmZlcnMgY29taW5nIGJlZm9yZSB0aGUgcmVx dWVzdGVkIHNlZWsgcG9zaXRpb24uCi0gICAgICAgICAgICBnc3RfYWRhcHRlcl9mbHVzaChwcml2 LT5hZGFwdGVyLmdldCgpLCBwcml2LT5xdWV1ZVNpemUpOwotICAgICAgICAgICAgcHJpdi0+cXVl dWVTaXplID0gMDsKKyAgICAgICAgICAgIGdzdF9hZGFwdGVyX2NsZWFyKHByaXYtPmFkYXB0ZXIu Z2V0KCkpOwogICAgICAgICB9CiAgICAgICAgIHVpbnQ2NF90IHJlcXVlc3RlZFBvc2l0aW9uID0g cHJpdi0+cmVxdWVzdGVkUG9zaXRpb247CiAgICAgICAgIHdlYktpdFdlYlNyY1N0b3AoYmFzZVNy Yyk7CkBAIC0zNzgsMTQgKzUxNCw5IEBAIHN0YXRpYyBHc3RGbG93UmV0dXJuIHdlYktpdFdlYlNy Y0NyZWF0ZShHc3RQdXNoU3JjKiBwdXNoU3JjLCBHc3RCdWZmZXIqKiBidWZmZXIpCiAgICAgICAg IH0pOwogICAgIH0KIAotICAgIEdTVF9UUkFDRV9PQkpFQ1Qoc3JjLCAiZmx1c2hpbmc6ICVzLCBk b2VzSGF2ZUVPUzogJXMsIHF1ZXVlU2l6ZTogJSIgR19HVUlOVDY0X0ZPUk1BVCAiLCBpc0Rvd25s b2FkU3VzcGVuZGVkOiAlcyIsCi0gICAgICAgIGJvb2xGb3JQcmludGluZyhwcml2LT5pc0ZsdXNo aW5nKSwgYm9vbEZvclByaW50aW5nKHByaXYtPmRvZXNIYXZlRU9TKSwgcHJpdi0+cXVldWVTaXpl LAotICAgICAgICBib29sRm9yUHJpbnRpbmcocHJpdi0+aXNEb3dubG9hZFN1c3BlbmRlZCkpOwot Ci0gICAgaWYgKHByaXYtPmlzRmx1c2hpbmcpIHsKLSAgICAgICAgR1NUX0RFQlVHX09CSkVDVChz cmMsICJGbHVzaGluZyIpOwotICAgICAgICByZXR1cm4gR1NUX0ZMT1dfRkxVU0hJTkc7Ci0gICAg fQorICAgIHNpemVfdCBxdWV1ZVNpemUgPSBnc3RfYWRhcHRlcl9hdmFpbGFibGUocHJpdi0+YWRh cHRlci5nZXQoKSk7CisgICAgR1NUX1RSQUNFX09CSkVDVChzcmMsICJmbHVzaGluZzogJXMsIGRv ZXNIYXZlRU9TOiAlcywgcXVldWVTaXplOiAlbHUsIGlzRG93bmxvYWRTdXNwZW5kZWQ6ICVzIiwg Ym9vbEZvclByaW50aW5nKHByaXYtPmlzRmx1c2hpbmcpCisgICAgICAgICwgYm9vbEZvclByaW50 aW5nKHByaXYtPmRvZXNIYXZlRU9TKSwgcXVldWVTaXplLCBib29sRm9yUHJpbnRpbmcocHJpdi0+ aXNEb3dubG9hZFN1c3BlbmRlZCkpOwogCiAgICAgaWYgKHByaXYtPmRvZXNIYXZlRU9TKSB7CiAg ICAgICAgIEdTVF9ERUJVR19PQkpFQ1Qoc3JjLCAiRU9TIik7CkBAIC0zOTcsMjMgKzUyOCw0NiBA QCBzdGF0aWMgR3N0Rmxvd1JldHVybiB3ZWJLaXRXZWJTcmNDcmVhdGUoR3N0UHVzaFNyYyogcHVz aFNyYywgR3N0QnVmZmVyKiogYnVmZmVyKQogICAgIHsKICAgICAgICAgTG9ja0hvbGRlciBhZGFw dGVyTG9ja2VyKHByaXYtPmFkYXB0ZXJMb2NrKTsKICAgICAgICAgdW5zaWduZWQgcmV0cmllcyA9 IDA7Ci0gICAgICAgIHNpemVfdCBhdmFpbGFibGUgPSBnc3RfYWRhcHRlcl9hdmFpbGFibGVfZmFz dChwcml2LT5hZGFwdGVyLmdldCgpKTsKLSAgICAgICAgd2hpbGUgKGF2YWlsYWJsZSA8IHNpemUg JiYgIWlzQWRhcHRlckRyYWluZWQpIHsKLSAgICAgICAgICAgIHByaXYtPmFkYXB0ZXJDb25kaXRp b24ud2FpdEZvcihwcml2LT5hZGFwdGVyTG9jaywgMTAwX21zLCBbJl0gewotICAgICAgICAgICAg ICAgIHJldHVybiBnc3RfYWRhcHRlcl9hdmFpbGFibGVfZmFzdChwcml2LT5hZGFwdGVyLmdldCgp KSA+PSBzaXplOwotICAgICAgICAgICAgfSk7Ci0gICAgICAgICAgICByZXRyaWVzKys7Ci0gICAg ICAgICAgICBhdmFpbGFibGUgPSBnc3RfYWRhcHRlcl9hdmFpbGFibGVfZmFzdChwcml2LT5hZGFw dGVyLmdldCgpKTsKLSAgICAgICAgICAgIGlmIChhdmFpbGFibGUgJiYgYXZhaWxhYmxlIDwgc2l6 ZSkgewotICAgICAgICAgICAgICAgIEdTVF9UUkFDRV9PQkpFQ1Qoc3JjLCAiZGlkIG5vdCBnZXQg dGhlICV1IGJsb2Nrc2l6ZSBieXRlcywgbGV0J3MgcHVzaCB0aGUgJSIgR19HU0laRV9GT1JNQVQg IiBieXRlcyB3ZSBnb3QiLCBzaXplLCBhdmFpbGFibGUpOwotICAgICAgICAgICAgICAgIHNpemUg PSBhdmFpbGFibGU7Ci0gICAgICAgICAgICB9IGVsc2UgaWYgKHJldHJpZXMgPiAzKQorICAgICAg ICBxdWV1ZVNpemUgPSBnc3RfYWRhcHRlcl9hdmFpbGFibGUocHJpdi0+YWRhcHRlci5nZXQoKSk7 CisgICAgICAgIEdTVF9UUkFDRV9PQkpFQ1Qoc3JjLCAiYXZhaWxhYmxlICUiIEdfR1NJWkVfRk9S TUFUICIsIGJsb2NrIHNpemUgJXUiLCBxdWV1ZVNpemUsIHNpemUpOworICAgICAgICB3aGlsZSAo cXVldWVTaXplIDwgc2l6ZSAmJiAhaXNBZGFwdGVyRHJhaW5lZCAmJiAhcHJpdi0+aXNGbHVzaGlu ZykgeworICAgICAgICAgICAgaWYgKCFxdWV1ZVNpemUpIHsKKyAgICAgICAgICAgICAgICAvLyBQ b3NpdGlvbiBpcyBub3QgZ29pbmcgdG8gbW92ZSB3aGVuIGRvd25sb2FkIGlzIHN1c3BlbmRlZCBh bmQgd2UgYXJlIFBBVVNFRCwgc28gd2UgY2FuIGJsb2NrIGhlcmUgd2l0aG91dCBjaGVja2luZyB0 aGUgcG9zaXRpb24uCisgICAgICAgICAgICAgICAgaWYgKHByaXYtPmlzRG93bmxvYWRTdXNwZW5k ZWQgJiYgIXByaXYtPmlzU2Vla2luZyAmJiBHU1RfU1RBVEUoc3JjKSA8IEdTVF9TVEFURV9QTEFZ SU5HKSB7CisgICAgICAgICAgICAgICAgICAgIEdTVF9ERUJVR19PQkpFQ1Qoc3JjLCAiYmxvY2tp bmcgdW50aWwgcG9zaXRpb24gbW92ZXMiKTsKKyAgICAgICAgICAgICAgICAgICAgcHJpdi0+YWRh cHRlckNvbmRpdGlvbi53YWl0KHByaXYtPmFkYXB0ZXJMb2NrLCBbJl0geworICAgICAgICAgICAg ICAgICAgICAgICAgcmV0dXJuIHByaXYtPmlzU2Vla2luZyB8fCBwcml2LT5pc0ZsdXNoaW5nIHx8 IEdTVF9TVEFURShzcmMpID09IEdTVF9TVEFURV9QTEFZSU5HOworICAgICAgICAgICAgICAgICAg ICB9KTsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgR1NUX1RSQUNFX09CSkVD VChzcmMsICJub3QgZW5vdWdoIGRhdGEsIGxldCdzIHdhaXQgYSBiaXQiKTsKKyAgICAgICAgICAg ICAgICBwcml2LT5pc1dhaXRpbmdGb3JEYXRhID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICBwcml2 LT5hZGFwdGVyQ29uZGl0aW9uLndhaXRGb3IocHJpdi0+YWRhcHRlckxvY2ssIDFfcywgWyZdIHsK KyAgICAgICAgICAgICAgICAgICAgcmVzdGFydExvYWRlcklmTmVlZGVkKHNyYyk7CisgICAgICAg ICAgICAgICAgICAgIHJldHVybiBwcml2LT5pc0ZsdXNoaW5nIHx8ICghcHJpdi0+aXNEb3dubG9h ZFN1c3BlbmRlZCAmJiBnc3RfYWRhcHRlcl9hdmFpbGFibGUocHJpdi0+YWRhcHRlci5nZXQoKSkp OworICAgICAgICAgICAgICAgIH0pOworICAgICAgICAgICAgICAgIHByaXYtPmlzV2FpdGluZ0Zv ckRhdGEgPSBmYWxzZTsKKyAgICAgICAgICAgICAgICBxdWV1ZVNpemUgPSBnc3RfYWRhcHRlcl9h dmFpbGFibGUocHJpdi0+YWRhcHRlci5nZXQoKSk7CisgICAgICAgICAgICB9CisgICAgICAgICAg ICBHU1RfVFJBQ0VfT0JKRUNUKHNyYywgImlzIGRvd25sb2FkIHN1c3BlbmRlZCAlcywgYXZhaWxh YmxlICUiIEdfR1NJWkVfRk9STUFUICIsIHRyaWVkICV1IiwgYm9vbEZvclByaW50aW5nKHByaXYt PmlzRG93bmxvYWRTdXNwZW5kZWQpCisgICAgICAgICAgICAgICAgLCBxdWV1ZVNpemUsIHJldHJp ZXMgKyAxKTsKKyAgICAgICAgICAgIGlmIChxdWV1ZVNpemUgJiYgcXVldWVTaXplIDwgc2l6ZSkg eworICAgICAgICAgICAgICAgIEdTVF9UUkFDRV9PQkpFQ1Qoc3JjLCAiZGlkIG5vdCBnZXQgdGhl ICV1IGJsb2Nrc2l6ZSBieXRlcywgbGV0J3MgcHVzaCB0aGUgJSIgR19HU0laRV9GT1JNQVQgIiBi eXRlcyB3ZSBnb3QiLCBzaXplLCBxdWV1ZVNpemUpOworICAgICAgICAgICAgICAgIHNpemUgPSBx dWV1ZVNpemU7CisgICAgICAgICAgICB9IGVsc2UgaWYgKHByaXYtPmhhdmVTaXplICYmIHByaXYt PnJlYWRQb3NpdGlvbiA+PSBwcml2LT5zaXplKSB7CisgICAgICAgICAgICAgICAgR1NUX0RFQlVH X09CSkVDVChzcmMsICJXYWl0aW5nIGZvciBkYXRhIGJleW9uZCB0aGUgZW5kLCBzaWduYWxsaW5n IEVPUyIpOworICAgICAgICAgICAgICAgIHJldHVybiBHU1RfRkxPV19FT1M7CisgICAgICAgICAg ICB9IGVsc2UgaWYgKCFwcml2LT5pc0Rvd25sb2FkU3VzcGVuZGVkICYmICsrcmV0cmllcyA+PSAx MCkKICAgICAgICAgICAgICAgICBpc0FkYXB0ZXJEcmFpbmVkID0gdHJ1ZTsKICAgICAgICAgfQog ICAgIH0KIAorICAgIGlmIChwcml2LT5pc0ZsdXNoaW5nKSB7CisgICAgICAgIEdTVF9ERUJVR19P QkpFQ1Qoc3JjLCAiRmx1c2hpbmciKTsKKyAgICAgICAgcmV0dXJuIEdTVF9GTE9XX0ZMVVNISU5H OworICAgIH0KKwogICAgIGlmIChpc0FkYXB0ZXJEcmFpbmVkKSB7Ci0gICAgICAgIEdTVF9ERUJV R19PQkpFQ1Qoc3JjLCAiQWRhcHRlciBzdGlsbCBlbXB0eSBhZnRlciA0MDAgbWlsbGktc2Vjb25k cyBvZiB3YWl0aW5nLCBhc3N1bWluZyBFT1MiKTsKKyAgICAgICAgR1NUX0RFQlVHX09CSkVDVChz cmMsICJBZGFwdGVyIHN0aWxsIGVtcHR5IGFmdGVyIDEwcyBvZiB3YWl0aW5nLCBhc3N1bWluZyBF T1MiKTsKICAgICAgICAgcmV0dXJuIEdTVF9GTE9XX0VPUzsKICAgICB9CiAKQEAgLTQzMSwxMSAr NTg1LDkgQEAgc3RhdGljIEdzdEZsb3dSZXR1cm4gd2ViS2l0V2ViU3JjQ3JlYXRlKEdzdFB1c2hT cmMqIHB1c2hTcmMsIEdzdEJ1ZmZlcioqIGJ1ZmZlcikKICAgICAgICAgR1NUX1RSQUNFX09CSkVD VChzcmMsICJUYWtpbmcgJXUgYnl0ZXMgZnJvbSBhZGFwdGVyIiwgc2l6ZSk7CiAgICAgICAgIExv Y2tIb2xkZXIgYWRhcHRlckxvY2tlcihwcml2LT5hZGFwdGVyTG9jayk7CiAgICAgICAgIGlmIChz aXplKSB7Ci0gICAgICAgICAgICAqYnVmZmVyID0gZ3N0X2FkYXB0ZXJfdGFrZV9idWZmZXJfZmFz dChwcml2LT5hZGFwdGVyLmdldCgpLCBzaXplKTsKKyAgICAgICAgICAgICpidWZmZXIgPSBnc3Rf YWRhcHRlcl90YWtlX2J1ZmZlcihwcml2LT5hZGFwdGVyLmdldCgpLCBzaXplKTsKICAgICAgICAg ICAgIFJFTEVBU0VfQVNTRVJUKCpidWZmZXIpOwogCi0gICAgICAgICAgICBwcml2LT5xdWV1ZVNp emUgLT0gc2l6ZTsKLQogICAgICAgICAgICAgR1NUX0JVRkZFUl9PRkZTRVQoKmJ1ZmZlcikgPSBi YXNlU3JjLT5zZWdtZW50LnBvc2l0aW9uOwogICAgICAgICAgICAgR1NUX0JVRkZFUl9PRkZTRVRf RU5EKCpidWZmZXIpID0gR1NUX0JVRkZFUl9PRkZTRVQoKmJ1ZmZlcikgKyBzaXplOwogICAgICAg ICAgICAgR1NUX1RSQUNFX09CSkVDVChzcmMsICJCdWZmZXIgYm91bmRzIHNldCB0byAlIiBHX0dV SU5UNjRfRk9STUFUICItJSIgR19HVUlOVDY0X0ZPUk1BVCwgR1NUX0JVRkZFUl9PRkZTRVQoKmJ1 ZmZlciksIEdTVF9CVUZGRVJfT0ZGU0VUX0VORCgqYnVmZmVyKSk7CkBAIC00NDgsMTYgKzYwMCw3 IEBAIHN0YXRpYyBHc3RGbG93UmV0dXJuIHdlYktpdFdlYlNyY0NyZWF0ZShHc3RQdXNoU3JjKiBw dXNoU3JjLCBHc3RCdWZmZXIqKiBidWZmZXIpCiAgICAgICAgICAgICB9IGVsc2UgaWYgKHByaXYt Pndhc1NlZWtpbmcpCiAgICAgICAgICAgICAgICAgcHJpdi0+d2FzU2Vla2luZyA9IGZhbHNlOwog Ci0gICAgICAgICAgICBpZiAoIXByaXYtPmRvZXNIYXZlRU9TICYmIHByaXYtPmhhdmVTaXplICYm IHByaXYtPmlzU2Vla2FibGUKLSAgICAgICAgICAgICAgICAmJiAocHJpdi0+c2l6ZSA+IFNNQUxM X01FRElBX1JFU09VUkNFX01BWF9TSVpFKSAmJiBwcml2LT5yZWFkUG9zaXRpb24KLSAgICAgICAg ICAgICAgICAmJiAocHJpdi0+cmVhZFBvc2l0aW9uICE9IHByaXYtPnNpemUpCi0gICAgICAgICAg ICAgICAgJiYgKHByaXYtPnF1ZXVlU2l6ZSA8IChwcml2LT5zaXplICogSElHSF9RVUVVRV9GQUNU T1JfVEhSRVNIT0xEICogTE9XX1FVRVVFX0ZBQ1RPUl9USFJFU0hPTEQpKQotICAgICAgICAgICAg ICAgICYmIEdTVF9TVEFURShzcmMpID49IEdTVF9TVEFURV9QQVVTRUQgJiYgcHJpdi0+aXNEb3du bG9hZFN1c3BlbmRlZCkgewotICAgICAgICAgICAgICAgIEdTVF9ERUJVR19PQkpFQ1Qoc3JjLCAi W0J1ZmZlcmluZ10gQWRhcHRlciBydW5uaW5nIG91dCBvZiBkYXRhLCByZXN0YXJ0aW5nIGRvd25s b2FkIik7Ci0gICAgICAgICAgICAgICAgcHJpdi0+aXNEb3dubG9hZFN1c3BlbmRlZCA9IGZhbHNl OwotICAgICAgICAgICAgICAgIHdlYktpdFdlYlNyY01ha2VSZXF1ZXN0KGJhc2VTcmMsIGZhbHNl KTsKLSAgICAgICAgICAgIH0KLQorICAgICAgICAgICAgcmVzdGFydExvYWRlcklmTmVlZGVkKHNy Yyk7CiAgICAgICAgIH0gZWxzZQogICAgICAgICAgICAgR1NUX0VSUk9SX09CSkVDVChzcmMsICJF bXB0eSBhZGFwdGVyPyIpOwogICAgIH0KQEAgLTY3MCw3ICs4MTMsNiBAQCBzdGF0aWMgZ2Jvb2xl YW4gd2ViS2l0V2ViU3JjU3RvcChHc3RCYXNlU3JjKiBiYXNlU3JjKQogICAgIHsKICAgICAgICAg TG9ja0hvbGRlciBhZGFwdGVyTG9ja2VyKHByaXYtPmFkYXB0ZXJMb2NrKTsKICAgICAgICAgZ3N0 X2FkYXB0ZXJfY2xlYXIocHJpdi0+YWRhcHRlci5nZXQoKSk7Ci0gICAgICAgIHByaXYtPnF1ZXVl U2l6ZSA9IDA7CiAgICAgfQogCiAgICAgd2Via2l0V2ViU3JjUmVzZXQoc3JjKTsKQEAgLTcyOCw2 ICs4NzAsNyBAQCBzdGF0aWMgZ2Jvb2xlYW4gd2ViS2l0V2ViU3JjRG9TZWVrKEdzdEJhc2VTcmMq IGJhc2VTcmMsIEdzdFNlZ21lbnQqIHNlZ21lbnQpCiAgICAgcHJpdi0+aXNTZWVraW5nID0gdHJ1 ZTsKICAgICBwcml2LT5yZXF1ZXN0ZWRQb3NpdGlvbiA9IHNlZ21lbnQtPnN0YXJ0OwogICAgIHBy aXYtPnN0b3BQb3NpdGlvbiA9IHNlZ21lbnQtPnN0b3A7CisgICAgcHJpdi0+YWRhcHRlckNvbmRp dGlvbi5ub3RpZnlPbmUoKTsKICAgICByZXR1cm4gVFJVRTsKIH0KIApAQCAtNzY2LDYgKzkwOSw3 IEBAIHN0YXRpYyBnYm9vbGVhbiB3ZWJLaXRXZWJTcmNVbkxvY2soR3N0QmFzZVNyYyogYmFzZVNy YykKICAgICBHU1RfREVCVUdfT0JKRUNUKHNyYywgIlVubG9jayIpOwogICAgIHNyYy0+cHJpdi0+ aXNGbHVzaGluZyA9IHRydWU7CiAgICAgc3JjLT5wcml2LT5yZXNwb25zZUNvbmRpdGlvbi5ub3Rp ZnlPbmUoKTsKKyAgICBzcmMtPnByaXYtPmFkYXB0ZXJDb25kaXRpb24ubm90aWZ5T25lKCk7CiAg ICAgcmV0dXJuIFRSVUU7CiB9CiAKQEAgLTc5NSw4ICs5MzksMTQgQEAgc3RhdGljIEdzdFN0YXRl Q2hhbmdlUmV0dXJuIHdlYktpdFdlYlNyY0NoYW5nZVN0YXRlKEdzdEVsZW1lbnQqIGVsZW1lbnQs IEdzdFN0YXQKICAgICAgICAgR1NUX0RFQlVHX09CSkVDVChzcmMsICJQQVVTRUQtPlJFQURZIGNh bmNlbGxpbmcgbmV0d29yayByZXF1ZXN0cyIpOwogICAgICAgICBzcmMtPnByaXYtPmlzRmx1c2hp bmcgPSB0cnVlOwogICAgICAgICBzcmMtPnByaXYtPnJlc3BvbnNlQ29uZGl0aW9uLm5vdGlmeU9u ZSgpOworICAgICAgICBzcmMtPnByaXYtPmFkYXB0ZXJDb25kaXRpb24ubm90aWZ5T25lKCk7CiAg ICAgICAgIGJyZWFrOwotICAgIH0gZGVmYXVsdDoKKyAgICB9CisgICAgY2FzZSBHU1RfU1RBVEVf Q0hBTkdFX1BBVVNFRF9UT19QTEFZSU5HOgorICAgICAgICBzcmMtPnByaXYtPmlzSW5pdGlhbExv YWQgPSBmYWxzZTsKKyAgICAgICAgc3JjLT5wcml2LT5hZGFwdGVyQ29uZGl0aW9uLm5vdGlmeU9u ZSgpOworICAgICAgICBicmVhazsKKyAgICBkZWZhdWx0OgogICAgICAgICBicmVhazsKICAgICB9 CiAKQEAgLTg5NSw2ICsxMDQ1LDEzIEBAIHZvaWQgd2ViS2l0V2ViU3JjU2V0TWVkaWFQbGF5ZXIo V2ViS2l0V2ViU3JjKiBzcmMsIFdlYkNvcmU6Ok1lZGlhUGxheWVyKiBwbGF5ZXIpCiAgICAgc3Jj LT5wcml2LT5wbGF5ZXIgPSBwbGF5ZXI7CiB9CiAKK3ZvaWQgd2ViS2l0V2ViU3JjU2V0T25EaXNr QnVmZmVyaW5nRW5hYmxlZChXZWJLaXRXZWJTcmMqIHNyYywgYm9vbCBpc0VuYWJsZWQpCit7Cisg ICAgQVNTRVJUKHNyYyk7CisgICAgc3JjLT5wcml2LT5pc09uRGlza0J1ZmZlcmluZ0VuYWJsZWQg PSBpc0VuYWJsZWQ7CisgICAgR1NUX1RSQUNFX09CSkVDVChzcmMsICJzZXQgb24gZGlzayBidWZm ZXJpbmcgZW5hYmxlZCB0byAlcyIsIGJvb2xGb3JQcmludGluZyhzcmMtPnByaXYtPmlzT25EaXNr QnVmZmVyaW5nRW5hYmxlZCkpOworfQorCiBib29sIHdlYktpdFNyY1Bhc3NlZENPUlNBY2Nlc3ND aGVjayhXZWJLaXRXZWJTcmMqIHNyYykKIHsKICAgICByZXR1cm4gc3JjLT5wcml2LT5kaWRQYXNz QWNjZXNzQ29udHJvbENoZWNrOwpAQCAtOTE3LDcgKzEwNzQsNyBAQCB2b2lkIENhY2hlZFJlc291 cmNlU3RyZWFtaW5nQ2xpZW50OjpjaGVja1VwZGF0ZUJsb2Nrc2l6ZSh1bnNpZ25lZCBieXRlc1Jl YWQpCiAgICAgdW5zaWduZWQgYmxvY2tzaXplID0gZ3N0X2Jhc2Vfc3JjX2dldF9ibG9ja3NpemUo YmFzZVNyYyk7CiAgICAgR1NUX0xPR19PQkpFQ1Qoc3JjLCAiQ2hlY2tpbmcgdG8gdXBkYXRlIGJs b2Nrc2l6ZS4gUmVhZDogJXUsIGN1cnJlbnQgYmxvY2tzaXplOiAldSIsIGJ5dGVzUmVhZCwgYmxv Y2tzaXplKTsKIAotICAgIGlmIChieXRlc1JlYWQgPj0gYmxvY2tzaXplICogc19ncm93QmxvY2tz aXplTGltaXQpIHsKKyAgICBpZiAoYnl0ZXNSZWFkID4gYmxvY2tzaXplICogc19ncm93QmxvY2tz aXplTGltaXQpIHsKICAgICAgICAgbV9yZWR1Y2VCbG9ja3NpemVDb3VudCA9IDA7CiAgICAgICAg IG1faW5jcmVhc2VCbG9ja3NpemVDb3VudCsrOwogCkBAIC0xMDY5LDYgKzEyMjYsMTYgQEAgdm9p ZCBDYWNoZWRSZXNvdXJjZVN0cmVhbWluZ0NsaWVudDo6ZGF0YVJlY2VpdmVkKFBsYXRmb3JtTWVk aWFSZXNvdXJjZSYsIGNvbnN0IGMKIAogICAgIEdTVF9MT0dfT0JKRUNUKHNyYywgIkhhdmUgJWQg Ynl0ZXMgb2YgZGF0YSIsIGxlbmd0aCk7CiAgICAgTG9ja0hvbGRlciBsb2NrZXIocHJpdi0+cmVz cG9uc2VMb2NrKTsKKyAgICAvLyBSb3VnaCBiYW5kd2lkdGggY2FsY3VsYXRpb24uIFdlIGRvbid0 IGNhbGN1bGF0ZSBzaW5jZSB3ZSBpc3N1ZSB0aGUgcmVxdWVzdCBiZWNhdXNlIHRoYXQgd291bGQg aW5jbHVkZSBzZW5kaW5nIHRoZSByZXF1ZXN0LCBldGMuIFRoaXMgd2F5IHdlIGNhbgorICAgIC8v IGhhdmUgYSBiaXQgbW9yZSBhY2N1cmFjeS4KKyAgICBpZiAocHJpdi0+ZG93bmxvYWRTdGFydFRp bWUpIHsKKyAgICAgICAgcHJpdi0+dG90YWxEb3dubG9hZGVkQnl0ZXMgKz0gbGVuZ3RoOworICAg ICAgICBkb3VibGUgdGltZVNpbmNlU3RhcnQgPSAoV2FsbFRpbWU6Om5vdygpIC0gcHJpdi0+ZG93 bmxvYWRTdGFydFRpbWUpLnNlY29uZHMoKTsKKyAgICAgICAgR1NUX1RSQUNFX09CSkVDVChzcmMs ICJkb3dubG9hZGVkICV1IGJ5dGVzIGluICVsZiBzZWNvbmRzID1+ICUxLjBsZiBieXRlcy9zZWNv bmQiLCBwcml2LT50b3RhbERvd25sb2FkZWRCeXRlcywgdGltZVNpbmNlU3RhcnQsIHByaXYtPnRv dGFsRG93bmxvYWRlZEJ5dGVzIC8gdGltZVNpbmNlU3RhcnQpOworICAgIH0gZWxzZSB7CisgICAg ICAgIHByaXYtPmRvd25sb2FkU3RhcnRUaW1lID0gV2FsbFRpbWU6Om5vdygpOworICAgICAgICBw cml2LT50b3RhbERvd25sb2FkZWRCeXRlcyA9IDA7CisgICAgfQogCiAgICAgdWludDY0X3QgbmV3 UG9zaXRpb24gPSBwcml2LT5yZWFkUG9zaXRpb24gKyBsZW5ndGg7CiAgICAgaWYgKExJS0VMWSAo cHJpdi0+cmVxdWVzdGVkUG9zaXRpb24gPT0gcHJpdi0+cmVhZFBvc2l0aW9uKSkKQEAgLTExMDMs MTggKzEyNzAsOCBAQCB2b2lkIENhY2hlZFJlc291cmNlU3RyZWFtaW5nQ2xpZW50OjpkYXRhUmVj ZWl2ZWQoUGxhdGZvcm1NZWRpYVJlc291cmNlJiwgY29uc3QgYwogICAgIHsKICAgICAgICAgTG9j a0hvbGRlciBhZGFwdGVyTG9ja2VyKHByaXYtPmFkYXB0ZXJMb2NrKTsKICAgICAgICAgR3N0QnVm ZmVyKiBidWZmZXIgPSBnc3RfYnVmZmVyX25ld193cmFwcGVkKGdfbWVtZHVwKGRhdGEsIGxlbmd0 aCksIGxlbmd0aCk7Ci0gICAgICAgIHByaXYtPnF1ZXVlU2l6ZSArPSBsZW5ndGg7CiAgICAgICAg IGdzdF9hZGFwdGVyX3B1c2gocHJpdi0+YWRhcHRlci5nZXQoKSwgYnVmZmVyKTsKLSAgICAgICAg R1NUX1RSQUNFX09CSkVDVChzcmMsICJbQnVmZmVyaW5nXSBpc0Rvd25sb2FkU3VzcGVuZGVkOiAl cyIsIGJvb2xGb3JQcmludGluZyhwcml2LT5pc0Rvd25sb2FkU3VzcGVuZGVkKSk7Ci0gICAgICAg IGlmIChwcml2LT5oYXZlU2l6ZSAmJiAocHJpdi0+c2l6ZSA+IFNNQUxMX01FRElBX1JFU09VUkNF X01BWF9TSVpFKSAmJiAocHJpdi0+cXVldWVTaXplID4gKHByaXYtPnNpemUgKiBISUdIX1FVRVVF X0ZBQ1RPUl9USFJFU0hPTEQpKQotICAgICAgICAgICAgJiYgIXByaXYtPmlzRG93bmxvYWRTdXNw ZW5kZWQgJiYgcHJpdi0+aXNTZWVrYWJsZSkgewotICAgICAgICAgICAgR1NUX1RSQUNFX09CSkVD VChzcmMsICJbQnVmZmVyaW5nXSBxdWV1ZVNpemU6ICUiIEdfR1VJTlQ2NF9GT1JNQVQgIiwgdGhy ZXNob2xkOiAlZiIsIHByaXYtPnF1ZXVlU2l6ZSwKLSAgICAgICAgICAgICAgICBwcml2LT5zaXpl ICogSElHSF9RVUVVRV9GQUNUT1JfVEhSRVNIT0xEKTsKLSAgICAgICAgICAgIEdTVF9ERUJVR19P QkpFQ1Qoc3JjLCAiW0J1ZmZlcmluZ10gU3RvcHBpbmcgcmVzb3VyY2UgbG9hZGVyIik7Ci0gICAg ICAgICAgICBwcml2LT5pc0Rvd25sb2FkU3VzcGVuZGVkID0gdHJ1ZTsKLSAgICAgICAgICAgIHBy aXYtPnJlc291cmNlLT5zdG9wKCk7Ci0gICAgICAgICAgICByZXR1cm47Ci0gICAgICAgIH0KKyAg ICAgICAgc3RvcExvYWRlcklmTmVlZGVkKHNyYyk7CiAgICAgICAgIHByaXYtPmFkYXB0ZXJDb25k aXRpb24ubm90aWZ5T25lKCk7CiAgICAgfQogfQpAQCAtMTE2MCw0ICsxMzE3LDE5IEBAIGJvb2wg d2ViS2l0U3JjV291bGRUYWludE9yaWdpbihXZWJLaXRXZWJTcmMqIHNyYywgY29uc3QgU2VjdXJp dHlPcmlnaW4mIG9yaWdpbikKICAgICByZXR1cm4gZmFsc2U7CiB9CiAKK2Jvb2wgd2ViS2l0U3Jj SXNXYWl0aW5nRm9yRGF0YShXZWJLaXRXZWJTcmMqIHNyYykKK3sKKyAgICBXZWJLaXRXZWJTcmNQ cml2YXRlKiBwcml2ID0gc3JjLT5wcml2OworCisgICAgYm9vbCByZXN1bHQgPSAhcHJpdi0+aXNE b3dubG9hZFN1c3BlbmRlZCAmJiBwcml2LT5pc1dhaXRpbmdGb3JEYXRhOworCisgICAgaWYgKHJl c3VsdCAmJiBwcml2LT5oYXZlU2l6ZSkKKyAgICAgICAgcmVzdWx0ID0gcHJpdi0+cmVhZFBvc2l0 aW9uIDwgcHJpdi0+c2l6ZTsKKworICAgIEdTVF9UUkFDRV9PQkpFQ1Qoc3JjLCAiaXMgd2FpdGlu ZyBmb3IgZGF0YSAlcywgaXMgZG93bmxvYWQgc3VzcGVuZGVkICVzLCBoYXMgc2l6ZSAlcywgcmVh ZCBwb3NpdGlvbiAlIiBHX0dVSU5UNjRfRk9STUFUICIsIHNpemUgJSIgR19HVUlOVDY0X0ZPUk1B VAorICAgICAgICAiLCByZXN1bHQgJXMiLCBib29sRm9yUHJpbnRpbmcocHJpdi0+aXNXYWl0aW5n Rm9yRGF0YSksIGJvb2xGb3JQcmludGluZyhwcml2LT5pc0Rvd25sb2FkU3VzcGVuZGVkKSwgYm9v bEZvclByaW50aW5nKHByaXYtPmhhdmVTaXplKSwgcHJpdi0+cmVhZFBvc2l0aW9uCisgICAgICAg ICwgcHJpdi0+c2l6ZSwgYm9vbEZvclByaW50aW5nKHJlc3VsdCkpOworICAgIHJldHVybiByZXN1 bHQ7Cit9CisKICNlbmRpZiAvLyBFTkFCTEUoVklERU8pICYmIFVTRShHU1RSRUFNRVIpCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvV2ViS2l0 V2ViU291cmNlR1N0cmVhbWVyLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9n c3RyZWFtZXIvV2ViS2l0V2ViU291cmNlR1N0cmVhbWVyLmgKaW5kZXggZjNkOThmYmVjOWI2NDIw NWJkZmI5ZTU0OTdhZTUwMjEzZTg0MTA4MS4uZWE2NjUwYjU3MTVhY2E4ZWY3NTI2NjNkMzY0OTRh OTQ2ZTg0YjBiYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Z3N0cmVhbWVyL1dlYktpdFdlYlNvdXJjZUdTdHJlYW1lci5oCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9XZWJLaXRXZWJTb3VyY2VHU3RyZWFtZXIuaApA QCAtNTUsOCArNTUsMTAgQEAgc3RydWN0IF9XZWJLaXRXZWJTcmNDbGFzcyB7CiAKIEdUeXBlIHdl YmtpdF93ZWJfc3JjX2dldF90eXBlKHZvaWQpOwogdm9pZCB3ZWJLaXRXZWJTcmNTZXRNZWRpYVBs YXllcihXZWJLaXRXZWJTcmMqLCBXZWJDb3JlOjpNZWRpYVBsYXllciopOwordm9pZCB3ZWJLaXRX ZWJTcmNTZXRPbkRpc2tCdWZmZXJpbmdFbmFibGVkKFdlYktpdFdlYlNyYyosIGJvb2wpOwogYm9v bCB3ZWJLaXRTcmNQYXNzZWRDT1JTQWNjZXNzQ2hlY2soV2ViS2l0V2ViU3JjKik7CiBib29sIHdl YktpdFNyY1dvdWxkVGFpbnRPcmlnaW4oV2ViS2l0V2ViU3JjKiwgY29uc3QgV2ViQ29yZTo6U2Vj dXJpdHlPcmlnaW4mKTsKK2Jvb2wgd2ViS2l0U3JjSXNXYWl0aW5nRm9yRGF0YShXZWJLaXRXZWJT cmMqKTsKIAogR19FTkRfREVDTFMKIAo= 386442 2019-12-27 06:48:00 -0800 2020-01-09 07:13:28 -0800 Patch bug-205275-20191227154759.patch text/plain 33185 calvaris U3VidmVyc2lvbiBSZXZpc2lvbjogMjUzOTE1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDRiZmRmMDVlODQyZDlhNTY5OTkwMjli NjEzYmMxMTM5OWM5MzU5N2QuLjY3OTliOTllZGExZmM5Y2QxYWNkMzE2MDI1NjVmY2E3MGM4NmU5 NzcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTIgQEAKKzIwMTktMTItMTYgIFhhYmllciBSb2RyaWd1ZXogQ2Fs dmFyICA8Y2FsdmFyaXNAaWdhbGlhLmNvbT4KKworICAgICAgICBbR1N0cmVhbWVyXSBNYWtlIHNv dXJjZSBhd2FyZSBvZiBidWZmZXJlZCB0aW1lCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0yMDUyNzUKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICAqIHd0Zi9NZWRpYVRpbWUuaDogQWRkZWQgb3BlcmF0b3JzIHRv IG9wZXJhdGUgd2l0aCBTZWNvbmRzLgorCiAyMDE5LTEyLTI0ICBFcmljIENhcmxzb24gIDxlcmlj LmNhcmxzb25AYXBwbGUuY29tPgogCiAgICAgICAgIFtNZWRpYSBpbiBHUFUgcHJvY2Vzc10gRW5h YmxlIG1lZGlhIHBsYXllciBwcm94eSBsb2dnaW5nCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggOGMwOGE4ODdiZTky ODE2MDdhODQ4MWZkN2VhOTgzYWE0Y2IyM2U4OC4uZDM0ZWVjZTA2Y2Y5OGQwOTFlMWJhNzAyOWM4 MTViZTcyMTQzODhmYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBi L1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDY4IEBACisyMDE5LTEyLTE2ICBY YWJpZXIgUm9kcmlndWV6IENhbHZhciAgPGNhbHZhcmlzQGlnYWxpYS5jb20+CisKKyAgICAgICAg W0dTdHJlYW1lcl0gTWFrZSBzb3VyY2UgYXdhcmUgb2YgYnVmZmVyZWQgdGltZQorICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjA1Mjc1CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUmV3b3JrZWQgaG93IHRoZSB3 ZWIgc291cmNlIGRlYWxzIHdpdGggZGF0YS4gSXQncyBtb3JlIGVhZ2VyIG5vdworICAgICAgICBp biBwdXNoaW5nIGRhdGEgZG93bnN0cmVhbS4gV2UgZG9uJ3QgcmVhZCB0aGUgR3N0QWRhcHRlciBt ZXRob2RzCisgICAgICAgIG1hcmtlZCBhcyBmYXN0IGFueW1vcmUgYmVjYXVzZSBzb21ldGltZXMg aXQgd2FzIHNsb3dlciBhcyB3ZSB3ZXJlCisgICAgICAgIHdhaXRpbmcgZm9yIG1vcmUgYnVmZmVy cyB0aGF0IGNvdWxkIGJlIHJldHJpZXZlZCB3aXRoIHRoZSB0aG9zZQorICAgICAgICBtZXRob2Rz IHRvIGJlIGF2YWlsYWJsZSBhbmQgd2UgaGFkIGVub3VnaCBpZiB3ZSByZXRyaWV2ZWQgaXQgd2l0 aAorICAgICAgICB0aGUgQVBJIHRoYXQgaXMgbm90IG1hcmtlZCBhcyBmYXN0LgorCisgICAgICAg IFRoZSBzdHJlYW1pbmcgdGhyZWFkIGxvY2tzIG5vdyB3aGVuIGl0IGhhcyBubyBkYXRhIHRvIHB1 c2gKKyAgICAgICAgZG93bnN0cmVhbSBhbmQgcmVzdGFydHMgdGhlIGRvd25sb2FkIGlmIG5lZWRl ZC4KKworICAgICAgICBXaGVuIHBvc3NpYmxlLCB3ZSB1c2Ugbm93IHdhdGVyIGxldmVsIHZhbHVl cyBpbiB0aW1lIHRvIGNvbnNpZGVyCisgICAgICAgIHdoZW4gdG8gc3RvcC9yZXN0YXIgZG93bmxv YWQuIFdlIGhhdmUgdGhlIGxvdyB3YXRlciBsZXZlbCB0aGF0CisgICAgICAgIHdpbGwgYmUgdXNl ZCB0byByZXN0YXJ0IHRoZSBkb3dubG9hZCB3aGVuIHdlIGdvIGJlbG93IHRoYXQKKyAgICAgICAg bGltaXQuIFdlIGhhdmUgdGhlIGhpZ2ggd2F0ZXIgbGV2ZWwgdGhhdCB3ZSdsbCB1c2UgdG8gc3Rv cCB0aGUKKyAgICAgICAgZG93bmxvYWQgd2hlbiB3ZSBnbyBhYm92ZSB0aGF0LiBXZSBhbHNvIGhh dmUgYW4gaW5pdGlhbCB3YXRlcgorICAgICAgICBsZXZlbCB0byBiZSB1c2VkIGR1cmluZyB0aGUg aW5pdGlhbCBsb2FkIGFzIGluIHNvbWUgY2FzZXMsCisgICAgICAgIGRvd25sb2FkaW5nIHVwIHRv IHRoZSBoaWdoIHdhdGVyIG1hcmsgY2FuIHRha2UgYSBsb3Qgb2YgdGltZSBhbmQKKyAgICAgICAg dGhlIGNocm9tZSB3aWxsIHNob3cgdGhhdCB0aGUgcGFnZSBpcyB0YWtpbmcgYWdlcyB0byBmaW5p c2gKKyAgICAgICAgZG93bmxvYWRpbmcuIEFzIHRoZSBpbml0aWFsIGxldmVsIGlzIGxvd2VyIHRo YW4gdGhlIGxvdyBsZXZlbCwKKyAgICAgICAgd2hhdCB3aWxsIGhhcHBlbiBpcyB0aGF0IHRoZSBk b3dubG9hZCB3aWxsIGJlIHN0b3BwZWQgd2hlbiB0aGUKKyAgICAgICAgaW5pdGlhbCBsZXZlbCBp cyByZWFjaGVkLCB0aGVuIHRoZSBuZXh0IGJ1ZmZlciBpcyBzZXJ2ZWQsIGxldmVsIGlzCisgICAg ICAgIGNoZWNrZWQgYWdhaW4gYW5kIHdlJ2xsIHJlc3RhcnQgZG93bmxvYWQgYWdhaW4gaW4gYmFj a2dyb3VuZAorICAgICAgICBhbG1vc3QgaW1tZWRpYXRlbHkgKGJ1dCB0aGUgY2hyb21lIHJlZmxl Y3RzIHRoZSBwYWdlIGlzIGFscmVhZHkKKyAgICAgICAgZG93bmxvYWRlZCwgd2hpY2ggaXMgdHJ1 ZSBiZWNhdXNlIGl0IGlzIHNob3dpbmcgZXZlcnl0aGluZyBpbgorICAgICAgICBwbGFjZSBidXQg dGhlIHZpZGVvIGFscmVhZHkpLgorCisgICAgICAgIEluIHRoaXMgcGF0Y2ggd2UgYWxzbyBmaXhl ZCB0aGUgcG9zc2libGUgcmFjZSBjb25kaXRpb24gb2YKKyAgICAgICAgcmVjZWl2aW5nIGEgZmx1 c2ggZHVyaW5nIHRoZSBzdHJlYW1pbmcgdGhyZWFkIHdhaXQuCisKKyAgICAgICAgKiBwbGF0Zm9y bS9ncmFwaGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyLmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6Ok1lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lcjo6dXBkYXRlQnVmZmVy aW5nU3RhdHVzKToKKyAgICAgICAgRG93bmxvYWQgaXMgbm90IGZpbmlzaGVkIGlmIHRoZSBzb3Vy Y2UgaXMgd2FpdGluZy4KKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhUGxheWVyUHJpdmF0ZUdTdHJl YW1lcjo6dXBkYXRlU3RhdGVzKTogQWRkZWQgRkFMTFRIUk9VR0guCisgICAgICAgIChXZWJDb3Jl OjpNZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXI6OnVwZGF0ZURvd25sb2FkQnVmZmVyaW5nRmxh Zyk6CisgICAgICAgIE1ha2Ugc291cmNlIGF3YXJlIG9mIHBpcGVsaW5lIGJ1ZmZlcmluZyBzdHJh dGVneS4KKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvV2ViS2l0V2ViU291 cmNlR1N0cmVhbWVyLmNwcDoKKyAgICAgICAgKGFyZU5leHRTZWNvbmRzQnVmZmVyZWQpOiBDaGVj a3MgaWYgYSBjZXJ0YWluIGFtb3V0IG9mIHNlY29uZHMgYXJlCisgICAgICAgIGFscmVhZHkgYnVm ZmVyZWQuCisgICAgICAgIChyZXN0YXJ0TG9hZGVySWZOZWVkZWQpOiBBZGRlZCwgYmFzZWQgb24g YnVmZmVyZWQgc2Vjb25kcy4KKyAgICAgICAgKHN0b3BMb2FkZXJJZk5lZWRlZCk6ICBBZGRlZCwg YmFzZWQgb24gYnVmZmVyZWQgc2Vjb25kcy4KKyAgICAgICAgKHdlYktpdFdlYlNyY0NyZWF0ZSk6 IEF2b2lkIGFkYXB0ZXIgbWV0aG9kcyBtYXJrZWQgYXMgZmFzdCwKKyAgICAgICAgb3RoZXJ3aXNl IHdlIG1pZ2h0IGJlIHdhaXRpbmcgZm9yIGRhdGEgd2UgYWxyZWFkeSBoYXZlLiBTdHJlYW1pbmcK KyAgICAgICAgdGhyZWFkIGlzIG5vdyBnb2luZyB0byBsb2NrIHdhaXRpbmcgZm9yIGRhdGEgYW5k IGlzIG1vcmUgZWFnZXIgaW4KKyAgICAgICAgcHVzaGluZyBkYXRhIGRvd25zdHJlYW0uCisgICAg ICAgICh3ZWJLaXRXZWJTcmNTdG9wKTogTm8gbW9yZSBxdWV1ZVNpemUuCisgICAgICAgICh3ZWJL aXRXZWJTcmNEb1NlZWspOgorICAgICAgICAod2ViS2l0V2ViU3JjVW5Mb2NrKToKKyAgICAgICAg KHdlYktpdFdlYlNyY0NoYW5nZVN0YXRlKTogTm90aWZ5IHN0cmVhbWluZyB0aHJlYWQuCisgICAg ICAgICh3ZWJLaXRXZWJTcmNTZXRPbkRpc2tCdWZmZXJpbmdFbmFibGVkKTogQWRkZWQuCisgICAg ICAgIChDYWNoZWRSZXNvdXJjZVN0cmVhbWluZ0NsaWVudDo6Y2hlY2tVcGRhdGVCbG9ja3NpemUp OiBCbG9ja3NpemUKKyAgICAgICAgYWRqdXN0bWVudCBpbXByb3ZlZC4gV2l0aCBmb3JtZXIgdmFs dWVzIGJsb2Nrc2l6ZSBncmV3IHRvbyBmYXN0CisgICAgICAgIGFuZCBjb3VsZG4ndCBiZSByZWR1 Y2VkIHNvIGVhc2lseS4gSSB0aGluayBub3cgaXQgYWRqdXN0cyBtb3JlCisgICAgICAgIHF1aWNr bHkgdG8gdGhlIHJlYWwgbmV0d29yayB2YWx1ZXMuCisgICAgICAgIChDYWNoZWRSZXNvdXJjZVN0 cmVhbWluZ0NsaWVudDo6ZGF0YVJlY2VpdmVkKTogQWRkZWQgcnVkaW1lbnRhcnkKKyAgICAgICAg YmFuZHdpdGggY2FsY3VsYXRpb24gYW5kIHVzZSBzdG9wTG9hZGVySWZOZWVkZWQuCisgICAgICAg ICh3ZWJLaXRTcmNJc1dhaXRpbmdGb3JEYXRhKTogQWRkZWQuCisgICAgICAgICogcGxhdGZvcm0v Z3JhcGhpY3MvZ3N0cmVhbWVyL1dlYktpdFdlYlNvdXJjZUdTdHJlYW1lci5oOgorCiAyMDE5LTEy LTI2ICBaYWxhbiBCdWp0YXMgIDx6YWxhbkBhcHBsZS5jb20+CiAKICAgICAgICAgW0xGQ11bSUZD XSBXaGVuIGFsaWduIHRoZSBpbmxpbmUgY29udGVudCB3ZSBuZWVkIHRvIGFsaWduIHRoZSBsaW5l IGFzIHdlbGwKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL01lZGlhVGltZS5oIGIvU291cmNl L1dURi93dGYvTWVkaWFUaW1lLmgKaW5kZXggNTZmNTViMGZiMGYwMWQ2NjE4OTQ5OWMyYzFhYjQ4 ZTdhM2FjZWJlOC4uODI1ZjA5MzBhOGMxOWY3MzZkMDQyNDEyYmRlY2NkYmJjMmFjMjc4MCAxMDA2 NDQKLS0tIGEvU291cmNlL1dURi93dGYvTWVkaWFUaW1lLmgKKysrIGIvU291cmNlL1dURi93dGYv TWVkaWFUaW1lLmgKQEAgLTY3LDEyICs2NywxNCBAQCBwdWJsaWM6CiAgICAgZG91YmxlIHRvRG91 YmxlKCkgY29uc3Q7CiAKICAgICBNZWRpYVRpbWUmIG9wZXJhdG9yPShjb25zdCBNZWRpYVRpbWUm IHJocyk7Ci0gICAgTWVkaWFUaW1lJiBvcGVyYXRvcis9KGNvbnN0IE1lZGlhVGltZSYgcmhzKSB7 IHJldHVybiAqdGhpcyA9ICp0aGlzICsgcmhzOyB9Ci0gICAgTWVkaWFUaW1lJiBvcGVyYXRvci09 KGNvbnN0IE1lZGlhVGltZSYgcmhzKSB7IHJldHVybiAqdGhpcyA9ICp0aGlzIC0gcmhzOyB9Cisg ICAgdGVtcGxhdGU8dHlwZW5hbWUgVD4gTWVkaWFUaW1lJiBvcGVyYXRvcis9KGNvbnN0IFQmIHJo cykgeyByZXR1cm4gKnRoaXMgPSAqdGhpcyArIHJoczsgfQorICAgIHRlbXBsYXRlPHR5cGVuYW1l IFQ+IE1lZGlhVGltZSYgb3BlcmF0b3ItPShjb25zdCBUJiByaHMpIHsgcmV0dXJuICp0aGlzID0g KnRoaXMgLSByaHM7IH0KICAgICBNZWRpYVRpbWUgb3BlcmF0b3IrKGNvbnN0IE1lZGlhVGltZSYg cmhzKSBjb25zdDsKICAgICBNZWRpYVRpbWUgb3BlcmF0b3ItKGNvbnN0IE1lZGlhVGltZSYgcmhz KSBjb25zdDsKICAgICBNZWRpYVRpbWUgb3BlcmF0b3ItKCkgY29uc3Q7CiAgICAgTWVkaWFUaW1l IG9wZXJhdG9yKihpbnQzMl90KSBjb25zdDsKKyAgICBNZWRpYVRpbWUgb3BlcmF0b3IrKGNvbnN0 IFNlY29uZHMmIHNlY29uZHMpIGNvbnN0IHsgcmV0dXJuICp0aGlzICsgTWVkaWFUaW1lOjpjcmVh dGVXaXRoRG91YmxlKHNlY29uZHMuc2Vjb25kcygpKTsgfTsKKyAgICBNZWRpYVRpbWUgb3BlcmF0 b3ItKGNvbnN0IFNlY29uZHMmIHNlY29uZHMpIGNvbnN0IHsgcmV0dXJuICp0aGlzIC0gTWVkaWFU aW1lOjpjcmVhdGVXaXRoRG91YmxlKHNlY29uZHMuc2Vjb25kcygpKTsgfTsKICAgICBib29sIG9w ZXJhdG9yPChjb25zdCBNZWRpYVRpbWUmIHJocykgY29uc3QgeyByZXR1cm4gY29tcGFyZShyaHMp ID09IExlc3NUaGFuOyB9CiAgICAgYm9vbCBvcGVyYXRvcj4oY29uc3QgTWVkaWFUaW1lJiByaHMp IGNvbnN0IHsgcmV0dXJuIGNvbXBhcmUocmhzKSA9PSBHcmVhdGVyVGhhbjsgfQogICAgIGJvb2wg b3BlcmF0b3IhPShjb25zdCBNZWRpYVRpbWUmIHJocykgY29uc3QgeyByZXR1cm4gY29tcGFyZShy aHMpICE9IEVxdWFsVG87IH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2dzdHJlYW1lci9NZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXIuY3BwIGIvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL01lZGlhUGxheWVyUHJpdmF0ZUdT dHJlYW1lci5jcHAKaW5kZXggOTgwMDc4YmZkZWE0MmNiZDIzZTc1YmE1NDlhMTY3OTQ1YmUxYTUy NC4uNzkxZWYxY2E2NjlmY2E4ZDcyODk1YTRjNDg2N2NkZjBkODY3YTQyMSAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL01lZGlhUGxheWVyUHJp dmF0ZUdTdHJlYW1lci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Z3N0cmVhbWVyL01lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lci5jcHAKQEAgLTIyOTQsNyArMjI5 NCw4IEBAIHZvaWQgTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyOjp1cGRhdGVCdWZmZXJpbmdT dGF0dXMoR3N0QnVmZmVyaW5nTW9kZSBtb2RlLCBkCiB7CiAgICAgR1NUX0RFQlVHX09CSkVDVChw aXBlbGluZSgpLCAiW0J1ZmZlcmluZ10gbW9kZTogJXMsIHN0YXR1czogJWYlJSIsIGVudW1Ub1N0 cmluZyhHU1RfVFlQRV9CVUZGRVJJTkdfTU9ERSwgbW9kZSkuZGF0YSgpLCBwZXJjZW50YWdlKTsK IAotICAgIG1fZGlkRG93bmxvYWRGaW5pc2ggPSBwZXJjZW50YWdlID09IDEwMDsKKyAgICBtX2Rp ZERvd25sb2FkRmluaXNoID0gcGVyY2VudGFnZSA9PSAxMDAgJiYgIWlzV2ViU3JjV2FpdGluZ0Zv ckRhdGEoKTsKKyAgICBHU1RfVFJBQ0VfT0JKRUNUKHBpcGVsaW5lKCksICJkaWQgZG93bmxvYWQg ZmluaXNoICVzIiwgYm9vbEZvclByaW50aW5nKG1fZGlkRG93bmxvYWRGaW5pc2gpKTsKICAgICBt X2lzQnVmZmVyaW5nID0gIW1fZGlkRG93bmxvYWRGaW5pc2g7CiAKICAgICBzd2l0Y2ggKG1vZGUp IHsKQEAgLTIzMDIsNyArMjMwMyw3IEBAIHZvaWQgTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVy Ojp1cGRhdGVCdWZmZXJpbmdTdGF0dXMoR3N0QnVmZmVyaW5nTW9kZSBtb2RlLCBkCiAgICAgICAg IHVwZGF0ZU1heFRpbWVMb2FkZWQocGVyY2VudGFnZSk7CiAKICAgICAgICAgbV9idWZmZXJpbmdQ ZXJjZW50YWdlID0gcGVyY2VudGFnZTsKLSAgICAgICAgaWYgKG1fZGlkRG93bmxvYWRGaW5pc2gp CisgICAgICAgIGlmIChwZXJjZW50YWdlID09IDEwMCkKICAgICAgICAgICAgIHVwZGF0ZVN0YXRl cygpOwogCiAgICAgICAgIGJyZWFrOwpAQCAtMjMyNCw2ICsyMzI1LDExIEBAIHZvaWQgTWVkaWFQ bGF5ZXJQcml2YXRlR1N0cmVhbWVyOjp1cGRhdGVCdWZmZXJpbmdTdGF0dXMoR3N0QnVmZmVyaW5n TW9kZSBtb2RlLCBkCiAgICAgfQogfQogCitib29sIE1lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1l cjo6aXNXZWJTcmNXYWl0aW5nRm9yRGF0YSgpIGNvbnN0Cit7CisgICAgcmV0dXJuIFdFQktJVF9J U19XRUJfU1JDKG1fc291cmNlLmdldCgpKSAmJiB3ZWJLaXRTcmNJc1dhaXRpbmdGb3JEYXRhKFdF QktJVF9XRUJfU1JDX0NBU1QobV9zb3VyY2UuZ2V0KCkpKTsKK30KKwogI2lmIEVOQUJMRShWSURF T19UUkFDSykgJiYgVVNFKEdTVFJFQU1FUl9NUEVHVFMpCiB2b2lkIE1lZGlhUGxheWVyUHJpdmF0 ZUdTdHJlYW1lcjo6cHJvY2Vzc01wZWdUc1NlY3Rpb24oR3N0TXBlZ3RzU2VjdGlvbiogc2VjdGlv bikKIHsKQEAgLTI1NzQsNiArMjU4MCw3IEBAIHZvaWQgTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVh bWVyOjp1cGRhdGVTdGF0ZXMoKQogICAgICAgICAgICAgbV9uZXR3b3JrU3RhdGUgPSBNZWRpYVBs YXllcjo6TmV0d29ya1N0YXRlOjpFbXB0eTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBj YXNlIEdTVF9TVEFURV9QQVVTRUQ6CisgICAgICAgICAgICBGQUxMVEhST1VHSDsKICAgICAgICAg Y2FzZSBHU1RfU1RBVEVfUExBWUlORzoKICAgICAgICAgICAgIGlmIChtX2lzQnVmZmVyaW5nKSB7 CiAgICAgICAgICAgICAgICAgaWYgKG1fYnVmZmVyaW5nUGVyY2VudGFnZSA9PSAxMDApIHsKQEAg LTI2MTQsNyArMjYyMSw3IEBAIHZvaWQgTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyOjp1cGRh dGVTdGF0ZXMoKQogICAgICAgICB9IGVsc2UgaWYgKG1fY3VycmVudFN0YXRlID09IEdTVF9TVEFU RV9QTEFZSU5HKSB7CiAgICAgICAgICAgICBtX2lzUGF1c2VkID0gZmFsc2U7CiAKLSAgICAgICAg ICAgIGlmICgobV9pc0J1ZmZlcmluZyAmJiBtX2lzTGl2ZVN0cmVhbSkgfHwgIW1fcGxheWJhY2tS YXRlKSB7CisgICAgICAgICAgICBpZiAoKG1faXNCdWZmZXJpbmcgJiYgIW1faXNMaXZlU3RyZWFt KSB8fCAhbV9wbGF5YmFja1JhdGUpIHsKICAgICAgICAgICAgICAgICBHU1RfREVCVUdfT0JKRUNU KHBpcGVsaW5lKCksICJbQnVmZmVyaW5nXSBQYXVzaW5nIHN0cmVhbSBmb3IgYnVmZmVyaW5nLiIp OwogICAgICAgICAgICAgICAgIGNoYW5nZVBpcGVsaW5lU3RhdGUoR1NUX1NUQVRFX1BBVVNFRCk7 CiAgICAgICAgICAgICB9CkBAIC0yODc3LDYgKzI4ODQsOSBAQCB2b2lkIE1lZGlhUGxheWVyUHJp dmF0ZUdTdHJlYW1lcjo6dXBkYXRlRG93bmxvYWRCdWZmZXJpbmdGbGFnKCkKICAgICB9CiAKICAg ICBib29sIHNob3VsZERvd25sb2FkID0gIW1faXNMaXZlU3RyZWFtICYmIG1fcHJlbG9hZCA9PSBN ZWRpYVBsYXllcjo6UHJlbG9hZDo6QXV0bzsKKyAgICBBU1NFUlQobV9zb3VyY2UpOworICAgIGlm IChXRUJLSVRfSVNfV0VCX1NSQyhtX3NvdXJjZS5nZXQoKSkpCisgICAgICAgIHdlYktpdFdlYlNy Y1NldE9uRGlza0J1ZmZlcmluZ0VuYWJsZWQoV0VCS0lUX1dFQl9TUkNfQ0FTVChtX3NvdXJjZS5n ZXQoKSksIHNob3VsZERvd25sb2FkKTsKICAgICBpZiAoc2hvdWxkRG93bmxvYWQpIHsKICAgICAg ICAgR1NUX0lORk9fT0JKRUNUKHBpcGVsaW5lKCksICJFbmFibGluZyBvbi1kaXNrIGJ1ZmZlcmlu ZyIpOwogICAgICAgICBnX29iamVjdF9zZXQobV9waXBlbGluZS5nZXQoKSwgImZsYWdzIiwgZmxh Z3MgfCBmbGFnRG93bmxvYWQsIG51bGxwdHIpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL01lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lci5o IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL01lZGlhUGxheWVy UHJpdmF0ZUdTdHJlYW1lci5oCmluZGV4IGZkMDQ3NTQ3OWM3NDhlNDQ4MjRhZmJkYTBlYzIxY2Vi ODMwOWI5ZDIuLjMyN2RhMzhlNjU3YTA0ZjMyMjg1YzE3MWZmNzVlNGVhN2M1N2U5NDggMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9NZWRpYVBs YXllclByaXZhdGVHU3RyZWFtZXIuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9nc3RyZWFtZXIvTWVkaWFQbGF5ZXJQcml2YXRlR1N0cmVhbWVyLmgKQEAgLTQ0Niw2ICs0 NDYsOCBAQCBwcml2YXRlOgogICAgIHZvaWQgdXBkYXRlVHJhY2tzKCk7CiAgICAgdm9pZCBjbGVh clRyYWNrcygpOwogCisgICAgYm9vbCBpc1dlYlNyY1dhaXRpbmdGb3JEYXRhKCkgY29uc3Q7CisK ICNpZiBFTkFCTEUoRU5DUllQVEVEX01FRElBKQogICAgIGJvb2wgaXNDRE1BdHRhY2hlZCgpIGNv bnN0IHsgcmV0dXJuIG1fY2RtSW5zdGFuY2U7IH0KICAgICB2b2lkIGF0dGVtcHRUb0RlY3J5cHRX aXRoTG9jYWxJbnN0YW5jZSgpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvZ3N0cmVhbWVyL1dlYktpdFdlYlNvdXJjZUdTdHJlYW1lci5jcHAgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvV2ViS2l0V2ViU291cmNlR1N0cmVh bWVyLmNwcAppbmRleCBhZWRiZjY4NmYwNGJmMDllNzJkMmQzYjQ3NDdjOGJkOWU3ZjQ5ZTcwLi5k ZjM3MjQ2ZmVlNmNjMWFiYmQwNzhlMzg5NTVjOTc0NjUyMjAxNWVlIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvV2ViS2l0V2ViU291cmNlR1N0 cmVhbWVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFt ZXIvV2ViS2l0V2ViU291cmNlR1N0cmVhbWVyLmNwcApAQCAtMjgsMTIgKzI4LDE0IEBACiAjaW5j bHVkZSAiTWFpblRocmVhZE5vdGlmaWVyLmgiCiAjaW5jbHVkZSAiTWVkaWFQbGF5ZXIuaCIKICNp bmNsdWRlICJQbGF0Zm9ybU1lZGlhUmVzb3VyY2VMb2FkZXIuaCIKKyNpbmNsdWRlICJQbGF0Zm9y bVRpbWVSYW5nZXMuaCIKICNpbmNsdWRlICJSZXNvdXJjZUVycm9yLmgiCiAjaW5jbHVkZSAiUmVz b3VyY2VSZXF1ZXN0LmgiCiAjaW5jbHVkZSAiUmVzb3VyY2VSZXNwb25zZS5oIgogI2luY2x1ZGUg PGNzdGRpbnQ+CiAjaW5jbHVkZSA8d3RmL0NvbmRpdGlvbi5oPgogI2luY2x1ZGUgPHd0Zi9TY29w ZS5oPgorI2luY2x1ZGUgPHd0Zi9TdHJpbmdQcmludFN0cmVhbS5oPgogI2luY2x1ZGUgPHd0Zi9n bGliL1dURkdUeXBlLmg+CiAjaW5jbHVkZSA8d3RmL3RleHQvQ1N0cmluZy5oPgogCkBAIC01MCw2 ICs1MiwxMSBAQCB1c2luZyBuYW1lc3BhY2UgV2ViQ29yZTsKIC8vIHJlYWNoZWQsIHRoZSBkb3du bG9hZCB0YXNrIHJlc3VtZXMuCiAjZGVmaW5lIExPV19RVUVVRV9GQUNUT1JfVEhSRVNIT0xEIDAu MgogCisvLyBXYXRlciBsZXZlbCB2YWx1ZXMgaW4gc2Vjb25kcyB0aGF0IHdlIG5lZWQgdG8gaGF2 ZSBidWZmZXJlZCBhaGVhZCB0byBjb25zaWRlciB3ZSBoYXZlIGVub3VnaCB0aW1lIGJ1ZmZlcmVk IHRvIHN0b3AvcmVzdGFydCBkb3dubG9hZC4KK3N0YXRpYyBTZWNvbmRzIHNfaW5pdGlhbFdhdGVy TGV2ZWxCdWZmZXJlZFNlY29uZHMgPSAxNV9zOworc3RhdGljIFNlY29uZHMgc19sb3dXYXRlckxl dmVsQnVmZmVyZWRTZWNvbmRzID0gMjVfczsKK3N0YXRpYyBTZWNvbmRzIHNfaGlnaFdhdGVyTGV2 ZWxCdWZmZXJlZFNlY29uZHMgPSAzMF9zOworCiBjbGFzcyBDYWNoZWRSZXNvdXJjZVN0cmVhbWlu Z0NsaWVudCBmaW5hbCA6IHB1YmxpYyBQbGF0Zm9ybU1lZGlhUmVzb3VyY2VDbGllbnQgewogICAg IFdURl9NQUtFX0ZBU1RfQUxMT0NBVEVEOwogICAgIFdURl9NQUtFX05PTkNPUFlBQkxFKENhY2hl ZFJlc291cmNlU3RyZWFtaW5nQ2xpZW50KTsKQEAgLTcyLDkgKzc5LDkgQEAgcHJpdmF0ZToKICAg ICB2b2lkIGxvYWRGaW5pc2hlZChQbGF0Zm9ybU1lZGlhUmVzb3VyY2UmKSBvdmVycmlkZTsKIAog ICAgIHN0YXRpYyBjb25zdGV4cHIgaW50IHNfZ3Jvd0Jsb2Nrc2l6ZUxpbWl0IHsgMSB9OwotICAg IHN0YXRpYyBjb25zdGV4cHIgaW50IHNfZ3Jvd0Jsb2Nrc2l6ZUNvdW50IHsgMSB9OworICAgIHN0 YXRpYyBjb25zdGV4cHIgaW50IHNfZ3Jvd0Jsb2Nrc2l6ZUNvdW50IHsgMiB9OwogICAgIHN0YXRp YyBjb25zdGV4cHIgaW50IHNfZ3Jvd0Jsb2Nrc2l6ZUZhY3RvciB7IDIgfTsKLSAgICBzdGF0aWMg Y29uc3RleHByIGZsb2F0IHNfcmVkdWNlQmxvY2tzaXplTGltaXQgeyAwLjIwIH07CisgICAgc3Rh dGljIGNvbnN0ZXhwciBmbG9hdCBzX3JlZHVjZUJsb2Nrc2l6ZUxpbWl0IHsgMC41IH07CiAgICAg c3RhdGljIGNvbnN0ZXhwciBpbnQgc19yZWR1Y2VCbG9ja3NpemVDb3VudCB7IDIgfTsKICAgICBz dGF0aWMgY29uc3RleHByIGZsb2F0IHNfcmVkdWNlQmxvY2tzaXplRmFjdG9yIHsgMC41IH07CiAg ICAgaW50IG1fcmVkdWNlQmxvY2tzaXplQ291bnQgeyAwIH07CkBAIC0xMzcsMTQgKzE0NCwxOCBA QCBzdHJ1Y3QgX1dlYktpdFdlYlNyY1ByaXZhdGUgewogICAgIGJvb2wgaXNTZWVrYWJsZTsKICAg ICBib29sIGlzU2Vla2luZzsKICAgICBib29sIHdhc1NlZWtpbmcgeyBmYWxzZSB9OworICAgIGJv b2wgaXNPbkRpc2tCdWZmZXJpbmdFbmFibGVkIHsgZmFsc2UgfTsKKyAgICBib29sIGlzSW5pdGlh bExvYWQgeyB0cnVlIH07CiAgICAgdW5zaWduZWQgbWluaW11bUJsb2Nrc2l6ZTsKICAgICBMb2Nr IGFkYXB0ZXJMb2NrOwogICAgIENvbmRpdGlvbiBhZGFwdGVyQ29uZGl0aW9uOwotICAgIHVpbnQ2 NF90IHF1ZXVlU2l6ZSB7IDAgfTsKICAgICBib29sIGlzRG93bmxvYWRTdXNwZW5kZWQgeyBmYWxz ZSB9OwogICAgIEdSZWZQdHI8R3N0QWRhcHRlcj4gYWRhcHRlcjsKICAgICBHUmVmUHRyPEdzdEV2 ZW50PiBodHRwSGVhZGVyc0V2ZW50OwogICAgIEdVbmlxdWVQdHI8R3N0U3RydWN0dXJlPiBodHRw SGVhZGVyczsKKyAgICBXYWxsVGltZSBkb3dubG9hZFN0YXJ0VGltZSB7IFdhbGxUaW1lKCkgfTsK KyAgICBndWludCB0b3RhbERvd25sb2FkZWRCeXRlcyB7IDAgfTsKKyAgICBib29sIGlzV2FpdGlu Z0ZvckRhdGEgeyBmYWxzZSB9OwogfTsKIAogZW51bSB7CkBAIC0xNzksNiArMTkwLDkgQEAgc3Rh dGljIGdib29sZWFuIHdlYktpdFdlYlNyY1F1ZXJ5KEdzdEJhc2VTcmMqLCBHc3RRdWVyeSopOwog c3RhdGljIGdib29sZWFuIHdlYktpdFdlYlNyY1VuTG9jayhHc3RCYXNlU3JjKik7CiBzdGF0aWMg Z2Jvb2xlYW4gd2ViS2l0V2ViU3JjVW5Mb2NrU3RvcChHc3RCYXNlU3JjKik7CiBzdGF0aWMgdm9p ZCB3ZWJLaXRXZWJTcmNTZXRDb250ZXh0KEdzdEVsZW1lbnQqLCBHc3RDb250ZXh0Kik7CitzdGF0 aWMgdm9pZCByZXN0YXJ0TG9hZGVySWZOZWVkZWQoV2ViS2l0V2ViU3JjKik7CitzdGF0aWMgdm9p ZCBzdG9wTG9hZGVySWZOZWVkZWQoV2ViS2l0V2ViU3JjKik7CitzdGF0aWMgV1RGOjpPcHRpb25h bDxib29sPiBXQVJOX1VOVVNFRF9SRVRVUk4gYXJlTmV4dFNlY29uZHNCdWZmZXJlZChXZWJLaXRX ZWJTcmMqLCBjb25zdCBTZWNvbmRzJik7CiAKICNkZWZpbmUgd2Via2l0X3dlYl9zcmNfcGFyZW50 X2NsYXNzIHBhcmVudF9jbGFzcwogV0VCS0lUX0RFRklORV9UWVBFX1dJVEhfQ09ERShXZWJLaXRX ZWJTcmMsIHdlYmtpdF93ZWJfc3JjLCBHU1RfVFlQRV9QVVNIX1NSQywKQEAgLTM0NCw2ICszNTgs MTMyIEBAIHN0YXRpYyB2b2lkIHdlYktpdFdlYlNyY1NldENvbnRleHQoR3N0RWxlbWVudCogZWxl bWVudCwgR3N0Q29udGV4dCogY29udGV4dCkKICAgICBHU1RfRUxFTUVOVF9DTEFTUyhwYXJlbnRf Y2xhc3MpLT5zZXRfY29udGV4dChlbGVtZW50LCBjb250ZXh0KTsKIH0KIAorc3RhdGljIFdURjo6 T3B0aW9uYWw8Ym9vbD4gV0FSTl9VTlVTRURfUkVUVVJOIGFyZU5leHRTZWNvbmRzQnVmZmVyZWQo V2ViS2l0V2ViU3JjKiBzcmMsIGNvbnN0IFNlY29uZHMmIHNlY29uZHMpCit7CisgICAgV2ViS2l0 V2ViU3JjUHJpdmF0ZSogcHJpdiA9IHNyYy0+cHJpdjsKKworICAgIGlmICghcHJpdi0+aXNPbkRp c2tCdWZmZXJpbmdFbmFibGVkKQorICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OworCisgICAg TWVkaWFUaW1lIGN1cnJlbnRUaW1lID0gcHJpdi0+cGxheWVyLT5jdXJyZW50VGltZSgpOworICAg IE1lZGlhVGltZSBkZXNpcmVkQnVmZmVyZWRUaW1lRW5kID0gY3VycmVudFRpbWUgKyBzZWNvbmRz OworICAgIE1lZGlhVGltZSBkdXJhdGlvbiA9IHByaXYtPnBsYXllci0+ZHVyYXRpb24oKTsKKyAg ICBpZiAoZHVyYXRpb24pCisgICAgICAgIGRlc2lyZWRCdWZmZXJlZFRpbWVFbmQgPSBzdGQ6Om1p bihkdXJhdGlvbiwgZGVzaXJlZEJ1ZmZlcmVkVGltZUVuZCk7CisgICAgYXV0byBidWZmZXJlZFJh bmdlcyA9IHByaXYtPnBsYXllci0+YnVmZmVyZWQoKTsKKworICAgIC8vIEl0IHdvdWxkIGJlIG5p Y2UgdG8gY2hlY2sgaWYgdGhlIHdob2xlIHJhbmdlIGlzIGNvbnRhaW5lZCBpbnN0ZWFkIG9mIHRo aXMgYnV0IHRoZXJlIGFyZSBkZW11eGVycyB0aGF0IHNlZWsgdGhlIHNvdXJjZSBhbmQgbGVhdmUg c29tZSBob2xlcyBldmVuCisgICAgLy8gd2hlbiB0aGV5IGNhbiBwbGF5LgorICAgIGJvb2wgcmVz dWx0ID0gYnVmZmVyZWRSYW5nZXMtPmNvbnRhaW4oY3VycmVudFRpbWUpICYmIGJ1ZmZlcmVkUmFu Z2VzLT5jb250YWluKGRlc2lyZWRCdWZmZXJlZFRpbWVFbmQpOworCisgICAgLy8gUHJpbnRpbmcg dGhpcyBpcyBuaWNlIGJ1dCBjb3N0bHkgc28gbGV0J3MgYXZvaWQgaWYgaXQgaXMgb3V0IG9mIHRo ZSB0aHJlc2hvbGQuCisgICAgc3RhdGljIEdzdERlYnVnTGV2ZWwgZ3N0RGVidWdMZXZlbCA9IGdz dF9kZWJ1Z19jYXRlZ29yeV9nZXRfdGhyZXNob2xkKHdlYmtpdF93ZWJfc3JjX2RlYnVnKTsKKyAg ICBpZiAoZ3N0RGVidWdMZXZlbCA+PSBHU1RfTEVWRUxfVFJBQ0UpIHsKKyAgICAgICAgU3RyaW5n UHJpbnRTdHJlYW0gc3RyZWFtOworICAgICAgICBzdHJlYW0ucHJpbnQoImN1cnJlbnQgdGltZSAi KTsKKyAgICAgICAgc3RyZWFtLnByaW50KGN1cnJlbnRUaW1lKTsKKyAgICAgICAgc3RyZWFtLnBy aW50KCIsICgrIik7CisgICAgICAgIHN0cmVhbS5wcmludChzZWNvbmRzKTsKKyAgICAgICAgc3Ry ZWFtLnByaW50KCI9KSAiKTsKKyAgICAgICAgc3RyZWFtLnByaW50KGN1cnJlbnRUaW1lICsgc2Vj b25kcyk7CisgICAgICAgIHN0cmVhbS5wcmludCgiLCBkdXJhdGlvbiAiKTsKKyAgICAgICAgc3Ry ZWFtLnByaW50KHByaXYtPnBsYXllci0+ZHVyYXRpb24oKSk7CisgICAgICAgIHN0cmVhbS5wcmlu dCgiLCBkZXNpcmVkIHRpbWUgZW5kICIpOworICAgICAgICBzdHJlYW0ucHJpbnQoZGVzaXJlZEJ1 ZmZlcmVkVGltZUVuZCk7CisgICAgICAgIHN0cmVhbS5wcmludCgiLCBidWZmZXJlZCAiKTsKKyAg ICAgICAgYnVmZmVyZWRSYW5nZXMtPmR1bXAoc3RyZWFtKTsKKyAgICAgICAgc3RyZWFtLnByaW50 KCIsIHJlc3VsdCAiKTsKKyAgICAgICAgc3RyZWFtLnByaW50KHJlc3VsdCk7CisKKyAgICAgICAg R1NUX1RSQUNFX09CSkVDVChzcmMsICIlcyIsIHN0cmVhbS50b0NTdHJpbmcoKS5kYXRhKCkpOwor ICAgIH0KKworICAgIHJldHVybiBtYWtlT3B0aW9uYWwocmVzdWx0KTsKK30KKworc3RhdGljIHZv aWQgcmVzdGFydExvYWRlcklmTmVlZGVkKFdlYktpdFdlYlNyYyogc3JjKQoreworICAgIFdlYktp dFdlYlNyY1ByaXZhdGUqIHByaXYgPSBzcmMtPnByaXY7CisKKyAgICBpZiAoIXByaXYtPmlzRG93 bmxvYWRTdXNwZW5kZWQpIHsKKyAgICAgICAgR1NUX1RSQUNFX09CSkVDVChzcmMsICJkb3dubG9h ZCBhbHJlYWR5IGFjdGl2ZSIpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgR1NUX1RS QUNFX09CSkVDVChzcmMsICJpcyBkb3dubG9hZCBzdXNwZW5kZWQgJXMsIGRvZXMgaGF2ZSBFT1Mg JXMsIGRvZXMgaGF2ZSBzaXplICVzLCBpcyBzZWVrYWJsZSAlcywgc2l6ZSAlIiBHX0dVSU5UNjRf Rk9STUFUCisgICAgICAgICIgKG1pbiAldSkiLCBib29sRm9yUHJpbnRpbmcocHJpdi0+aXNEb3du bG9hZFN1c3BlbmRlZCksIGJvb2xGb3JQcmludGluZyhwcml2LT5kb2VzSGF2ZUVPUyksIGJvb2xG b3JQcmludGluZyhwcml2LT5oYXZlU2l6ZSkKKyAgICAgICAgLCBib29sRm9yUHJpbnRpbmcocHJp di0+aXNTZWVrYWJsZSksIHByaXYtPnNpemUsIFNNQUxMX01FRElBX1JFU09VUkNFX01BWF9TSVpF KTsKKyAgICBpZiAocHJpdi0+ZG9lc0hhdmVFT1MgfHwgIXByaXYtPmhhdmVTaXplIHx8ICFwcml2 LT5pc1NlZWthYmxlIHx8IHByaXYtPnNpemUgPD0gU01BTExfTUVESUFfUkVTT1VSQ0VfTUFYX1NJ WkUpIHsKKyAgICAgICAgR1NUX1RSQUNFX09CSkVDVChzcmMsICJkb3dubG9hZCBjYW5ub3QgYmUg c3RvcHBlZC9yZXN0YXJ0ZWQiKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKyAgICBHU1RfVFJB Q0VfT0JKRUNUKHNyYywgInJlYWQgcG9zaXRpb24gJSIgR19HVUlOVDY0X0ZPUk1BVCAiLCBzdGF0 ZSAlcyIsIHByaXYtPnJlYWRQb3NpdGlvbiwgZ3N0X2VsZW1lbnRfc3RhdGVfZ2V0X25hbWUoR1NU X1NUQVRFKHNyYykpKTsKKyAgICBpZiAoIXByaXYtPnJlYWRQb3NpdGlvbiB8fCBwcml2LT5yZWFk UG9zaXRpb24gPT0gcHJpdi0+c2l6ZSB8fCBHU1RfU1RBVEUoc3JjKSA8IEdTVF9TVEFURV9QQVVT RUQpIHsKKyAgICAgICAgR1NUX1RSQUNFX09CSkVDVChzcmMsICJjYW4ndCByZXN0YXJ0IGRvd25s b2FkIik7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBhdXRvIGlzRW5vdWdoVGltZUJ1 ZmZlcmVkID0gYXJlTmV4dFNlY29uZHNCdWZmZXJlZChzcmMsIHNfbG93V2F0ZXJMZXZlbEJ1ZmZl cmVkU2Vjb25kcyk7CisgICAgc2l6ZV90IHF1ZXVlU2l6ZSA9IGdzdF9hZGFwdGVyX2F2YWlsYWJs ZShwcml2LT5hZGFwdGVyLmdldCgpKTsKKyAgICBHU1RfVFJBQ0VfT0JKRUNUKHNyYywgImlzIGVu b3VnaCB0aW1lIGJ1ZmZlcmVkICVzLCBxdWV1ZSBzaXplICUiIEdfR1VJTlQ2NF9GT1JNQVQgIiAo bWluICUxLjBsZikiCisgICAgICAgICwgaXNFbm91Z2hUaW1lQnVmZmVyZWQuaGFzVmFsdWUoKSA/ IGJvb2xGb3JQcmludGluZyhpc0Vub3VnaFRpbWVCdWZmZXJlZC52YWx1ZSgpKSA6ICJ1bmtub3du IiwgcXVldWVTaXplCisgICAgICAgICwgcHJpdi0+c2l6ZSAqIEhJR0hfUVVFVUVfRkFDVE9SX1RI UkVTSE9MRCAqIExPV19RVUVVRV9GQUNUT1JfVEhSRVNIT0xEKTsKKworICAgIGlmIChpc0Vub3Vn aFRpbWVCdWZmZXJlZC5oYXNWYWx1ZSgpKSB7CisgICAgICAgIGlmIChpc0Vub3VnaFRpbWVCdWZm ZXJlZC52YWx1ZSgpKSB7CisgICAgICAgICAgICBHU1RfVFJBQ0VfT0JKRUNUKHNyYywgImVub3Vn aCBidWZmZXJlZCwgbm90IHJlc3RhcnRpbmcgZG93bmxvYWQiKTsKKyAgICAgICAgICAgIHJldHVy bjsKKyAgICAgICAgfQorICAgIH0gZWxzZSBpZiAocXVldWVTaXplID49IHByaXYtPnNpemUgKiBI SUdIX1FVRVVFX0ZBQ1RPUl9USFJFU0hPTEQgKiBMT1dfUVVFVUVfRkFDVE9SX1RIUkVTSE9MRCkg eworICAgICAgICBHU1RfVFJBQ0VfT0JKRUNUKHNyYywgInF1ZXVlIHNpemUgYWJvdmUgbG93IHdh dGVybWFyaywgbm90IHJlc3RhcnRpbmcgZG93bmxvYWQiKTsKKyAgICAgICAgcmV0dXJuOworICAg IH0KKworICAgIEdTVF9ERUJVR19PQkpFQ1Qoc3JjLCAicmVzdGFydGluZyBkb3dubG9hZCIpOwor ICAgIHByaXYtPmlzRG93bmxvYWRTdXNwZW5kZWQgPSBmYWxzZTsKKyAgICB3ZWJLaXRXZWJTcmNN YWtlUmVxdWVzdChHU1RfQkFTRV9TUkNfQ0FTVChzcmMpLCBmYWxzZSk7Cit9CisKKworc3RhdGlj IHZvaWQgc3RvcExvYWRlcklmTmVlZGVkKFdlYktpdFdlYlNyYyogc3JjKQoreworICAgIFdlYktp dFdlYlNyY1ByaXZhdGUqIHByaXYgPSBzcmMtPnByaXY7CisKKyAgICBpZiAocHJpdi0+aXNEb3du bG9hZFN1c3BlbmRlZCkgeworICAgICAgICBHU1RfVFJBQ0VfT0JKRUNUKHNyYywgImRvd25sb2Fk IGFscmVhZHkgc3VzcGVuZGVkIik7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBHU1Rf VFJBQ0VfT0JKRUNUKHNyYywgImlzIGRvd25sb2FkIHN1c3BlbmRlZCAlcywgZG9lcyBoYXZlIHNp emUgJXMsIGlzIHNlZWthYmxlICVzLCBzaXplICUiIEdfR1VJTlQ2NF9GT1JNQVQgIiAobWluICV1 KSIKKyAgICAgICAgLCBib29sRm9yUHJpbnRpbmcocHJpdi0+aXNEb3dubG9hZFN1c3BlbmRlZCks IGJvb2xGb3JQcmludGluZyhwcml2LT5oYXZlU2l6ZSksIGJvb2xGb3JQcmludGluZyhwcml2LT5p c1NlZWthYmxlKSwgcHJpdi0+c2l6ZQorICAgICAgICAsIFNNQUxMX01FRElBX1JFU09VUkNFX01B WF9TSVpFKTsKKyAgICBpZiAoIXByaXYtPmhhdmVTaXplIHx8ICFwcml2LT5pc1NlZWthYmxlIHx8 IHByaXYtPnNpemUgPD0gU01BTExfTUVESUFfUkVTT1VSQ0VfTUFYX1NJWkUpIHsKKyAgICAgICAg R1NUX1RSQUNFX09CSkVDVChzcmMsICJkb3dubG9hZCBjYW5ub3QgYmUgc3RvcHBlZC9yZXN0YXJ0 ZWQiKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIGF1dG8gaXNFbm91Z2hUaW1lQnVm ZmVyZWQgPSBhcmVOZXh0U2Vjb25kc0J1ZmZlcmVkKHNyYywgcHJpdi0+aXNJbml0aWFsTG9hZCA/ IHNfaW5pdGlhbFdhdGVyTGV2ZWxCdWZmZXJlZFNlY29uZHMgOiBzX2hpZ2hXYXRlckxldmVsQnVm ZmVyZWRTZWNvbmRzKTsKKyAgICBzaXplX3QgcXVldWVTaXplID0gZ3N0X2FkYXB0ZXJfYXZhaWxh YmxlKHByaXYtPmFkYXB0ZXIuZ2V0KCkpOworICAgIEdTVF9UUkFDRV9PQkpFQ1Qoc3JjLCAiaXMg ZW5vdWdoIHRpbWUgYnVmZmVyZWQgJXMgKGlzIGluaXRpYWwgbG9hZCAlcyksIHF1ZXVlIHNpemUg JSIgR19HVUlOVDY0X0ZPUk1BVCAiIChtYXggJTEuMGxmKSIKKyAgICAgICAgLCBpc0Vub3VnaFRp bWVCdWZmZXJlZC5oYXNWYWx1ZSgpID8gYm9vbEZvclByaW50aW5nKGlzRW5vdWdoVGltZUJ1ZmZl cmVkLnZhbHVlKCkpIDogInVua25vd24iLCBib29sRm9yUHJpbnRpbmcocHJpdi0+aXNJbml0aWFs TG9hZCkKKyAgICAgICAgLCBxdWV1ZVNpemUsIHByaXYtPnNpemUgKiBISUdIX1FVRVVFX0ZBQ1RP Ul9USFJFU0hPTEQpOworICAgIGlmIChpc0Vub3VnaFRpbWVCdWZmZXJlZC5oYXNWYWx1ZSgpKSB7 CisgICAgICAgIGlmICghaXNFbm91Z2hUaW1lQnVmZmVyZWQudmFsdWUoKSkgeworICAgICAgICAg ICAgR1NUX1RSQUNFX09CSkVDVChzcmMsICJub3QgZW5vdWdoIGJ1ZmZlcmVkLCBub3Qgc3RvcHBp bmcgZG93bmxvYWQiKTsKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgfQorICAgIH0gZWxz ZSBpZiAocXVldWVTaXplIDw9IHByaXYtPnNpemUgKiBISUdIX1FVRVVFX0ZBQ1RPUl9USFJFU0hP TEQpIHsKKyAgICAgICAgR1NUX1RSQUNFX09CSkVDVChzcmMsICJxdWV1ZSBzaXplIHVuZGVyIGhp Z2ggd2F0ZXJtYXJrLCBub3Qgc3RvcHBpbmcgZG93bmxvYWQiKTsKKyAgICAgICAgcmV0dXJuOwor ICAgIH0KKworICAgIEdTVF9ERUJVR19PQkpFQ1Qoc3JjLCAic3RvcHBpbmcgZG93bmxvYWQiKTsK KyAgICBwcml2LT5pc0luaXRpYWxMb2FkID0gZmFsc2U7CisgICAgcHJpdi0+aXNEb3dubG9hZFN1 c3BlbmRlZCA9IHRydWU7CisgICAgcHJpdi0+cmVzb3VyY2UtPnN0b3AoKTsKKyAgICBwcml2LT5k b3dubG9hZFN0YXJ0VGltZSA9IFdhbGxUaW1lKCk7Cit9CisKIHN0YXRpYyBHc3RGbG93UmV0dXJu IHdlYktpdFdlYlNyY0NyZWF0ZShHc3RQdXNoU3JjKiBwdXNoU3JjLCBHc3RCdWZmZXIqKiBidWZm ZXIpCiB7CiAgICAgR3N0QmFzZVNyYyogYmFzZVNyYyA9IEdTVF9CQVNFX1NSQ19DQVNUKHB1c2hT cmMpOwpAQCAtMzU2LDkgKzQ5Niw3IEBAIHN0YXRpYyBHc3RGbG93UmV0dXJuIHdlYktpdFdlYlNy Y0NyZWF0ZShHc3RQdXNoU3JjKiBwdXNoU3JjLCBHc3RCdWZmZXIqKiBidWZmZXIpCiAgICAgICAg IHsKICAgICAgICAgICAgIExvY2tIb2xkZXIgYWRhcHRlckxvY2tlcihwcml2LT5hZGFwdGVyTG9j ayk7CiAgICAgICAgICAgICBHU1RfREVCVUdfT0JKRUNUKHNyYywgIlNlZWtpbmcsIGZsdXNoaW5n IGFkYXB0ZXIiKTsKLSAgICAgICAgICAgIC8vIERpc2NhcmQgYWxsIHRoZSBidWZmZXJzIGNvbWlu ZyBiZWZvcmUgdGhlIHJlcXVlc3RlZCBzZWVrIHBvc2l0aW9uLgotICAgICAgICAgICAgZ3N0X2Fk YXB0ZXJfZmx1c2gocHJpdi0+YWRhcHRlci5nZXQoKSwgcHJpdi0+cXVldWVTaXplKTsKLSAgICAg ICAgICAgIHByaXYtPnF1ZXVlU2l6ZSA9IDA7CisgICAgICAgICAgICBnc3RfYWRhcHRlcl9jbGVh cihwcml2LT5hZGFwdGVyLmdldCgpKTsKICAgICAgICAgfQogICAgICAgICB1aW50NjRfdCByZXF1 ZXN0ZWRQb3NpdGlvbiA9IHByaXYtPnJlcXVlc3RlZFBvc2l0aW9uOwogICAgICAgICB3ZWJLaXRX ZWJTcmNTdG9wKGJhc2VTcmMpOwpAQCAtMzc4LDE0ICs1MTYsMTAgQEAgc3RhdGljIEdzdEZsb3dS ZXR1cm4gd2ViS2l0V2ViU3JjQ3JlYXRlKEdzdFB1c2hTcmMqIHB1c2hTcmMsIEdzdEJ1ZmZlcioq IGJ1ZmZlcikKICAgICAgICAgfSk7CiAgICAgfQogCi0gICAgR1NUX1RSQUNFX09CSkVDVChzcmMs ICJmbHVzaGluZzogJXMsIGRvZXNIYXZlRU9TOiAlcywgcXVldWVTaXplOiAlIiBHX0dVSU5UNjRf Rk9STUFUICIsIGlzRG93bmxvYWRTdXNwZW5kZWQ6ICVzIiwKLSAgICAgICAgYm9vbEZvclByaW50 aW5nKHByaXYtPmlzRmx1c2hpbmcpLCBib29sRm9yUHJpbnRpbmcocHJpdi0+ZG9lc0hhdmVFT1Mp LCBwcml2LT5xdWV1ZVNpemUsCi0gICAgICAgIGJvb2xGb3JQcmludGluZyhwcml2LT5pc0Rvd25s b2FkU3VzcGVuZGVkKSk7Ci0KLSAgICBpZiAocHJpdi0+aXNGbHVzaGluZykgewotICAgICAgICBH U1RfREVCVUdfT0JKRUNUKHNyYywgIkZsdXNoaW5nIik7Ci0gICAgICAgIHJldHVybiBHU1RfRkxP V19GTFVTSElORzsKLSAgICB9CisgICAgLy8gV2UgZG9uJ3QgcmVhZCB0aGUgR3N0QWRhcHRlciBt ZXRob2RzIG1hcmtlZCBhcyBmYXN0IGFueW1vcmUgYmVjYXVzZSBzb21ldGltZXMgaXQgd2FzIHNs b3dlciBhcyB3ZSB3ZXJlIHdhaXRpbmcgZm9yIG1vcmUgYnVmZmVycyB0aGF0IGNvdWxkIGJlCisg ICAgLy8gcmV0cmlldmVkIHdpdGggdGhlIHRob3NlIG1ldGhvZHMgdG8gYmUgYXZhaWxhYmxlIGFu ZCB3ZSBoYWQgZW5vdWdoIGlmIHdlIHJldHJpZXZlZCBpdCB3aXRoIHRoZSBBUEkgdGhhdCBpcyBu b3QgbWFya2VkIGFzIGZhc3QuCisgICAgR1NUX1RSQUNFX09CSkVDVChzcmMsICJmbHVzaGluZzog JXMsIGRvZXNIYXZlRU9TOiAlcywgaXNEb3dubG9hZFN1c3BlbmRlZDogJXMiLCBib29sRm9yUHJp bnRpbmcocHJpdi0+aXNGbHVzaGluZykKKyAgICAgICAgLCBib29sRm9yUHJpbnRpbmcocHJpdi0+ ZG9lc0hhdmVFT1MpLCBib29sRm9yUHJpbnRpbmcocHJpdi0+aXNEb3dubG9hZFN1c3BlbmRlZCkp OwogCiAgICAgaWYgKHByaXYtPmRvZXNIYXZlRU9TKSB7CiAgICAgICAgIEdTVF9ERUJVR19PQkpF Q1Qoc3JjLCAiRU9TIik7CkBAIC0zOTMsMjggKzUyNyw1NCBAQCBzdGF0aWMgR3N0Rmxvd1JldHVy biB3ZWJLaXRXZWJTcmNDcmVhdGUoR3N0UHVzaFNyYyogcHVzaFNyYywgR3N0QnVmZmVyKiogYnVm ZmVyKQogICAgIH0KIAogICAgIHVuc2lnbmVkIHNpemUgPSBnc3RfYmFzZV9zcmNfZ2V0X2Jsb2Nr c2l6ZShiYXNlU3JjKTsKLSAgICBib29sIGlzQWRhcHRlckRyYWluZWQgPSBmYWxzZTsKKyAgICBz aXplX3QgcXVldWVTaXplOwogICAgIHsKICAgICAgICAgTG9ja0hvbGRlciBhZGFwdGVyTG9ja2Vy KHByaXYtPmFkYXB0ZXJMb2NrKTsKICAgICAgICAgdW5zaWduZWQgcmV0cmllcyA9IDA7Ci0gICAg ICAgIHNpemVfdCBhdmFpbGFibGUgPSBnc3RfYWRhcHRlcl9hdmFpbGFibGVfZmFzdChwcml2LT5h ZGFwdGVyLmdldCgpKTsKLSAgICAgICAgd2hpbGUgKGF2YWlsYWJsZSA8IHNpemUgJiYgIWlzQWRh cHRlckRyYWluZWQpIHsKLSAgICAgICAgICAgIHByaXYtPmFkYXB0ZXJDb25kaXRpb24ud2FpdEZv cihwcml2LT5hZGFwdGVyTG9jaywgMTAwX21zLCBbJl0gewotICAgICAgICAgICAgICAgIHJldHVy biBnc3RfYWRhcHRlcl9hdmFpbGFibGVfZmFzdChwcml2LT5hZGFwdGVyLmdldCgpKSA+PSBzaXpl OworICAgICAgICBxdWV1ZVNpemUgPSBnc3RfYWRhcHRlcl9hdmFpbGFibGUocHJpdi0+YWRhcHRl ci5nZXQoKSk7CisgICAgICAgIEdTVF9UUkFDRV9PQkpFQ1Qoc3JjLCAiYXZhaWxhYmxlICUiIEdf R1NJWkVfRk9STUFUICIsIGJsb2NrIHNpemUgJXUiLCBxdWV1ZVNpemUsIHNpemUpOworICAgICAg ICB3aGlsZSAoIXF1ZXVlU2l6ZSAmJiAhcHJpdi0+aXNGbHVzaGluZykgeworICAgICAgICAgICAg Ly8gUG9zaXRpb24gaXMgbm90IGdvaW5nIHRvIG1vdmUgd2hlbiBkb3dubG9hZCBpcyBzdXNwZW5k ZWQgYW5kIHdlIG5vdCBQTEFZSU5HLCBzbyB3ZSBjYW4gYmxvY2sgaGVyZSB3aXRob3V0IGNoZWNr aW5nIHRoZSBwb3NpdGlvbiB1bnRpbAorICAgICAgICAgICAgLy8gdGhpcyBzaXR1YXRpb24gY2hh bmdlcy4KKyAgICAgICAgICAgIGlmIChwcml2LT5pc0Rvd25sb2FkU3VzcGVuZGVkICYmICFwcml2 LT5pc1NlZWtpbmcgJiYgR1NUX1NUQVRFKHNyYykgPCBHU1RfU1RBVEVfUExBWUlORykgeworICAg ICAgICAgICAgICAgIEdTVF9ERUJVR19PQkpFQ1Qoc3JjLCAiYmxvY2tpbmcgdW50aWwgcG9zaXRp b24gbW92ZXMiKTsKKyAgICAgICAgICAgICAgICBwcml2LT5hZGFwdGVyQ29uZGl0aW9uLndhaXQo cHJpdi0+YWRhcHRlckxvY2ssIFsmXSB7CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBwcml2 LT5pc1NlZWtpbmcgfHwgcHJpdi0+aXNGbHVzaGluZyB8fCBHU1RfU1RBVEUoc3JjKSA9PSBHU1Rf U1RBVEVfUExBWUlORzsKKyAgICAgICAgICAgICAgICB9KTsKKyAgICAgICAgICAgIH0KKworICAg ICAgICAgICAgR1NUX1RSQUNFX09CSkVDVChzcmMsICJsZXQncyB0cnkgdG8gcmVzdGFydCB0aGUg ZG93bmxvYWQgaWYgcG9zc2libGUgYW5kIHdhaXQgYSBiaXQgaWYgbm8gZGF0YSIpOworICAgICAg ICAgICAgcHJpdi0+aXNXYWl0aW5nRm9yRGF0YSA9IHRydWU7CisgICAgICAgICAgICBwcml2LT5h ZGFwdGVyQ29uZGl0aW9uLndhaXRGb3IocHJpdi0+YWRhcHRlckxvY2ssIDFfcywgWyZdIHsKKyAg ICAgICAgICAgICAgICByZXN0YXJ0TG9hZGVySWZOZWVkZWQoc3JjKTsKKyAgICAgICAgICAgICAg ICByZXR1cm4gcHJpdi0+aXNGbHVzaGluZyB8fCAoIXByaXYtPmlzRG93bmxvYWRTdXNwZW5kZWQg JiYgZ3N0X2FkYXB0ZXJfYXZhaWxhYmxlKHByaXYtPmFkYXB0ZXIuZ2V0KCkpKTsKICAgICAgICAg ICAgIH0pOwotICAgICAgICAgICAgcmV0cmllcysrOwotICAgICAgICAgICAgYXZhaWxhYmxlID0g Z3N0X2FkYXB0ZXJfYXZhaWxhYmxlX2Zhc3QocHJpdi0+YWRhcHRlci5nZXQoKSk7Ci0gICAgICAg ICAgICBpZiAoYXZhaWxhYmxlICYmIGF2YWlsYWJsZSA8IHNpemUpIHsKLSAgICAgICAgICAgICAg ICBHU1RfVFJBQ0VfT0JKRUNUKHNyYywgImRpZCBub3QgZ2V0IHRoZSAldSBibG9ja3NpemUgYnl0 ZXMsIGxldCdzIHB1c2ggdGhlICUiIEdfR1NJWkVfRk9STUFUICIgYnl0ZXMgd2UgZ290Iiwgc2l6 ZSwgYXZhaWxhYmxlKTsKLSAgICAgICAgICAgICAgICBzaXplID0gYXZhaWxhYmxlOwotICAgICAg ICAgICAgfSBlbHNlIGlmIChyZXRyaWVzID4gMykKLSAgICAgICAgICAgICAgICBpc0FkYXB0ZXJE cmFpbmVkID0gdHJ1ZTsKKyAgICAgICAgICAgIHByaXYtPmlzV2FpdGluZ0ZvckRhdGEgPSBmYWxz ZTsKKyAgICAgICAgICAgIHF1ZXVlU2l6ZSA9IGdzdF9hZGFwdGVyX2F2YWlsYWJsZShwcml2LT5h ZGFwdGVyLmdldCgpKTsKKyAgICAgICAgICAgIEdTVF9UUkFDRV9PQkpFQ1Qoc3JjLCAiYXZhaWxh YmxlICUiIEdfR1NJWkVfRk9STUFULCBxdWV1ZVNpemUpOworICAgICAgICAgICAgaWYgKHF1ZXVl U2l6ZSB8fCBwcml2LT5pc0ZsdXNoaW5nKSB7CisgICAgICAgICAgICAgICAgLy8gV2UgaGF2ZSBk YXRhIG9yIHdlJ3JlIGZsdXNoaW5nLiBXZSBjYW4gYnJlYWsgdGhlIGxvb3AgaGVyZS4KKyAgICAg ICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgIH0KKworICAgICAgICAgICAgLy8gV2Ugc2hv dWxkIGtlZXAgd2FpdGluZyBidXQgd2UgY291bGQgYmUgaW4gRU9TLiBMZXQncyBjaGVjayB0aGUg dHdvIHBvc3NpYmlsaXRpZXM6CisgICAgICAgICAgICAvLyAxLiBXZSBhcmUgdGhlIGVuZCBvZiB0 aGUga25vd24gc2l6ZSBvZiB0aGUgZmlsZS4KKyAgICAgICAgICAgIC8vIDIuIERvd25sb2FkIGlz IG5vdCBzdXNwZW5kZWQgYW5kIG5vIG1vcmUgZGF0YSBpcyBhcnJpdmluZy4gV2UgY2Fubm90IHdh aXQgZm9yZXZlciwgMTB4MXMgc2VlbXMgc2FmZSBhbmQgc2Vuc2libGUuCisgICAgICAgICAgICBp ZiAocHJpdi0+aGF2ZVNpemUgJiYgcHJpdi0+cmVhZFBvc2l0aW9uID49IHByaXYtPnNpemUpIHsK KyAgICAgICAgICAgICAgICBHU1RfREVCVUdfT0JKRUNUKHNyYywgIldhaXRpbmcgZm9yIGRhdGEg YmV5b25kIHRoZSBlbmQsIHNpZ25hbGxpbmcgRU9TIik7CisgICAgICAgICAgICAgICAgcmV0dXJu IEdTVF9GTE9XX0VPUzsKKyAgICAgICAgICAgIH0KKyAgICAgICAgICAgIEdTVF9UUkFDRV9PQkpF Q1Qoc3JjLCAiaXMgZG93bmxvYWQgc3VzcGVuZGVkICVzLCB0cmllZCAldSIsIGJvb2xGb3JQcmlu dGluZyhwcml2LT5pc0Rvd25sb2FkU3VzcGVuZGVkKSwgcmV0cmllcyArIDEpOworICAgICAgICAg ICAgaWYgKCFwcml2LT5pc0Rvd25sb2FkU3VzcGVuZGVkICYmICsrcmV0cmllcyA+PSAxMCkgewor ICAgICAgICAgICAgICAgIEdTVF9ERUJVR19PQkpFQ1Qoc3JjLCAiQWRhcHRlciBzdGlsbCBlbXB0 eSBhZnRlciAxMHMgb2Ygd2FpdGluZywgYXNzdW1pbmcgRU9TIik7CisgICAgICAgICAgICAgICAg cmV0dXJuIEdTVF9GTE9XX0VPUzsKKyAgICAgICAgICAgIH0KICAgICAgICAgfQogICAgIH0KIAot ICAgIGlmIChpc0FkYXB0ZXJEcmFpbmVkKSB7Ci0gICAgICAgIEdTVF9ERUJVR19PQkpFQ1Qoc3Jj LCAiQWRhcHRlciBzdGlsbCBlbXB0eSBhZnRlciA0MDAgbWlsbGktc2Vjb25kcyBvZiB3YWl0aW5n LCBhc3N1bWluZyBFT1MiKTsKLSAgICAgICAgcmV0dXJuIEdTVF9GTE9XX0VPUzsKKyAgICBpZiAo cHJpdi0+aXNGbHVzaGluZykgeworICAgICAgICBHU1RfREVCVUdfT0JKRUNUKHNyYywgIkZsdXNo aW5nIik7CisgICAgICAgIHJldHVybiBHU1RfRkxPV19GTFVTSElORzsKICAgICB9CiAKICAgICBp ZiAocHJpdi0+aGF2ZVNpemUgJiYgIXByaXYtPmlzRHVyYXRpb25TZXQpIHsKQEAgLTQyOCwxNCAr NTg4LDE3IEBAIHN0YXRpYyBHc3RGbG93UmV0dXJuIHdlYktpdFdlYlNyY0NyZWF0ZShHc3RQdXNo U3JjKiBwdXNoU3JjLCBHc3RCdWZmZXIqKiBidWZmZXIpCiAgICAgICAgIGdzdF9wYWRfcHVzaF9l dmVudChHU1RfQkFTRV9TUkNfUEFEKGJhc2VTcmMpLCBwcml2LT5odHRwSGVhZGVyc0V2ZW50Lmxl YWtSZWYoKSk7CiAKICAgICB7Ci0gICAgICAgIEdTVF9UUkFDRV9PQkpFQ1Qoc3JjLCAiVGFraW5n ICV1IGJ5dGVzIGZyb20gYWRhcHRlciIsIHNpemUpOwogICAgICAgICBMb2NrSG9sZGVyIGFkYXB0 ZXJMb2NrZXIocHJpdi0+YWRhcHRlckxvY2spOworICAgICAgICBxdWV1ZVNpemUgPSBnc3RfYWRh cHRlcl9hdmFpbGFibGUocHJpdi0+YWRhcHRlci5nZXQoKSk7CisgICAgICAgIGlmIChxdWV1ZVNp emUgPCBzaXplKSB7CisgICAgICAgICAgICBHU1RfVFJBQ0VfT0JKRUNUKHNyYywgIkRpZCBub3Qg Z2V0IHRoZSAldSBibG9ja3NpemUgYnl0ZXMsIGxldCdzIHB1c2ggdGhlICUiIEdfR1NJWkVfRk9S TUFUICIgYnl0ZXMgd2UgZ290Iiwgc2l6ZSwgcXVldWVTaXplKTsKKyAgICAgICAgICAgIHNpemUg PSBxdWV1ZVNpemU7CisgICAgICAgIH0gZWxzZQorICAgICAgICAgICAgR1NUX1RSQUNFX09CSkVD VChzcmMsICJUYWtpbmcgJXUgYnl0ZXMgZnJvbSBhZGFwdGVyIiwgc2l6ZSk7CiAgICAgICAgIGlm IChzaXplKSB7Ci0gICAgICAgICAgICAqYnVmZmVyID0gZ3N0X2FkYXB0ZXJfdGFrZV9idWZmZXJf ZmFzdChwcml2LT5hZGFwdGVyLmdldCgpLCBzaXplKTsKKyAgICAgICAgICAgICpidWZmZXIgPSBn c3RfYWRhcHRlcl90YWtlX2J1ZmZlcihwcml2LT5hZGFwdGVyLmdldCgpLCBzaXplKTsKICAgICAg ICAgICAgIFJFTEVBU0VfQVNTRVJUKCpidWZmZXIpOwogCi0gICAgICAgICAgICBwcml2LT5xdWV1 ZVNpemUgLT0gc2l6ZTsKLQogICAgICAgICAgICAgR1NUX0JVRkZFUl9PRkZTRVQoKmJ1ZmZlcikg PSBiYXNlU3JjLT5zZWdtZW50LnBvc2l0aW9uOwogICAgICAgICAgICAgR1NUX0JVRkZFUl9PRkZT RVRfRU5EKCpidWZmZXIpID0gR1NUX0JVRkZFUl9PRkZTRVQoKmJ1ZmZlcikgKyBzaXplOwogICAg ICAgICAgICAgR1NUX1RSQUNFX09CSkVDVChzcmMsICJCdWZmZXIgYm91bmRzIHNldCB0byAlIiBH X0dVSU5UNjRfRk9STUFUICItJSIgR19HVUlOVDY0X0ZPUk1BVCwgR1NUX0JVRkZFUl9PRkZTRVQo KmJ1ZmZlciksIEdTVF9CVUZGRVJfT0ZGU0VUX0VORCgqYnVmZmVyKSk7CkBAIC00NDgsMTggKzYx MSwxMSBAQCBzdGF0aWMgR3N0Rmxvd1JldHVybiB3ZWJLaXRXZWJTcmNDcmVhdGUoR3N0UHVzaFNy YyogcHVzaFNyYywgR3N0QnVmZmVyKiogYnVmZmVyKQogICAgICAgICAgICAgfSBlbHNlIGlmIChw cml2LT53YXNTZWVraW5nKQogICAgICAgICAgICAgICAgIHByaXYtPndhc1NlZWtpbmcgPSBmYWxz ZTsKIAotICAgICAgICAgICAgaWYgKCFwcml2LT5kb2VzSGF2ZUVPUyAmJiBwcml2LT5oYXZlU2l6 ZSAmJiBwcml2LT5pc1NlZWthYmxlCi0gICAgICAgICAgICAgICAgJiYgKHByaXYtPnNpemUgPiBT TUFMTF9NRURJQV9SRVNPVVJDRV9NQVhfU0laRSkgJiYgcHJpdi0+cmVhZFBvc2l0aW9uCi0gICAg ICAgICAgICAgICAgJiYgKHByaXYtPnJlYWRQb3NpdGlvbiAhPSBwcml2LT5zaXplKQotICAgICAg ICAgICAgICAgICYmIChwcml2LT5xdWV1ZVNpemUgPCAocHJpdi0+c2l6ZSAqIEhJR0hfUVVFVUVf RkFDVE9SX1RIUkVTSE9MRCAqIExPV19RVUVVRV9GQUNUT1JfVEhSRVNIT0xEKSkKLSAgICAgICAg ICAgICAgICAmJiBHU1RfU1RBVEUoc3JjKSA+PSBHU1RfU1RBVEVfUEFVU0VEICYmIHByaXYtPmlz RG93bmxvYWRTdXNwZW5kZWQpIHsKLSAgICAgICAgICAgICAgICBHU1RfREVCVUdfT0JKRUNUKHNy YywgIltCdWZmZXJpbmddIEFkYXB0ZXIgcnVubmluZyBvdXQgb2YgZGF0YSwgcmVzdGFydGluZyBk b3dubG9hZCIpOwotICAgICAgICAgICAgICAgIHByaXYtPmlzRG93bmxvYWRTdXNwZW5kZWQgPSBm YWxzZTsKLSAgICAgICAgICAgICAgICB3ZWJLaXRXZWJTcmNNYWtlUmVxdWVzdChiYXNlU3JjLCBm YWxzZSk7Ci0gICAgICAgICAgICB9Ci0KLSAgICAgICAgfSBlbHNlCi0gICAgICAgICAgICBHU1Rf RVJST1JfT0JKRUNUKHNyYywgIkVtcHR5IGFkYXB0ZXI/Iik7CisgICAgICAgICAgICByZXN0YXJ0 TG9hZGVySWZOZWVkZWQoc3JjKTsKKyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgIEdTVF9F UlJPUl9PQkpFQ1Qoc3JjLCAiRW1wdHkgYWRhcHRlciEiKTsKKyAgICAgICAgICAgIEFTU0VSVF9O T1RfUkVBQ0hFRCgpOworICAgICAgICB9CiAgICAgfQogCiAgICAgcmV0dXJuIEdTVF9GTE9XX09L OwpAQCAtNjcwLDcgKzgyNiw2IEBAIHN0YXRpYyBnYm9vbGVhbiB3ZWJLaXRXZWJTcmNTdG9wKEdz dEJhc2VTcmMqIGJhc2VTcmMpCiAgICAgewogICAgICAgICBMb2NrSG9sZGVyIGFkYXB0ZXJMb2Nr ZXIocHJpdi0+YWRhcHRlckxvY2spOwogICAgICAgICBnc3RfYWRhcHRlcl9jbGVhcihwcml2LT5h ZGFwdGVyLmdldCgpKTsKLSAgICAgICAgcHJpdi0+cXVldWVTaXplID0gMDsKICAgICB9CiAKICAg ICB3ZWJraXRXZWJTcmNSZXNldChzcmMpOwpAQCAtNzI4LDYgKzg4Myw3IEBAIHN0YXRpYyBnYm9v bGVhbiB3ZWJLaXRXZWJTcmNEb1NlZWsoR3N0QmFzZVNyYyogYmFzZVNyYywgR3N0U2VnbWVudCog c2VnbWVudCkKICAgICBwcml2LT5pc1NlZWtpbmcgPSB0cnVlOwogICAgIHByaXYtPnJlcXVlc3Rl ZFBvc2l0aW9uID0gc2VnbWVudC0+c3RhcnQ7CiAgICAgcHJpdi0+c3RvcFBvc2l0aW9uID0gc2Vn bWVudC0+c3RvcDsKKyAgICBwcml2LT5hZGFwdGVyQ29uZGl0aW9uLm5vdGlmeU9uZSgpOwogICAg IHJldHVybiBUUlVFOwogfQogCkBAIC03NjYsNiArOTIyLDcgQEAgc3RhdGljIGdib29sZWFuIHdl YktpdFdlYlNyY1VuTG9jayhHc3RCYXNlU3JjKiBiYXNlU3JjKQogICAgIEdTVF9ERUJVR19PQkpF Q1Qoc3JjLCAiVW5sb2NrIik7CiAgICAgc3JjLT5wcml2LT5pc0ZsdXNoaW5nID0gdHJ1ZTsKICAg ICBzcmMtPnByaXYtPnJlc3BvbnNlQ29uZGl0aW9uLm5vdGlmeU9uZSgpOworICAgIHNyYy0+cHJp di0+YWRhcHRlckNvbmRpdGlvbi5ub3RpZnlPbmUoKTsKICAgICByZXR1cm4gVFJVRTsKIH0KIApA QCAtNzk1LDggKzk1MiwxNCBAQCBzdGF0aWMgR3N0U3RhdGVDaGFuZ2VSZXR1cm4gd2ViS2l0V2Vi U3JjQ2hhbmdlU3RhdGUoR3N0RWxlbWVudCogZWxlbWVudCwgR3N0U3RhdAogICAgICAgICBHU1Rf REVCVUdfT0JKRUNUKHNyYywgIlBBVVNFRC0+UkVBRFkgY2FuY2VsbGluZyBuZXR3b3JrIHJlcXVl c3RzIik7CiAgICAgICAgIHNyYy0+cHJpdi0+aXNGbHVzaGluZyA9IHRydWU7CiAgICAgICAgIHNy Yy0+cHJpdi0+cmVzcG9uc2VDb25kaXRpb24ubm90aWZ5T25lKCk7CisgICAgICAgIHNyYy0+cHJp di0+YWRhcHRlckNvbmRpdGlvbi5ub3RpZnlPbmUoKTsKKyAgICAgICAgYnJlYWs7CisgICAgfQor ICAgIGNhc2UgR1NUX1NUQVRFX0NIQU5HRV9QQVVTRURfVE9fUExBWUlORzoKKyAgICAgICAgc3Jj LT5wcml2LT5pc0luaXRpYWxMb2FkID0gZmFsc2U7CisgICAgICAgIHNyYy0+cHJpdi0+YWRhcHRl ckNvbmRpdGlvbi5ub3RpZnlPbmUoKTsKICAgICAgICAgYnJlYWs7Ci0gICAgfSBkZWZhdWx0Ogor ICAgIGRlZmF1bHQ6CiAgICAgICAgIGJyZWFrOwogICAgIH0KIApAQCAtODk1LDYgKzEwNTgsMTMg QEAgdm9pZCB3ZWJLaXRXZWJTcmNTZXRNZWRpYVBsYXllcihXZWJLaXRXZWJTcmMqIHNyYywgV2Vi Q29yZTo6TWVkaWFQbGF5ZXIqIHBsYXllcikKICAgICBzcmMtPnByaXYtPnBsYXllciA9IHBsYXll cjsKIH0KIAordm9pZCB3ZWJLaXRXZWJTcmNTZXRPbkRpc2tCdWZmZXJpbmdFbmFibGVkKFdlYktp dFdlYlNyYyogc3JjLCBib29sIGlzRW5hYmxlZCkKK3sKKyAgICBBU1NFUlQoc3JjKTsKKyAgICBz cmMtPnByaXYtPmlzT25EaXNrQnVmZmVyaW5nRW5hYmxlZCA9IGlzRW5hYmxlZDsKKyAgICBHU1Rf VFJBQ0VfT0JKRUNUKHNyYywgInNldCBvbiBkaXNrIGJ1ZmZlcmluZyBlbmFibGVkIHRvICVzIiwg Ym9vbEZvclByaW50aW5nKHNyYy0+cHJpdi0+aXNPbkRpc2tCdWZmZXJpbmdFbmFibGVkKSk7Cit9 CisKIGJvb2wgd2ViS2l0U3JjUGFzc2VkQ09SU0FjY2Vzc0NoZWNrKFdlYktpdFdlYlNyYyogc3Jj KQogewogICAgIHJldHVybiBzcmMtPnByaXYtPmRpZFBhc3NBY2Nlc3NDb250cm9sQ2hlY2s7CkBA IC05MTcsNyArMTA4Nyw3IEBAIHZvaWQgQ2FjaGVkUmVzb3VyY2VTdHJlYW1pbmdDbGllbnQ6OmNo ZWNrVXBkYXRlQmxvY2tzaXplKHVuc2lnbmVkIGJ5dGVzUmVhZCkKICAgICB1bnNpZ25lZCBibG9j a3NpemUgPSBnc3RfYmFzZV9zcmNfZ2V0X2Jsb2Nrc2l6ZShiYXNlU3JjKTsKICAgICBHU1RfTE9H X09CSkVDVChzcmMsICJDaGVja2luZyB0byB1cGRhdGUgYmxvY2tzaXplLiBSZWFkOiAldSwgY3Vy cmVudCBibG9ja3NpemU6ICV1IiwgYnl0ZXNSZWFkLCBibG9ja3NpemUpOwogCi0gICAgaWYgKGJ5 dGVzUmVhZCA+PSBibG9ja3NpemUgKiBzX2dyb3dCbG9ja3NpemVMaW1pdCkgeworICAgIGlmIChi eXRlc1JlYWQgPiBibG9ja3NpemUgKiBzX2dyb3dCbG9ja3NpemVMaW1pdCkgewogICAgICAgICBt X3JlZHVjZUJsb2Nrc2l6ZUNvdW50ID0gMDsKICAgICAgICAgbV9pbmNyZWFzZUJsb2Nrc2l6ZUNv dW50Kys7CiAKQEAgLTEwNjksNiArMTIzOSwxNyBAQCB2b2lkIENhY2hlZFJlc291cmNlU3RyZWFt aW5nQ2xpZW50OjpkYXRhUmVjZWl2ZWQoUGxhdGZvcm1NZWRpYVJlc291cmNlJiwgY29uc3QgYwog CiAgICAgR1NUX0xPR19PQkpFQ1Qoc3JjLCAiSGF2ZSAlZCBieXRlcyBvZiBkYXRhIiwgbGVuZ3Ro KTsKICAgICBMb2NrSG9sZGVyIGxvY2tlcihwcml2LT5yZXNwb25zZUxvY2spOworICAgIC8vIFJv dWdoIGJhbmR3aWR0aCBjYWxjdWxhdGlvbi4gV2UgaWdub3JlIGhlcmUgdGhlIGZpcnN0IGRhdGEg cGFja2FnZSBiZWNhdXNlIHdlIHdvdWxkIGhhdmUgdG8gcmVzZXQgdGhlIGNvdW50ZXJzIHdoZW4g d2UgaXNzdWUgdGhlIHJlcXVlc3QgYW5kCisgICAgLy8gdGhhdCBmaXJzdCBwYWNrYWdlIGRlbGl2 ZXJ5IHdvdWxkIGluY2x1ZGUgdGhlIHRpbWUgb2Ygc2VuZGluZyBvdXQgdGhlIHJlcXVlc3QgYW5k IGdldHRpbmcgdGhlIGRhdGEgYmFjay4gU2luY2Ugd2UgY2FuJ3QgZGlzdGluZ8O8aXNoIHRoZQor ICAgIC8vIHNlbmRpbmcgdGltZSBmcm9tIHRoZSByZWNlaXZpbmcgdGltZSwgaXQgaXMgYmV0dGVy IHRvIGlnbm9yZSBpdC4KKyAgICBpZiAocHJpdi0+ZG93bmxvYWRTdGFydFRpbWUpIHsKKyAgICAg ICAgcHJpdi0+dG90YWxEb3dubG9hZGVkQnl0ZXMgKz0gbGVuZ3RoOworICAgICAgICBkb3VibGUg dGltZVNpbmNlU3RhcnQgPSAoV2FsbFRpbWU6Om5vdygpIC0gcHJpdi0+ZG93bmxvYWRTdGFydFRp bWUpLnNlY29uZHMoKTsKKyAgICAgICAgR1NUX1RSQUNFX09CSkVDVChzcmMsICJkb3dubG9hZGVk ICV1IGJ5dGVzIGluICVsZiBzZWNvbmRzID1+ICUxLjBsZiBieXRlcy9zZWNvbmQiLCBwcml2LT50 b3RhbERvd25sb2FkZWRCeXRlcywgdGltZVNpbmNlU3RhcnQsIHByaXYtPnRvdGFsRG93bmxvYWRl ZEJ5dGVzIC8gdGltZVNpbmNlU3RhcnQpOworICAgIH0gZWxzZSB7CisgICAgICAgIHByaXYtPmRv d25sb2FkU3RhcnRUaW1lID0gV2FsbFRpbWU6Om5vdygpOworICAgICAgICBwcml2LT50b3RhbERv d25sb2FkZWRCeXRlcyA9IDA7CisgICAgfQogCiAgICAgdWludDY0X3QgbmV3UG9zaXRpb24gPSBw cml2LT5yZWFkUG9zaXRpb24gKyBsZW5ndGg7CiAgICAgaWYgKExJS0VMWSAocHJpdi0+cmVxdWVz dGVkUG9zaXRpb24gPT0gcHJpdi0+cmVhZFBvc2l0aW9uKSkKQEAgLTExMDMsMTggKzEyODQsOCBA QCB2b2lkIENhY2hlZFJlc291cmNlU3RyZWFtaW5nQ2xpZW50OjpkYXRhUmVjZWl2ZWQoUGxhdGZv cm1NZWRpYVJlc291cmNlJiwgY29uc3QgYwogICAgIHsKICAgICAgICAgTG9ja0hvbGRlciBhZGFw dGVyTG9ja2VyKHByaXYtPmFkYXB0ZXJMb2NrKTsKICAgICAgICAgR3N0QnVmZmVyKiBidWZmZXIg PSBnc3RfYnVmZmVyX25ld193cmFwcGVkKGdfbWVtZHVwKGRhdGEsIGxlbmd0aCksIGxlbmd0aCk7 Ci0gICAgICAgIHByaXYtPnF1ZXVlU2l6ZSArPSBsZW5ndGg7CiAgICAgICAgIGdzdF9hZGFwdGVy X3B1c2gocHJpdi0+YWRhcHRlci5nZXQoKSwgYnVmZmVyKTsKLSAgICAgICAgR1NUX1RSQUNFX09C SkVDVChzcmMsICJbQnVmZmVyaW5nXSBpc0Rvd25sb2FkU3VzcGVuZGVkOiAlcyIsIGJvb2xGb3JQ cmludGluZyhwcml2LT5pc0Rvd25sb2FkU3VzcGVuZGVkKSk7Ci0gICAgICAgIGlmIChwcml2LT5o YXZlU2l6ZSAmJiAocHJpdi0+c2l6ZSA+IFNNQUxMX01FRElBX1JFU09VUkNFX01BWF9TSVpFKSAm JiAocHJpdi0+cXVldWVTaXplID4gKHByaXYtPnNpemUgKiBISUdIX1FVRVVFX0ZBQ1RPUl9USFJF U0hPTEQpKQotICAgICAgICAgICAgJiYgIXByaXYtPmlzRG93bmxvYWRTdXNwZW5kZWQgJiYgcHJp di0+aXNTZWVrYWJsZSkgewotICAgICAgICAgICAgR1NUX1RSQUNFX09CSkVDVChzcmMsICJbQnVm ZmVyaW5nXSBxdWV1ZVNpemU6ICUiIEdfR1VJTlQ2NF9GT1JNQVQgIiwgdGhyZXNob2xkOiAlZiIs IHByaXYtPnF1ZXVlU2l6ZSwKLSAgICAgICAgICAgICAgICBwcml2LT5zaXplICogSElHSF9RVUVV RV9GQUNUT1JfVEhSRVNIT0xEKTsKLSAgICAgICAgICAgIEdTVF9ERUJVR19PQkpFQ1Qoc3JjLCAi W0J1ZmZlcmluZ10gU3RvcHBpbmcgcmVzb3VyY2UgbG9hZGVyIik7Ci0gICAgICAgICAgICBwcml2 LT5pc0Rvd25sb2FkU3VzcGVuZGVkID0gdHJ1ZTsKLSAgICAgICAgICAgIHByaXYtPnJlc291cmNl LT5zdG9wKCk7Ci0gICAgICAgICAgICByZXR1cm47Ci0gICAgICAgIH0KKyAgICAgICAgc3RvcExv YWRlcklmTmVlZGVkKHNyYyk7CiAgICAgICAgIHByaXYtPmFkYXB0ZXJDb25kaXRpb24ubm90aWZ5 T25lKCk7CiAgICAgfQogfQpAQCAtMTE2MCw0ICsxMzMxLDE5IEBAIGJvb2wgd2ViS2l0U3JjV291 bGRUYWludE9yaWdpbihXZWJLaXRXZWJTcmMqIHNyYywgY29uc3QgU2VjdXJpdHlPcmlnaW4mIG9y aWdpbikKICAgICByZXR1cm4gZmFsc2U7CiB9CiAKK2Jvb2wgd2ViS2l0U3JjSXNXYWl0aW5nRm9y RGF0YShXZWJLaXRXZWJTcmMqIHNyYykKK3sKKyAgICBXZWJLaXRXZWJTcmNQcml2YXRlKiBwcml2 ID0gc3JjLT5wcml2OworCisgICAgYm9vbCByZXN1bHQgPSAhcHJpdi0+aXNEb3dubG9hZFN1c3Bl bmRlZCAmJiBwcml2LT5pc1dhaXRpbmdGb3JEYXRhOworCisgICAgaWYgKHJlc3VsdCAmJiBwcml2 LT5oYXZlU2l6ZSkKKyAgICAgICAgcmVzdWx0ID0gcHJpdi0+cmVhZFBvc2l0aW9uIDwgcHJpdi0+ c2l6ZTsKKworICAgIEdTVF9UUkFDRV9PQkpFQ1Qoc3JjLCAiaXMgd2FpdGluZyBmb3IgZGF0YSAl cywgaXMgZG93bmxvYWQgc3VzcGVuZGVkICVzLCBoYXMgc2l6ZSAlcywgcmVhZCBwb3NpdGlvbiAl IiBHX0dVSU5UNjRfRk9STUFUICIsIHNpemUgJSIgR19HVUlOVDY0X0ZPUk1BVAorICAgICAgICAi LCByZXN1bHQgJXMiLCBib29sRm9yUHJpbnRpbmcocHJpdi0+aXNXYWl0aW5nRm9yRGF0YSksIGJv b2xGb3JQcmludGluZyhwcml2LT5pc0Rvd25sb2FkU3VzcGVuZGVkKSwgYm9vbEZvclByaW50aW5n KHByaXYtPmhhdmVTaXplKSwgcHJpdi0+cmVhZFBvc2l0aW9uCisgICAgICAgICwgcHJpdi0+c2l6 ZSwgYm9vbEZvclByaW50aW5nKHJlc3VsdCkpOworICAgIHJldHVybiByZXN1bHQ7Cit9CisKICNl bmRpZiAvLyBFTkFCTEUoVklERU8pICYmIFVTRShHU1RSRUFNRVIpCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvV2ViS2l0V2ViU291cmNlR1N0 cmVhbWVyLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvV2Vi S2l0V2ViU291cmNlR1N0cmVhbWVyLmgKaW5kZXggZjNkOThmYmVjOWI2NDIwNWJkZmI5ZTU0OTdh ZTUwMjEzZTg0MTA4MS4uZWE2NjUwYjU3MTVhY2E4ZWY3NTI2NjNkMzY0OTRhOTQ2ZTg0YjBiYyAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL1dl YktpdFdlYlNvdXJjZUdTdHJlYW1lci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2dzdHJlYW1lci9XZWJLaXRXZWJTb3VyY2VHU3RyZWFtZXIuaApAQCAtNTUsOCArNTUs MTAgQEAgc3RydWN0IF9XZWJLaXRXZWJTcmNDbGFzcyB7CiAKIEdUeXBlIHdlYmtpdF93ZWJfc3Jj X2dldF90eXBlKHZvaWQpOwogdm9pZCB3ZWJLaXRXZWJTcmNTZXRNZWRpYVBsYXllcihXZWJLaXRX ZWJTcmMqLCBXZWJDb3JlOjpNZWRpYVBsYXllciopOwordm9pZCB3ZWJLaXRXZWJTcmNTZXRPbkRp c2tCdWZmZXJpbmdFbmFibGVkKFdlYktpdFdlYlNyYyosIGJvb2wpOwogYm9vbCB3ZWJLaXRTcmNQ YXNzZWRDT1JTQWNjZXNzQ2hlY2soV2ViS2l0V2ViU3JjKik7CiBib29sIHdlYktpdFNyY1dvdWxk VGFpbnRPcmlnaW4oV2ViS2l0V2ViU3JjKiwgY29uc3QgV2ViQ29yZTo6U2VjdXJpdHlPcmlnaW4m KTsKK2Jvb2wgd2ViS2l0U3JjSXNXYWl0aW5nRm9yRGF0YShXZWJLaXRXZWJTcmMqKTsKIAogR19F TkRfREVDTFMKIAo= 387223 2020-01-09 07:15:05 -0800 2022-02-10 16:31:15 -0800 Patch bug-205275-20200109161504.patch text/plain 19918 calvaris U3VidmVyc2lvbiBSZXZpc2lvbjogMjU0MTg5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYmExOWNmYjBiOGNkYjQy ZDI1NjE4YzAyYzBiNjZlOGFhNjMzMTFkYS4uMjVmMmZhN2ZmMGZiNzczODFiMjI0MGM2ODE1YTA3 MjAyOGYzMDBjZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQzIEBACisyMDIwLTAxLTA5ICBYYWJp ZXIgUm9kcmlndWV6IENhbHZhciAgPGNhbHZhcmlzQGlnYWxpYS5jb20+CisKKyAgICAgICAgW0dT dHJlYW1lcl0gTWFrZSBzb3VyY2UgYXdhcmUgb2YgYnVmZmVyZWQgdGltZQorICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjA1Mjc1CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUmV3b3JrZWQgaG93IHRoZSB3ZWIg c291cmNlIGRlYWxzIHdpdGggZGF0YS4gSXQncyBtb3JlIGVhZ2VyIG5vdworICAgICAgICBpbiBw dXNoaW5nIGRhdGEgZG93bnN0cmVhbS4gV2UgZG9uJ3QgcmVhZCB0aGUgR3N0QWRhcHRlciBtZXRo b2RzCisgICAgICAgIG1hcmtlZCBhcyBmYXN0IGFueW1vcmUgYmVjYXVzZSBzb21ldGltZXMgaXQg d2FzIHNsb3dlciBhcyB3ZSB3ZXJlCisgICAgICAgIHdhaXRpbmcgZm9yIG1vcmUgYnVmZmVycyB0 aGF0IGNvdWxkIGJlIHJldHJpZXZlZCB3aXRoIHRoZSB0aG9zZQorICAgICAgICBtZXRob2RzIHRv IGJlIGF2YWlsYWJsZSBhbmQgd2UgaGFkIGVub3VnaCBpZiB3ZSByZXRyaWV2ZWQgaXQgd2l0aAor ICAgICAgICB0aGUgQVBJIHRoYXQgaXMgbm90IG1hcmtlZCBhcyBmYXN0LgorCisgICAgICAgIFRo ZSBzdHJlYW1pbmcgdGhyZWFkIGxvY2tzIG5vdyB3aGVuIGl0IGhhcyBubyBkYXRhIHRvIHB1c2gK KyAgICAgICAgZG93bnN0cmVhbSBhbmQgcmVzdGFydHMgdGhlIGRvd25sb2FkIGlmIG5lZWRlZC4K KworICAgICAgICBJbiB0aGlzIHBhdGNoIHdlIGFsc28gZml4ZWQgdGhlIHBvc3NpYmxlIHJhY2Ug Y29uZGl0aW9uIG9mCisgICAgICAgIHJlY2VpdmluZyBhIGZsdXNoIGR1cmluZyB0aGUgc3RyZWFt aW5nIHRocmVhZCB3YWl0LgorCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVy L01lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpNZWRp YVBsYXllclByaXZhdGVHU3RyZWFtZXI6OnVwZGF0ZVN0YXRlcyk6IEFkZGVkIEZBTExUSFJPVUdI LgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9XZWJLaXRXZWJTb3VyY2VH U3RyZWFtZXIuY3BwOgorICAgICAgICAocmVzdGFydExvYWRlcklmTmVlZGVkKToKKyAgICAgICAg KHN0b3BMb2FkZXJJZk5lZWRlZCk6IFJlZmFjdG9yZWQuCisgICAgICAgICh3ZWJLaXRXZWJTcmND cmVhdGUpOiBBdm9pZCBhZGFwdGVyIG1ldGhvZHMgbWFya2VkIGFzIGZhc3QsCisgICAgICAgIG90 aGVyd2lzZSB3ZSBtaWdodCBiZSB3YWl0aW5nIGZvciBkYXRhIHdlIGFscmVhZHkgaGF2ZS4gU3Ry ZWFtaW5nCisgICAgICAgIHRocmVhZCBpcyBub3cgZ29pbmcgdG8gbG9jayB3YWl0aW5nIGZvciBk YXRhIGFuZCBpcyBtb3JlIGVhZ2VyIGluCisgICAgICAgIHB1c2hpbmcgZGF0YSBkb3duc3RyZWFt LgorICAgICAgICAod2ViS2l0V2ViU3JjU3RvcCk6IE5vIG1vcmUgcXVldWVTaXplLgorICAgICAg ICAod2ViS2l0V2ViU3JjRG9TZWVrKToKKyAgICAgICAgKHdlYktpdFdlYlNyY1VuTG9jayk6Cisg ICAgICAgICh3ZWJLaXRXZWJTcmNDaGFuZ2VTdGF0ZSk6IE5vdGlmeSBzdHJlYW1pbmcgdGhyZWFk LgorICAgICAgICAoQ2FjaGVkUmVzb3VyY2VTdHJlYW1pbmdDbGllbnQ6OmNoZWNrVXBkYXRlQmxv Y2tzaXplKTogQmxvY2tzaXplCisgICAgICAgIGFkanVzdG1lbnQgaW1wcm92ZWQuIFdpdGggZm9y bWVyIHZhbHVlcyBibG9ja3NpemUgZ3JldyB0b28gZmFzdAorICAgICAgICBhbmQgY291bGRuJ3Qg YmUgcmVkdWNlZCBzbyBlYXNpbHkuIEkgdGhpbmsgbm93IGl0IGFkanVzdHMgbW9yZQorICAgICAg ICBxdWlja2x5IHRvIHRoZSByZWFsIG5ldHdvcmsgdmFsdWVzLgorICAgICAgICAoQ2FjaGVkUmVz b3VyY2VTdHJlYW1pbmdDbGllbnQ6OmRhdGFSZWNlaXZlZCk6IEFkZGVkIHJ1ZGltZW50YXJ5Cisg ICAgICAgIGJhbmR3aXRoIGNhbGN1bGF0aW9uIGFuZCB1c2Ugc3RvcExvYWRlcklmTmVlZGVkLgor CiAyMDIwLTAxLTA3ICBTYWlkIEFib3UtSGFsbGF3YSAgPHNhYm91aGFsbGF3YUBhcHBsZS5jb20+ CiAKICAgICAgICAgSW1wbGVtZW50IGNzczMtaW1hZ2VzIGltYWdlLW9yaWVudGF0aW9uCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvTWVkaWFQ bGF5ZXJQcml2YXRlR1N0cmVhbWVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2dzdHJlYW1lci9NZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXIuY3BwCmluZGV4IDQzNzlm ZWM4ODgyMTA2M2NmOTEyZDlhNzZjNzUwOGQ5ZDhmNWUwZWQuLjllYWIyNzgyZDhmOTY3MzQ0MTQz MzdjZWMwN2MxYzc1ZTg5ZDBlY2YgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2dzdHJlYW1lci9NZWRpYVBsYXllclByaXZhdGVHU3RyZWFtZXIuY3BwCisrKyBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9NZWRpYVBsYXllclBy aXZhdGVHU3RyZWFtZXIuY3BwCkBAIC0yNTc0LDYgKzI1NzQsNyBAQCB2b2lkIE1lZGlhUGxheWVy UHJpdmF0ZUdTdHJlYW1lcjo6dXBkYXRlU3RhdGVzKCkKICAgICAgICAgICAgIG1fbmV0d29ya1N0 YXRlID0gTWVkaWFQbGF5ZXI6Ok5ldHdvcmtTdGF0ZTo6RW1wdHk7CiAgICAgICAgICAgICBicmVh azsKICAgICAgICAgY2FzZSBHU1RfU1RBVEVfUEFVU0VEOgorICAgICAgICAgICAgRkFMTFRIUk9V R0g7CiAgICAgICAgIGNhc2UgR1NUX1NUQVRFX1BMQVlJTkc6CiAgICAgICAgICAgICBpZiAobV9p c0J1ZmZlcmluZykgewogICAgICAgICAgICAgICAgIGlmIChtX2J1ZmZlcmluZ1BlcmNlbnRhZ2Ug PT0gMTAwKSB7CkBAIC0yNjE0LDcgKzI2MTUsNyBAQCB2b2lkIE1lZGlhUGxheWVyUHJpdmF0ZUdT dHJlYW1lcjo6dXBkYXRlU3RhdGVzKCkKICAgICAgICAgfSBlbHNlIGlmIChtX2N1cnJlbnRTdGF0 ZSA9PSBHU1RfU1RBVEVfUExBWUlORykgewogICAgICAgICAgICAgbV9pc1BhdXNlZCA9IGZhbHNl OwogCi0gICAgICAgICAgICBpZiAoKG1faXNCdWZmZXJpbmcgJiYgbV9pc0xpdmVTdHJlYW0pIHx8 ICFtX3BsYXliYWNrUmF0ZSkgeworICAgICAgICAgICAgaWYgKChtX2lzQnVmZmVyaW5nICYmICFt X2lzTGl2ZVN0cmVhbSkgfHwgIW1fcGxheWJhY2tSYXRlKSB7CiAgICAgICAgICAgICAgICAgR1NU X0RFQlVHX09CSkVDVChwaXBlbGluZSgpLCAiW0J1ZmZlcmluZ10gUGF1c2luZyBzdHJlYW0gZm9y IGJ1ZmZlcmluZy4iKTsKICAgICAgICAgICAgICAgICBjaGFuZ2VQaXBlbGluZVN0YXRlKEdTVF9T VEFURV9QQVVTRUQpOwogICAgICAgICAgICAgfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL1dlYktpdFdlYlNvdXJjZUdTdHJlYW1lci5jcHAg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvV2ViS2l0V2ViU291 cmNlR1N0cmVhbWVyLmNwcAppbmRleCA2NDE1NDE3OTczMDc5MDMwMWFlMTc4ZWY4NGQ3ZjhhZDdl ZWZlZDQ3Li4wMWRlZTg3MWQ2ODgwYjI5MDczYjJmYzcyOWVhMDI3YjdkOTVhOWY0IDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvV2ViS2l0V2Vi U291cmNlR1N0cmVhbWVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9nc3RyZWFtZXIvV2ViS2l0V2ViU291cmNlR1N0cmVhbWVyLmNwcApAQCAtNzMsOSArNzMsOSBA QCBwcml2YXRlOgogICAgIHZvaWQgbG9hZEZpbmlzaGVkKFBsYXRmb3JtTWVkaWFSZXNvdXJjZSYp IG92ZXJyaWRlOwogCiAgICAgc3RhdGljIGNvbnN0ZXhwciBpbnQgc19ncm93QmxvY2tzaXplTGlt aXQgeyAxIH07Ci0gICAgc3RhdGljIGNvbnN0ZXhwciBpbnQgc19ncm93QmxvY2tzaXplQ291bnQg eyAxIH07CisgICAgc3RhdGljIGNvbnN0ZXhwciBpbnQgc19ncm93QmxvY2tzaXplQ291bnQgeyAy IH07CiAgICAgc3RhdGljIGNvbnN0ZXhwciBpbnQgc19ncm93QmxvY2tzaXplRmFjdG9yIHsgMiB9 OwotICAgIHN0YXRpYyBjb25zdGV4cHIgZmxvYXQgc19yZWR1Y2VCbG9ja3NpemVMaW1pdCB7IDAu MjAgfTsKKyAgICBzdGF0aWMgY29uc3RleHByIGZsb2F0IHNfcmVkdWNlQmxvY2tzaXplTGltaXQg eyAwLjUgfTsKICAgICBzdGF0aWMgY29uc3RleHByIGludCBzX3JlZHVjZUJsb2Nrc2l6ZUNvdW50 IHsgMiB9OwogICAgIHN0YXRpYyBjb25zdGV4cHIgZmxvYXQgc19yZWR1Y2VCbG9ja3NpemVGYWN0 b3IgeyAwLjUgfTsKICAgICBpbnQgbV9yZWR1Y2VCbG9ja3NpemVDb3VudCB7IDAgfTsKQEAgLTE0 MSwxMSArMTQxLDEyIEBAIHN0cnVjdCBfV2ViS2l0V2ViU3JjUHJpdmF0ZSB7CiAgICAgdW5zaWdu ZWQgbWluaW11bUJsb2Nrc2l6ZTsKICAgICBMb2NrIGFkYXB0ZXJMb2NrOwogICAgIENvbmRpdGlv biBhZGFwdGVyQ29uZGl0aW9uOwotICAgIHVpbnQ2NF90IHF1ZXVlU2l6ZSB7IDAgfTsKICAgICBi b29sIGlzRG93bmxvYWRTdXNwZW5kZWQgeyBmYWxzZSB9OwogICAgIEdSZWZQdHI8R3N0QWRhcHRl cj4gYWRhcHRlcjsKICAgICBHUmVmUHRyPEdzdEV2ZW50PiBodHRwSGVhZGVyc0V2ZW50OwogICAg IEdVbmlxdWVQdHI8R3N0U3RydWN0dXJlPiBodHRwSGVhZGVyczsKKyAgICBXYWxsVGltZSBkb3du bG9hZFN0YXJ0VGltZSB7IFdhbGxUaW1lKCkgfTsKKyAgICBndWludCB0b3RhbERvd25sb2FkZWRC eXRlcyB7IDAgfTsKIH07CiAKIGVudW0gewpAQCAtMTgwLDYgKzE4MSw4IEBAIHN0YXRpYyBnYm9v bGVhbiB3ZWJLaXRXZWJTcmNRdWVyeShHc3RCYXNlU3JjKiwgR3N0UXVlcnkqKTsKIHN0YXRpYyBn Ym9vbGVhbiB3ZWJLaXRXZWJTcmNVbkxvY2soR3N0QmFzZVNyYyopOwogc3RhdGljIGdib29sZWFu IHdlYktpdFdlYlNyY1VuTG9ja1N0b3AoR3N0QmFzZVNyYyopOwogc3RhdGljIHZvaWQgd2ViS2l0 V2ViU3JjU2V0Q29udGV4dChHc3RFbGVtZW50KiwgR3N0Q29udGV4dCopOworc3RhdGljIHZvaWQg cmVzdGFydExvYWRlcklmTmVlZGVkKFdlYktpdFdlYlNyYyopOworc3RhdGljIHZvaWQgc3RvcExv YWRlcklmTmVlZGVkKFdlYktpdFdlYlNyYyopOwogCiAjZGVmaW5lIHdlYmtpdF93ZWJfc3JjX3Bh cmVudF9jbGFzcyBwYXJlbnRfY2xhc3MKIFdFQktJVF9ERUZJTkVfVFlQRV9XSVRIX0NPREUoV2Vi S2l0V2ViU3JjLCB3ZWJraXRfd2ViX3NyYywgR1NUX1RZUEVfUFVTSF9TUkMsCkBAIC0zNDUsNiAr MzQ4LDczIEBAIHN0YXRpYyB2b2lkIHdlYktpdFdlYlNyY1NldENvbnRleHQoR3N0RWxlbWVudCog ZWxlbWVudCwgR3N0Q29udGV4dCogY29udGV4dCkKICAgICBHU1RfRUxFTUVOVF9DTEFTUyhwYXJl bnRfY2xhc3MpLT5zZXRfY29udGV4dChlbGVtZW50LCBjb250ZXh0KTsKIH0KIAorc3RhdGljIHZv aWQgcmVzdGFydExvYWRlcklmTmVlZGVkKFdlYktpdFdlYlNyYyogc3JjKQoreworICAgIFdlYktp dFdlYlNyY1ByaXZhdGUqIHByaXYgPSBzcmMtPnByaXY7CisKKyAgICBpZiAoIXByaXYtPmlzRG93 bmxvYWRTdXNwZW5kZWQpIHsKKyAgICAgICAgR1NUX1RSQUNFX09CSkVDVChzcmMsICJkb3dubG9h ZCBhbHJlYWR5IGFjdGl2ZSIpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgR1NUX1RS QUNFX09CSkVDVChzcmMsICJpcyBkb3dubG9hZCBzdXNwZW5kZWQgJXMsIGRvZXMgaGF2ZSBFT1Mg JXMsIGRvZXMgaGF2ZSBzaXplICVzLCBpcyBzZWVrYWJsZSAlcywgc2l6ZSAlIiBHX0dVSU5UNjRf Rk9STUFUCisgICAgICAgICIgKG1pbiAldSkiLCBib29sRm9yUHJpbnRpbmcocHJpdi0+aXNEb3du bG9hZFN1c3BlbmRlZCksIGJvb2xGb3JQcmludGluZyhwcml2LT5kb2VzSGF2ZUVPUyksIGJvb2xG b3JQcmludGluZyhwcml2LT5oYXZlU2l6ZSkKKyAgICAgICAgLCBib29sRm9yUHJpbnRpbmcocHJp di0+aXNTZWVrYWJsZSksIHByaXYtPnNpemUsIFNNQUxMX01FRElBX1JFU09VUkNFX01BWF9TSVpF KTsKKyAgICBpZiAocHJpdi0+ZG9lc0hhdmVFT1MgfHwgIXByaXYtPmhhdmVTaXplIHx8ICFwcml2 LT5pc1NlZWthYmxlIHx8IHByaXYtPnNpemUgPD0gU01BTExfTUVESUFfUkVTT1VSQ0VfTUFYX1NJ WkUpIHsKKyAgICAgICAgR1NUX1RSQUNFX09CSkVDVChzcmMsICJkb3dubG9hZCBjYW5ub3QgYmUg c3RvcHBlZC9yZXN0YXJ0ZWQiKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKyAgICBHU1RfVFJB Q0VfT0JKRUNUKHNyYywgInJlYWQgcG9zaXRpb24gJSIgR19HVUlOVDY0X0ZPUk1BVCAiLCBzdGF0 ZSAlcyIsIHByaXYtPnJlYWRQb3NpdGlvbiwgZ3N0X2VsZW1lbnRfc3RhdGVfZ2V0X25hbWUoR1NU X1NUQVRFKHNyYykpKTsKKyAgICBpZiAoIXByaXYtPnJlYWRQb3NpdGlvbiB8fCBwcml2LT5yZWFk UG9zaXRpb24gPT0gcHJpdi0+c2l6ZSB8fCBHU1RfU1RBVEUoc3JjKSA8IEdTVF9TVEFURV9QQVVT RUQpIHsKKyAgICAgICAgR1NUX1RSQUNFX09CSkVDVChzcmMsICJjYW4ndCByZXN0YXJ0IGRvd25s b2FkIik7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBzaXplX3QgcXVldWVTaXplID0g Z3N0X2FkYXB0ZXJfYXZhaWxhYmxlKHByaXYtPmFkYXB0ZXIuZ2V0KCkpOworICAgIEdTVF9UUkFD RV9PQkpFQ1Qoc3JjLCAicXVldWUgc2l6ZSAlIiBHX0dVSU5UNjRfRk9STUFUICIgKG1pbiAlMS4w bGYpIiwgcXVldWVTaXplCisgICAgICAgICwgcHJpdi0+c2l6ZSAqIEhJR0hfUVVFVUVfRkFDVE9S X1RIUkVTSE9MRCAqIExPV19RVUVVRV9GQUNUT1JfVEhSRVNIT0xEKTsKKworICAgIGlmIChxdWV1 ZVNpemUgPj0gcHJpdi0+c2l6ZSAqIEhJR0hfUVVFVUVfRkFDVE9SX1RIUkVTSE9MRCAqIExPV19R VUVVRV9GQUNUT1JfVEhSRVNIT0xEKSB7CisgICAgICAgIEdTVF9UUkFDRV9PQkpFQ1Qoc3JjLCAi cXVldWUgc2l6ZSBhYm92ZSBsb3cgd2F0ZXJtYXJrLCBub3QgcmVzdGFydGluZyBkb3dubG9hZCIp OworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgR1NUX0RFQlVHX09CSkVDVChzcmMsICJy ZXN0YXJ0aW5nIGRvd25sb2FkIik7CisgICAgcHJpdi0+aXNEb3dubG9hZFN1c3BlbmRlZCA9IGZh bHNlOworICAgIHdlYktpdFdlYlNyY01ha2VSZXF1ZXN0KEdTVF9CQVNFX1NSQ19DQVNUKHNyYyks IGZhbHNlKTsKK30KKworCitzdGF0aWMgdm9pZCBzdG9wTG9hZGVySWZOZWVkZWQoV2ViS2l0V2Vi U3JjKiBzcmMpCit7CisgICAgV2ViS2l0V2ViU3JjUHJpdmF0ZSogcHJpdiA9IHNyYy0+cHJpdjsK KworICAgIGlmIChwcml2LT5pc0Rvd25sb2FkU3VzcGVuZGVkKSB7CisgICAgICAgIEdTVF9UUkFD RV9PQkpFQ1Qoc3JjLCAiZG93bmxvYWQgYWxyZWFkeSBzdXNwZW5kZWQiKTsKKyAgICAgICAgcmV0 dXJuOworICAgIH0KKworICAgIEdTVF9UUkFDRV9PQkpFQ1Qoc3JjLCAiaXMgZG93bmxvYWQgc3Vz cGVuZGVkICVzLCBkb2VzIGhhdmUgc2l6ZSAlcywgaXMgc2Vla2FibGUgJXMsIHNpemUgJSIgR19H VUlOVDY0X0ZPUk1BVCAiIChtaW4gJXUpIgorICAgICAgICAsIGJvb2xGb3JQcmludGluZyhwcml2 LT5pc0Rvd25sb2FkU3VzcGVuZGVkKSwgYm9vbEZvclByaW50aW5nKHByaXYtPmhhdmVTaXplKSwg Ym9vbEZvclByaW50aW5nKHByaXYtPmlzU2Vla2FibGUpLCBwcml2LT5zaXplCisgICAgICAgICwg U01BTExfTUVESUFfUkVTT1VSQ0VfTUFYX1NJWkUpOworICAgIGlmICghcHJpdi0+aGF2ZVNpemUg fHwgIXByaXYtPmlzU2Vla2FibGUgfHwgcHJpdi0+c2l6ZSA8PSBTTUFMTF9NRURJQV9SRVNPVVJD RV9NQVhfU0laRSkgeworICAgICAgICBHU1RfVFJBQ0VfT0JKRUNUKHNyYywgImRvd25sb2FkIGNh bm5vdCBiZSBzdG9wcGVkL3Jlc3RhcnRlZCIpOworICAgICAgICByZXR1cm47CisgICAgfQorCisg ICAgc2l6ZV90IHF1ZXVlU2l6ZSA9IGdzdF9hZGFwdGVyX2F2YWlsYWJsZShwcml2LT5hZGFwdGVy LmdldCgpKTsKKyAgICBHU1RfVFJBQ0VfT0JKRUNUKHNyYywgInF1ZXVlIHNpemUgJSIgR19HVUlO VDY0X0ZPUk1BVCAiIChtYXggJTEuMGxmKSIsIHF1ZXVlU2l6ZSwgcHJpdi0+c2l6ZSAqIEhJR0hf UVVFVUVfRkFDVE9SX1RIUkVTSE9MRCk7CisgICAgaWYgKHF1ZXVlU2l6ZSA8PSBwcml2LT5zaXpl ICogSElHSF9RVUVVRV9GQUNUT1JfVEhSRVNIT0xEKSB7CisgICAgICAgIEdTVF9UUkFDRV9PQkpF Q1Qoc3JjLCAicXVldWUgc2l6ZSB1bmRlciBoaWdoIHdhdGVybWFyaywgbm90IHN0b3BwaW5nIGRv d25sb2FkIik7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBHU1RfREVCVUdfT0JKRUNU KHNyYywgInN0b3BwaW5nIGRvd25sb2FkIik7CisgICAgcHJpdi0+aXNEb3dubG9hZFN1c3BlbmRl ZCA9IHRydWU7CisgICAgcHJpdi0+cmVzb3VyY2UtPnN0b3AoKTsKKyAgICBwcml2LT5kb3dubG9h ZFN0YXJ0VGltZSA9IFdhbGxUaW1lKCk7Cit9CisKIHN0YXRpYyBHc3RGbG93UmV0dXJuIHdlYktp dFdlYlNyY0NyZWF0ZShHc3RQdXNoU3JjKiBwdXNoU3JjLCBHc3RCdWZmZXIqKiBidWZmZXIpCiB7 CiAgICAgR3N0QmFzZVNyYyogYmFzZVNyYyA9IEdTVF9CQVNFX1NSQ19DQVNUKHB1c2hTcmMpOwpA QCAtMzU3LDkgKzQyNyw3IEBAIHN0YXRpYyBHc3RGbG93UmV0dXJuIHdlYktpdFdlYlNyY0NyZWF0 ZShHc3RQdXNoU3JjKiBwdXNoU3JjLCBHc3RCdWZmZXIqKiBidWZmZXIpCiAgICAgICAgIHsKICAg ICAgICAgICAgIExvY2tIb2xkZXIgYWRhcHRlckxvY2tlcihwcml2LT5hZGFwdGVyTG9jayk7CiAg ICAgICAgICAgICBHU1RfREVCVUdfT0JKRUNUKHNyYywgIlNlZWtpbmcsIGZsdXNoaW5nIGFkYXB0 ZXIiKTsKLSAgICAgICAgICAgIC8vIERpc2NhcmQgYWxsIHRoZSBidWZmZXJzIGNvbWluZyBiZWZv cmUgdGhlIHJlcXVlc3RlZCBzZWVrIHBvc2l0aW9uLgotICAgICAgICAgICAgZ3N0X2FkYXB0ZXJf Zmx1c2gocHJpdi0+YWRhcHRlci5nZXQoKSwgcHJpdi0+cXVldWVTaXplKTsKLSAgICAgICAgICAg IHByaXYtPnF1ZXVlU2l6ZSA9IDA7CisgICAgICAgICAgICBnc3RfYWRhcHRlcl9jbGVhcihwcml2 LT5hZGFwdGVyLmdldCgpKTsKICAgICAgICAgfQogICAgICAgICB1aW50NjRfdCByZXF1ZXN0ZWRQ b3NpdGlvbiA9IHByaXYtPnJlcXVlc3RlZFBvc2l0aW9uOwogICAgICAgICB3ZWJLaXRXZWJTcmNT dG9wKGJhc2VTcmMpOwpAQCAtMzc5LDE0ICs0NDcsMTAgQEAgc3RhdGljIEdzdEZsb3dSZXR1cm4g d2ViS2l0V2ViU3JjQ3JlYXRlKEdzdFB1c2hTcmMqIHB1c2hTcmMsIEdzdEJ1ZmZlcioqIGJ1ZmZl cikKICAgICAgICAgfSk7CiAgICAgfQogCi0gICAgR1NUX1RSQUNFX09CSkVDVChzcmMsICJmbHVz aGluZzogJXMsIGRvZXNIYXZlRU9TOiAlcywgcXVldWVTaXplOiAlIiBHX0dVSU5UNjRfRk9STUFU ICIsIGlzRG93bmxvYWRTdXNwZW5kZWQ6ICVzIiwKLSAgICAgICAgYm9vbEZvclByaW50aW5nKHBy aXYtPmlzRmx1c2hpbmcpLCBib29sRm9yUHJpbnRpbmcocHJpdi0+ZG9lc0hhdmVFT1MpLCBwcml2 LT5xdWV1ZVNpemUsCi0gICAgICAgIGJvb2xGb3JQcmludGluZyhwcml2LT5pc0Rvd25sb2FkU3Vz cGVuZGVkKSk7Ci0KLSAgICBpZiAocHJpdi0+aXNGbHVzaGluZykgewotICAgICAgICBHU1RfREVC VUdfT0JKRUNUKHNyYywgIkZsdXNoaW5nIik7Ci0gICAgICAgIHJldHVybiBHU1RfRkxPV19GTFVT SElORzsKLSAgICB9CisgICAgLy8gV2UgZG9uJ3QgcmVhZCB0aGUgR3N0QWRhcHRlciBtZXRob2Rz IG1hcmtlZCBhcyBmYXN0IGFueW1vcmUgYmVjYXVzZSBzb21ldGltZXMgaXQgd2FzIHNsb3dlciBh cyB3ZSB3ZXJlIHdhaXRpbmcgZm9yIG1vcmUgYnVmZmVycyB0aGF0IGNvdWxkIGJlCisgICAgLy8g cmV0cmlldmVkIHdpdGggdGhlIHRob3NlIG1ldGhvZHMgdG8gYmUgYXZhaWxhYmxlIGFuZCB3ZSBo YWQgZW5vdWdoIGlmIHdlIHJldHJpZXZlZCBpdCB3aXRoIHRoZSBBUEkgdGhhdCBpcyBub3QgbWFy a2VkIGFzIGZhc3QuCisgICAgR1NUX1RSQUNFX09CSkVDVChzcmMsICJmbHVzaGluZzogJXMsIGRv ZXNIYXZlRU9TOiAlcywgaXNEb3dubG9hZFN1c3BlbmRlZDogJXMiLCBib29sRm9yUHJpbnRpbmco cHJpdi0+aXNGbHVzaGluZykKKyAgICAgICAgLCBib29sRm9yUHJpbnRpbmcocHJpdi0+ZG9lc0hh dmVFT1MpLCBib29sRm9yUHJpbnRpbmcocHJpdi0+aXNEb3dubG9hZFN1c3BlbmRlZCkpOwogCiAg ICAgaWYgKHByaXYtPmRvZXNIYXZlRU9TKSB7CiAgICAgICAgIEdTVF9ERUJVR19PQkpFQ1Qoc3Jj LCAiRU9TIik7CkBAIC0zOTQsMjggKzQ1OCw0MyBAQCBzdGF0aWMgR3N0Rmxvd1JldHVybiB3ZWJL aXRXZWJTcmNDcmVhdGUoR3N0UHVzaFNyYyogcHVzaFNyYywgR3N0QnVmZmVyKiogYnVmZmVyKQog ICAgIH0KIAogICAgIHVuc2lnbmVkIHNpemUgPSBnc3RfYmFzZV9zcmNfZ2V0X2Jsb2Nrc2l6ZShi YXNlU3JjKTsKLSAgICBib29sIGlzQWRhcHRlckRyYWluZWQgPSBmYWxzZTsKKyAgICBzaXplX3Qg cXVldWVTaXplOwogICAgIHsKICAgICAgICAgTG9ja0hvbGRlciBhZGFwdGVyTG9ja2VyKHByaXYt PmFkYXB0ZXJMb2NrKTsKICAgICAgICAgdW5zaWduZWQgcmV0cmllcyA9IDA7Ci0gICAgICAgIHNp emVfdCBhdmFpbGFibGUgPSBnc3RfYWRhcHRlcl9hdmFpbGFibGVfZmFzdChwcml2LT5hZGFwdGVy LmdldCgpKTsKLSAgICAgICAgd2hpbGUgKGF2YWlsYWJsZSA8IHNpemUgJiYgIWlzQWRhcHRlckRy YWluZWQpIHsKLSAgICAgICAgICAgIHByaXYtPmFkYXB0ZXJDb25kaXRpb24ud2FpdEZvcihwcml2 LT5hZGFwdGVyTG9jaywgMTAwX21zLCBbJl0gewotICAgICAgICAgICAgICAgIHJldHVybiBnc3Rf YWRhcHRlcl9hdmFpbGFibGVfZmFzdChwcml2LT5hZGFwdGVyLmdldCgpKSA+PSBzaXplOworICAg ICAgICBxdWV1ZVNpemUgPSBnc3RfYWRhcHRlcl9hdmFpbGFibGUocHJpdi0+YWRhcHRlci5nZXQo KSk7CisgICAgICAgIEdTVF9UUkFDRV9PQkpFQ1Qoc3JjLCAiYXZhaWxhYmxlICUiIEdfR1NJWkVf Rk9STUFUICIsIGJsb2NrIHNpemUgJXUiLCBxdWV1ZVNpemUsIHNpemUpOworICAgICAgICB3aGls ZSAoIXF1ZXVlU2l6ZSAmJiAhcHJpdi0+aXNGbHVzaGluZykgeworICAgICAgICAgICAgR1NUX1RS QUNFX09CSkVDVChzcmMsICJsZXQncyB0cnkgdG8gcmVzdGFydCB0aGUgZG93bmxvYWQgaWYgcG9z c2libGUgYW5kIHdhaXQgYSBiaXQgaWYgbm8gZGF0YSIpOworICAgICAgICAgICAgcHJpdi0+YWRh cHRlckNvbmRpdGlvbi53YWl0Rm9yKHByaXYtPmFkYXB0ZXJMb2NrLCAxX3MsIFsmXSB7CisgICAg ICAgICAgICAgICAgcmVzdGFydExvYWRlcklmTmVlZGVkKHNyYyk7CisgICAgICAgICAgICAgICAg cmV0dXJuIHByaXYtPmlzRmx1c2hpbmcgfHwgKCFwcml2LT5pc0Rvd25sb2FkU3VzcGVuZGVkICYm IGdzdF9hZGFwdGVyX2F2YWlsYWJsZShwcml2LT5hZGFwdGVyLmdldCgpKSk7CiAgICAgICAgICAg ICB9KTsKLSAgICAgICAgICAgIHJldHJpZXMrKzsKLSAgICAgICAgICAgIGF2YWlsYWJsZSA9IGdz dF9hZGFwdGVyX2F2YWlsYWJsZV9mYXN0KHByaXYtPmFkYXB0ZXIuZ2V0KCkpOwotICAgICAgICAg ICAgaWYgKGF2YWlsYWJsZSAmJiBhdmFpbGFibGUgPCBzaXplKSB7Ci0gICAgICAgICAgICAgICAg R1NUX1RSQUNFX09CSkVDVChzcmMsICJkaWQgbm90IGdldCB0aGUgJXUgYmxvY2tzaXplIGJ5dGVz LCBsZXQncyBwdXNoIHRoZSAlIiBHX0dTSVpFX0ZPUk1BVCAiIGJ5dGVzIHdlIGdvdCIsIHNpemUs IGF2YWlsYWJsZSk7Ci0gICAgICAgICAgICAgICAgc2l6ZSA9IGF2YWlsYWJsZTsKLSAgICAgICAg ICAgIH0gZWxzZSBpZiAocmV0cmllcyA+IDMpCi0gICAgICAgICAgICAgICAgaXNBZGFwdGVyRHJh aW5lZCA9IHRydWU7CisgICAgICAgICAgICBxdWV1ZVNpemUgPSBnc3RfYWRhcHRlcl9hdmFpbGFi bGUocHJpdi0+YWRhcHRlci5nZXQoKSk7CisgICAgICAgICAgICBHU1RfVFJBQ0VfT0JKRUNUKHNy YywgImF2YWlsYWJsZSAlIiBHX0dTSVpFX0ZPUk1BVCwgcXVldWVTaXplKTsKKyAgICAgICAgICAg IGlmIChxdWV1ZVNpemUgfHwgcHJpdi0+aXNGbHVzaGluZykgeworICAgICAgICAgICAgICAgIC8v IFdlIGhhdmUgZGF0YSBvciB3ZSdyZSBmbHVzaGluZy4gV2UgY2FuIGJyZWFrIHRoZSBsb29wIGhl cmUuCisgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICB9CisKKyAgICAgICAgICAg IC8vIFdlIHNob3VsZCBrZWVwIHdhaXRpbmcgYnV0IHdlIGNvdWxkIGJlIGluIEVPUy4gTGV0J3Mg Y2hlY2sgdGhlIHR3byBwb3NzaWJpbGl0aWVzOgorICAgICAgICAgICAgLy8gMS4gV2UgYXJlIHRo ZSBlbmQgb2YgdGhlIGtub3duIHNpemUgb2YgdGhlIGZpbGUuCisgICAgICAgICAgICAvLyAyLiBE b3dubG9hZCBpcyBub3Qgc3VzcGVuZGVkIGFuZCBubyBtb3JlIGRhdGEgaXMgYXJyaXZpbmcuIFdl IGNhbm5vdCB3YWl0IGZvcmV2ZXIsIDEweDFzIHNlZW1zIHNhZmUgYW5kIHNlbnNpYmxlLgorICAg ICAgICAgICAgaWYgKHByaXYtPmhhdmVTaXplICYmIHByaXYtPnJlYWRQb3NpdGlvbiA+PSBwcml2 LT5zaXplKSB7CisgICAgICAgICAgICAgICAgR1NUX0RFQlVHX09CSkVDVChzcmMsICJXYWl0aW5n IGZvciBkYXRhIGJleW9uZCB0aGUgZW5kLCBzaWduYWxsaW5nIEVPUyIpOworICAgICAgICAgICAg ICAgIHJldHVybiBHU1RfRkxPV19FT1M7CisgICAgICAgICAgICB9CisgICAgICAgICAgICBHU1Rf VFJBQ0VfT0JKRUNUKHNyYywgImlzIGRvd25sb2FkIHN1c3BlbmRlZCAlcywgdHJpZWQgJXUiLCBi b29sRm9yUHJpbnRpbmcocHJpdi0+aXNEb3dubG9hZFN1c3BlbmRlZCksIHJldHJpZXMgKyAxKTsK KyAgICAgICAgICAgIGlmICghcHJpdi0+aXNEb3dubG9hZFN1c3BlbmRlZCAmJiArK3JldHJpZXMg Pj0gMTApIHsKKyAgICAgICAgICAgICAgICBHU1RfREVCVUdfT0JKRUNUKHNyYywgIkFkYXB0ZXIg c3RpbGwgZW1wdHkgYWZ0ZXIgMTBzIG9mIHdhaXRpbmcsIGFzc3VtaW5nIEVPUyIpOworICAgICAg ICAgICAgICAgIHJldHVybiBHU1RfRkxPV19FT1M7CisgICAgICAgICAgICB9CiAgICAgICAgIH0K ICAgICB9CiAKLSAgICBpZiAoaXNBZGFwdGVyRHJhaW5lZCkgewotICAgICAgICBHU1RfREVCVUdf T0JKRUNUKHNyYywgIkFkYXB0ZXIgc3RpbGwgZW1wdHkgYWZ0ZXIgNDAwIG1pbGxpLXNlY29uZHMg b2Ygd2FpdGluZywgYXNzdW1pbmcgRU9TIik7Ci0gICAgICAgIHJldHVybiBHU1RfRkxPV19FT1M7 CisgICAgaWYgKHByaXYtPmlzRmx1c2hpbmcpIHsKKyAgICAgICAgR1NUX0RFQlVHX09CSkVDVChz cmMsICJGbHVzaGluZyIpOworICAgICAgICByZXR1cm4gR1NUX0ZMT1dfRkxVU0hJTkc7CiAgICAg fQogCiAgICAgaWYgKHByaXYtPmhhdmVTaXplICYmICFwcml2LT5pc0R1cmF0aW9uU2V0KSB7CkBA IC00MjksMTQgKzUwOCwxNyBAQCBzdGF0aWMgR3N0Rmxvd1JldHVybiB3ZWJLaXRXZWJTcmNDcmVh dGUoR3N0UHVzaFNyYyogcHVzaFNyYywgR3N0QnVmZmVyKiogYnVmZmVyKQogICAgICAgICBnc3Rf cGFkX3B1c2hfZXZlbnQoR1NUX0JBU0VfU1JDX1BBRChiYXNlU3JjKSwgcHJpdi0+aHR0cEhlYWRl cnNFdmVudC5sZWFrUmVmKCkpOwogCiAgICAgewotICAgICAgICBHU1RfVFJBQ0VfT0JKRUNUKHNy YywgIlRha2luZyAldSBieXRlcyBmcm9tIGFkYXB0ZXIiLCBzaXplKTsKICAgICAgICAgTG9ja0hv bGRlciBhZGFwdGVyTG9ja2VyKHByaXYtPmFkYXB0ZXJMb2NrKTsKKyAgICAgICAgcXVldWVTaXpl ID0gZ3N0X2FkYXB0ZXJfYXZhaWxhYmxlKHByaXYtPmFkYXB0ZXIuZ2V0KCkpOworICAgICAgICBp ZiAocXVldWVTaXplIDwgc2l6ZSkgeworICAgICAgICAgICAgR1NUX1RSQUNFX09CSkVDVChzcmMs ICJEaWQgbm90IGdldCB0aGUgJXUgYmxvY2tzaXplIGJ5dGVzLCBsZXQncyBwdXNoIHRoZSAlIiBH X0dTSVpFX0ZPUk1BVCAiIGJ5dGVzIHdlIGdvdCIsIHNpemUsIHF1ZXVlU2l6ZSk7CisgICAgICAg ICAgICBzaXplID0gcXVldWVTaXplOworICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgIEdTVF9U UkFDRV9PQkpFQ1Qoc3JjLCAiVGFraW5nICV1IGJ5dGVzIGZyb20gYWRhcHRlciIsIHNpemUpOwog ICAgICAgICBpZiAoc2l6ZSkgewotICAgICAgICAgICAgKmJ1ZmZlciA9IGdzdF9hZGFwdGVyX3Rh a2VfYnVmZmVyX2Zhc3QocHJpdi0+YWRhcHRlci5nZXQoKSwgc2l6ZSk7CisgICAgICAgICAgICAq YnVmZmVyID0gZ3N0X2FkYXB0ZXJfdGFrZV9idWZmZXIocHJpdi0+YWRhcHRlci5nZXQoKSwgc2l6 ZSk7CiAgICAgICAgICAgICBSRUxFQVNFX0FTU0VSVCgqYnVmZmVyKTsKIAotICAgICAgICAgICAg cHJpdi0+cXVldWVTaXplIC09IHNpemU7Ci0KICAgICAgICAgICAgIEdTVF9CVUZGRVJfT0ZGU0VU KCpidWZmZXIpID0gYmFzZVNyYy0+c2VnbWVudC5wb3NpdGlvbjsKICAgICAgICAgICAgIEdTVF9C VUZGRVJfT0ZGU0VUX0VORCgqYnVmZmVyKSA9IEdTVF9CVUZGRVJfT0ZGU0VUKCpidWZmZXIpICsg c2l6ZTsKICAgICAgICAgICAgIEdTVF9UUkFDRV9PQkpFQ1Qoc3JjLCAiQnVmZmVyIGJvdW5kcyBz ZXQgdG8gJSIgR19HVUlOVDY0X0ZPUk1BVCAiLSUiIEdfR1VJTlQ2NF9GT1JNQVQsIEdTVF9CVUZG RVJfT0ZGU0VUKCpidWZmZXIpLCBHU1RfQlVGRkVSX09GRlNFVF9FTkQoKmJ1ZmZlcikpOwpAQCAt NDQ5LDE4ICs1MzEsMTEgQEAgc3RhdGljIEdzdEZsb3dSZXR1cm4gd2ViS2l0V2ViU3JjQ3JlYXRl KEdzdFB1c2hTcmMqIHB1c2hTcmMsIEdzdEJ1ZmZlcioqIGJ1ZmZlcikKICAgICAgICAgICAgIH0g ZWxzZSBpZiAocHJpdi0+d2FzU2Vla2luZykKICAgICAgICAgICAgICAgICBwcml2LT53YXNTZWVr aW5nID0gZmFsc2U7CiAKLSAgICAgICAgICAgIGlmICghcHJpdi0+ZG9lc0hhdmVFT1MgJiYgcHJp di0+aGF2ZVNpemUgJiYgcHJpdi0+aXNTZWVrYWJsZQotICAgICAgICAgICAgICAgICYmIChwcml2 LT5zaXplID4gU01BTExfTUVESUFfUkVTT1VSQ0VfTUFYX1NJWkUpICYmIHByaXYtPnJlYWRQb3Np dGlvbgotICAgICAgICAgICAgICAgICYmIChwcml2LT5yZWFkUG9zaXRpb24gIT0gcHJpdi0+c2l6 ZSkKLSAgICAgICAgICAgICAgICAmJiAocHJpdi0+cXVldWVTaXplIDwgKHByaXYtPnNpemUgKiBI SUdIX1FVRVVFX0ZBQ1RPUl9USFJFU0hPTEQgKiBMT1dfUVVFVUVfRkFDVE9SX1RIUkVTSE9MRCkp Ci0gICAgICAgICAgICAgICAgJiYgR1NUX1NUQVRFKHNyYykgPj0gR1NUX1NUQVRFX1BBVVNFRCAm JiBwcml2LT5pc0Rvd25sb2FkU3VzcGVuZGVkKSB7Ci0gICAgICAgICAgICAgICAgR1NUX0RFQlVH X09CSkVDVChzcmMsICJbQnVmZmVyaW5nXSBBZGFwdGVyIHJ1bm5pbmcgb3V0IG9mIGRhdGEsIHJl c3RhcnRpbmcgZG93bmxvYWQiKTsKLSAgICAgICAgICAgICAgICBwcml2LT5pc0Rvd25sb2FkU3Vz cGVuZGVkID0gZmFsc2U7Ci0gICAgICAgICAgICAgICAgd2ViS2l0V2ViU3JjTWFrZVJlcXVlc3Qo YmFzZVNyYywgZmFsc2UpOwotICAgICAgICAgICAgfQotCi0gICAgICAgIH0gZWxzZQotICAgICAg ICAgICAgR1NUX0VSUk9SX09CSkVDVChzcmMsICJFbXB0eSBhZGFwdGVyPyIpOworICAgICAgICAg ICAgcmVzdGFydExvYWRlcklmTmVlZGVkKHNyYyk7CisgICAgICAgIH0gZWxzZSB7CisgICAgICAg ICAgICBHU1RfRVJST1JfT0JKRUNUKHNyYywgIkVtcHR5IGFkYXB0ZXIhIik7CisgICAgICAgICAg ICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICAgICAgfQogICAgIH0KIAogICAgIHJldHVybiBH U1RfRkxPV19PSzsKQEAgLTY3MSw3ICs3NDYsNiBAQCBzdGF0aWMgZ2Jvb2xlYW4gd2ViS2l0V2Vi U3JjU3RvcChHc3RCYXNlU3JjKiBiYXNlU3JjKQogICAgIHsKICAgICAgICAgTG9ja0hvbGRlciBh ZGFwdGVyTG9ja2VyKHByaXYtPmFkYXB0ZXJMb2NrKTsKICAgICAgICAgZ3N0X2FkYXB0ZXJfY2xl YXIocHJpdi0+YWRhcHRlci5nZXQoKSk7Ci0gICAgICAgIHByaXYtPnF1ZXVlU2l6ZSA9IDA7CiAg ICAgfQogCiAgICAgd2Via2l0V2ViU3JjUmVzZXQoc3JjKTsKQEAgLTcyOSw2ICs4MDMsNyBAQCBz dGF0aWMgZ2Jvb2xlYW4gd2ViS2l0V2ViU3JjRG9TZWVrKEdzdEJhc2VTcmMqIGJhc2VTcmMsIEdz dFNlZ21lbnQqIHNlZ21lbnQpCiAgICAgcHJpdi0+aXNTZWVraW5nID0gdHJ1ZTsKICAgICBwcml2 LT5yZXF1ZXN0ZWRQb3NpdGlvbiA9IHNlZ21lbnQtPnN0YXJ0OwogICAgIHByaXYtPnN0b3BQb3Np dGlvbiA9IHNlZ21lbnQtPnN0b3A7CisgICAgcHJpdi0+YWRhcHRlckNvbmRpdGlvbi5ub3RpZnlP bmUoKTsKICAgICByZXR1cm4gVFJVRTsKIH0KIApAQCAtNzY3LDYgKzg0Miw3IEBAIHN0YXRpYyBn Ym9vbGVhbiB3ZWJLaXRXZWJTcmNVbkxvY2soR3N0QmFzZVNyYyogYmFzZVNyYykKICAgICBHU1Rf REVCVUdfT0JKRUNUKHNyYywgIlVubG9jayIpOwogICAgIHNyYy0+cHJpdi0+aXNGbHVzaGluZyA9 IHRydWU7CiAgICAgc3JjLT5wcml2LT5yZXNwb25zZUNvbmRpdGlvbi5ub3RpZnlPbmUoKTsKKyAg ICBzcmMtPnByaXYtPmFkYXB0ZXJDb25kaXRpb24ubm90aWZ5T25lKCk7CiAgICAgcmV0dXJuIFRS VUU7CiB9CiAKQEAgLTc5Niw4ICs4NzIsMTAgQEAgc3RhdGljIEdzdFN0YXRlQ2hhbmdlUmV0dXJu IHdlYktpdFdlYlNyY0NoYW5nZVN0YXRlKEdzdEVsZW1lbnQqIGVsZW1lbnQsIEdzdFN0YXQKICAg ICAgICAgR1NUX0RFQlVHX09CSkVDVChzcmMsICJQQVVTRUQtPlJFQURZIGNhbmNlbGxpbmcgbmV0 d29yayByZXF1ZXN0cyIpOwogICAgICAgICBzcmMtPnByaXYtPmlzRmx1c2hpbmcgPSB0cnVlOwog ICAgICAgICBzcmMtPnByaXYtPnJlc3BvbnNlQ29uZGl0aW9uLm5vdGlmeU9uZSgpOworICAgICAg ICBzcmMtPnByaXYtPmFkYXB0ZXJDb25kaXRpb24ubm90aWZ5T25lKCk7CiAgICAgICAgIGJyZWFr OwotICAgIH0gZGVmYXVsdDoKKyAgICB9CisgICAgZGVmYXVsdDoKICAgICAgICAgYnJlYWs7CiAg ICAgfQogCkBAIC05MTgsNyArOTk2LDcgQEAgdm9pZCBDYWNoZWRSZXNvdXJjZVN0cmVhbWluZ0Ns aWVudDo6Y2hlY2tVcGRhdGVCbG9ja3NpemUodW5zaWduZWQgYnl0ZXNSZWFkKQogICAgIHVuc2ln bmVkIGJsb2Nrc2l6ZSA9IGdzdF9iYXNlX3NyY19nZXRfYmxvY2tzaXplKGJhc2VTcmMpOwogICAg IEdTVF9MT0dfT0JKRUNUKHNyYywgIkNoZWNraW5nIHRvIHVwZGF0ZSBibG9ja3NpemUuIFJlYWQ6 ICV1LCBjdXJyZW50IGJsb2Nrc2l6ZTogJXUiLCBieXRlc1JlYWQsIGJsb2Nrc2l6ZSk7CiAKLSAg ICBpZiAoYnl0ZXNSZWFkID49IGJsb2Nrc2l6ZSAqIHNfZ3Jvd0Jsb2Nrc2l6ZUxpbWl0KSB7Cisg ICAgaWYgKGJ5dGVzUmVhZCA+IGJsb2Nrc2l6ZSAqIHNfZ3Jvd0Jsb2Nrc2l6ZUxpbWl0KSB7CiAg ICAgICAgIG1fcmVkdWNlQmxvY2tzaXplQ291bnQgPSAwOwogICAgICAgICBtX2luY3JlYXNlQmxv Y2tzaXplQ291bnQrKzsKIApAQCAtMTA3MCw2ICsxMTQ4LDE3IEBAIHZvaWQgQ2FjaGVkUmVzb3Vy Y2VTdHJlYW1pbmdDbGllbnQ6OmRhdGFSZWNlaXZlZChQbGF0Zm9ybU1lZGlhUmVzb3VyY2UmLCBj b25zdCBjCiAKICAgICBHU1RfTE9HX09CSkVDVChzcmMsICJIYXZlICVkIGJ5dGVzIG9mIGRhdGEi LCBsZW5ndGgpOwogICAgIExvY2tIb2xkZXIgbG9ja2VyKHByaXYtPnJlc3BvbnNlTG9jayk7Cisg ICAgLy8gUm91Z2ggYmFuZHdpZHRoIGNhbGN1bGF0aW9uLiBXZSBpZ25vcmUgaGVyZSB0aGUgZmly c3QgZGF0YSBwYWNrYWdlIGJlY2F1c2Ugd2Ugd291bGQgaGF2ZSB0byByZXNldCB0aGUgY291bnRl cnMgd2hlbiB3ZSBpc3N1ZSB0aGUgcmVxdWVzdCBhbmQKKyAgICAvLyB0aGF0IGZpcnN0IHBhY2th Z2UgZGVsaXZlcnkgd291bGQgaW5jbHVkZSB0aGUgdGltZSBvZiBzZW5kaW5nIG91dCB0aGUgcmVx dWVzdCBhbmQgZ2V0dGluZyB0aGUgZGF0YSBiYWNrLiBTaW5jZSB3ZSBjYW4ndCBkaXN0aW5nw7xp c2ggdGhlCisgICAgLy8gc2VuZGluZyB0aW1lIGZyb20gdGhlIHJlY2VpdmluZyB0aW1lLCBpdCBp cyBiZXR0ZXIgdG8gaWdub3JlIGl0LgorICAgIGlmIChwcml2LT5kb3dubG9hZFN0YXJ0VGltZSkg eworICAgICAgICBwcml2LT50b3RhbERvd25sb2FkZWRCeXRlcyArPSBsZW5ndGg7CisgICAgICAg IGRvdWJsZSB0aW1lU2luY2VTdGFydCA9IChXYWxsVGltZTo6bm93KCkgLSBwcml2LT5kb3dubG9h ZFN0YXJ0VGltZSkuc2Vjb25kcygpOworICAgICAgICBHU1RfVFJBQ0VfT0JKRUNUKHNyYywgImRv d25sb2FkZWQgJXUgYnl0ZXMgaW4gJWxmIHNlY29uZHMgPX4gJTEuMGxmIGJ5dGVzL3NlY29uZCIs IHByaXYtPnRvdGFsRG93bmxvYWRlZEJ5dGVzLCB0aW1lU2luY2VTdGFydCwgcHJpdi0+dG90YWxE b3dubG9hZGVkQnl0ZXMgLyB0aW1lU2luY2VTdGFydCk7CisgICAgfSBlbHNlIHsKKyAgICAgICAg cHJpdi0+ZG93bmxvYWRTdGFydFRpbWUgPSBXYWxsVGltZTo6bm93KCk7CisgICAgICAgIHByaXYt PnRvdGFsRG93bmxvYWRlZEJ5dGVzID0gMDsKKyAgICB9CiAKICAgICB1aW50NjRfdCBuZXdQb3Np dGlvbiA9IHByaXYtPnJlYWRQb3NpdGlvbiArIGxlbmd0aDsKICAgICBpZiAoTElLRUxZIChwcml2 LT5yZXF1ZXN0ZWRQb3NpdGlvbiA9PSBwcml2LT5yZWFkUG9zaXRpb24pKQpAQCAtMTEwNCwxOCAr MTE5Myw4IEBAIHZvaWQgQ2FjaGVkUmVzb3VyY2VTdHJlYW1pbmdDbGllbnQ6OmRhdGFSZWNlaXZl ZChQbGF0Zm9ybU1lZGlhUmVzb3VyY2UmLCBjb25zdCBjCiAgICAgewogICAgICAgICBMb2NrSG9s ZGVyIGFkYXB0ZXJMb2NrZXIocHJpdi0+YWRhcHRlckxvY2spOwogICAgICAgICBHc3RCdWZmZXIq IGJ1ZmZlciA9IGdzdF9idWZmZXJfbmV3X3dyYXBwZWQoZ19tZW1kdXAoZGF0YSwgbGVuZ3RoKSwg bGVuZ3RoKTsKLSAgICAgICAgcHJpdi0+cXVldWVTaXplICs9IGxlbmd0aDsKICAgICAgICAgZ3N0 X2FkYXB0ZXJfcHVzaChwcml2LT5hZGFwdGVyLmdldCgpLCBidWZmZXIpOwotICAgICAgICBHU1Rf VFJBQ0VfT0JKRUNUKHNyYywgIltCdWZmZXJpbmddIGlzRG93bmxvYWRTdXNwZW5kZWQ6ICVzIiwg Ym9vbEZvclByaW50aW5nKHByaXYtPmlzRG93bmxvYWRTdXNwZW5kZWQpKTsKLSAgICAgICAgaWYg KHByaXYtPmhhdmVTaXplICYmIChwcml2LT5zaXplID4gU01BTExfTUVESUFfUkVTT1VSQ0VfTUFY X1NJWkUpICYmIChwcml2LT5xdWV1ZVNpemUgPiAocHJpdi0+c2l6ZSAqIEhJR0hfUVVFVUVfRkFD VE9SX1RIUkVTSE9MRCkpCi0gICAgICAgICAgICAmJiAhcHJpdi0+aXNEb3dubG9hZFN1c3BlbmRl ZCAmJiBwcml2LT5pc1NlZWthYmxlKSB7Ci0gICAgICAgICAgICBHU1RfVFJBQ0VfT0JKRUNUKHNy YywgIltCdWZmZXJpbmddIHF1ZXVlU2l6ZTogJSIgR19HVUlOVDY0X0ZPUk1BVCAiLCB0aHJlc2hv bGQ6ICVmIiwgcHJpdi0+cXVldWVTaXplLAotICAgICAgICAgICAgICAgIHByaXYtPnNpemUgKiBI SUdIX1FVRVVFX0ZBQ1RPUl9USFJFU0hPTEQpOwotICAgICAgICAgICAgR1NUX0RFQlVHX09CSkVD VChzcmMsICJbQnVmZmVyaW5nXSBTdG9wcGluZyByZXNvdXJjZSBsb2FkZXIiKTsKLSAgICAgICAg ICAgIHByaXYtPmlzRG93bmxvYWRTdXNwZW5kZWQgPSB0cnVlOwotICAgICAgICAgICAgcHJpdi0+ cmVzb3VyY2UtPnN0b3AoKTsKLSAgICAgICAgICAgIHJldHVybjsKLSAgICAgICAgfQorICAgICAg ICBzdG9wTG9hZGVySWZOZWVkZWQoc3JjKTsKICAgICAgICAgcHJpdi0+YWRhcHRlckNvbmRpdGlv bi5ub3RpZnlPbmUoKTsKICAgICB9CiB9Cg==