118445 2013-07-06 12:14:34 -0700 [Qt] QtWebKit should allow sending domain specific keycode to HTML applications 2013-08-09 05:10:13 -0700 1 1 1 Unclassified WebKit WebKit Qt 528+ (Nightly build) All All RESOLVED FIXED P2 Major --- 118566 0 arurajku webkit-unassigned allan.jensen ararunprasad commit-queue hausmann jturcotte noam vivekg oldest_to_newest 906585 0 arurajku 2013-07-06 12:14:34 -0700 Currently QtWebKit allows sending only key values present in(WindowsKeyBoardCodes.h), mostly Keyboard keys. But QtWebKit's usage is beyond the PC world & used in may areas like TV/STB/..etc. So it should allow sending domain specific keyvalues like(Color Keys[Red, Green, Yellow, Blue], Subtitle, Program Guide,..) to HTML application. Soon I will post a patch for this bug. 906587 1 206194 arurajku 2013-07-06 12:43:36 -0700 Created attachment 206194 Patch 906590 2 allan.jensen 2013-07-06 13:36:55 -0700 What is the use-case here? Since this is the historic windows keycode value set here, it must be mapped to correct values, just parsing through Qt keycodes is kind of random and unlikely to be useful unless you control the website on the other end. If you have control over the website why not change the website to use the other properties provided by the DOM key events instead of the windows keycode value? 906610 3 arurajku 2013-07-06 23:03:02 -0700 (In reply to comment #2) > What is the use-case here? To send domain specific key values like(ex, TV Remote Keys like Color Keys[Red, Green, Yellow, Blue], Subtitle, Program Guide,..) to HTML application. > > Since this is the historic windows keycode value set here, it must be mapped to correct values, just parsing through Qt keycodes is kind of random and unlikely to be useful unless you control the website on the other end. Yes, it is all controlled Web Applications. > > If you have control over the website why not change the website to use the other properties provided by the DOM key events instead of the windows keycode value? What other properties in DOM key event? How to dispatch those keys from native to Web App? using script injection? According to this patch, sender(native world) & receiver(HTML Web App) knows the key, but WebKit doesn't aware of this and just passes the given value to Web App. 907635 4 allan.jensen 2013-07-11 06:53:07 -0700 (In reply to comment #3) > (In reply to comment #2) > > What is the use-case here? > To send domain specific key values like(ex, TV Remote Keys like Color Keys[Red, Green, Yellow, Blue], Subtitle, Program Guide,..) to HTML application. > > > > > Since this is the historic windows keycode value set here, it must be mapped to correct values, just parsing through Qt keycodes is kind of random and unlikely to be useful unless you control the website on the other end. > > Yes, it is all controlled Web Applications. > > > > If you have control over the website why not change the website to use the other properties provided by the DOM key events instead of the windows keycode value? > > What other properties in DOM key event? How to dispatch those keys from native to Web App? using script injection? > > According to this patch, sender(native world) & receiver(HTML Web App) knows the key, but WebKit doesn't aware of this and just passes the given value to Web App. I was thinking of the key value, see http://www.w3.org/TR/DOM-Level-3-Events/#key-values-list Though I wonder if we support it fully, but I would prefer to add support for that, than a Qt specific passthrough. 907638 5 arurajku 2013-07-11 07:07:15 -0700 (In reply to comment #4) > I was thinking of the key value, see http://www.w3.org/TR/DOM-Level-3-Events/#key-values-list So you mean application should rely on the "key" attribute(which is a string representation of a key) of KeyBoardEvent object ? > > Though I wonder if we support it fully, but I would prefer to add support for that, than a Qt specific passthrough. But how to transfer the string value from Qt to WebKit? By adding new property to QKeyEvent? For private applications we could do change it to use "key" attribute rather than "keyCode", but some interactive tv apps(HbbTV/CEHTML apps) refers "keyCode" property to handle the event. I don't think it is possible to change the HbbTV/CEHTML spec to use "key" :( Sorry incase I misinterpreted your comments. 907664 6 allan.jensen 2013-07-11 08:19:37 -0700 (In reply to comment #5) > (In reply to comment #4) > > I was thinking of the key value, see http://www.w3.org/TR/DOM-Level-3-Events/#key-values-list > > So you mean application should rely on the "key" attribute(which is a string representation of a key) of KeyBoardEvent object ? > Yes. It currently also falls back to encoding the Qt keycode as U+<keycode>. > > But how to transfer the string value from Qt to WebKit? By adding new property to QKeyEvent? > Well, we almost already have that in the key property. > For private applications we could do change it to use "key" attribute rather than "keyCode", but some interactive tv apps(HbbTV/CEHTML apps) refers "keyCode" property to handle the event. I don't think it is possible to change the HbbTV/CEHTML spec to use "key" :( Sorry incase I misinterpreted your comments. Right, but in those cases we should expand our translation table of keycodes so it matches what those applications expect. 907675 7 arurajku 2013-07-11 09:03:13 -0700 (In reply to comment #6) > > But how to transfer the string value from Qt to WebKit? By adding new property to QKeyEvent? > > > Well, we almost already have that in the key property. > > > For private applications we could do change it to use "key" attribute rather than "keyCode", but some interactive tv apps(HbbTV/CEHTML apps) refers "keyCode" property to handle the event. I don't think it is possible to change the HbbTV/CEHTML spec to use "key" :( Sorry incase I misinterpreted your comments. > > Right, but in those cases we should expand our translation table of keycodes so it matches what those applications expect. By adding new keys to Qt::Key enum? So it needs change in Qt right? 907696 8 allan.jensen 2013-07-11 10:02:04 -0700 (In reply to comment #7) > (In reply to comment #6) > > > But how to transfer the string value from Qt to WebKit? By adding new property to QKeyEvent? > > > > > Well, we almost already have that in the key property. > > > > > For private applications we could do change it to use "key" attribute rather than "keyCode", but some interactive tv apps(HbbTV/CEHTML apps) refers "keyCode" property to handle the event. I don't think it is possible to change the HbbTV/CEHTML spec to use "key" :( Sorry incase I misinterpreted your comments. > > > > Right, but in those cases we should expand our translation table of keycodes so it matches what those applications expect. > > By adding new keys to Qt::Key enum? So it needs change in Qt right? The color codes and channel-up/down are already added to Qt 5.2 dev branch, but we would need to add them anyway to get keycodes through. 907704 9 arurajku 2013-07-11 10:32:43 -0700 (In reply to comment #8) > The color codes and channel-up/down are already added to Qt 5.2 dev branch, but we would need to add them anyway to get keycodes through. Good news :) but lot of other keys there which are specific to TV/STB.(like subtitle,Guide,Teletext,Info,Back,Input Source Selection, & lot). I agree that it would satisfy a bit. But what would be its key value? Based on which standard ?(There are lot of standard are there like CEHTML/Open IPTV,HbbTV,Connected TV,..). Anyhow the one who uses QtWebKit for those domain should touch the inner side of WebCore to assign their domain specific key value. 907728 10 allan.jensen 2013-07-11 11:40:59 -0700 (In reply to comment #9) > (In reply to comment #8) > > The color codes and channel-up/down are already added to Qt 5.2 dev branch, but we would need to add them anyway to get keycodes through. > > Good news :) but lot of other keys there which are specific to TV/STB.(like subtitle,Guide,Teletext,Info,Back,Input Source Selection, & lot). I agree that it would satisfy a bit. But what would be its key value? Based on which standard ?(There are lot of standard are there like CEHTML/Open IPTV,HbbTV,Connected TV,..). > Anyhow the one who uses QtWebKit for those domain should touch the inner side of WebCore to assign their domain specific key value. It will use Qt defined keycode values. Once a key event has been created by Qt the original values are no longer used. This is also why we need the values defined in Qt in the first place, otherwise there is no keycode value for WebKit either. Qt do have most of the keys. I am looking into getting Guide, Info and Exit added as well. 907836 11 arurajku 2013-07-12 00:15:42 -0700 (In reply to comment #10) > > Anyhow the one who uses QtWebKit for those domain should touch the inner side of WebCore to assign their domain specific key value. > > It will use Qt defined keycode values. Once a key event has been created by Qt the original values are no longer used. This is also why we need the values defined in Qt in the first place, otherwise there is no keycode value for WebKit either. > > Qt do have most of the keys. I am looking into getting Guide, Info and Exit added as well. I understood that Qt::Key enum is going to have more STB/TV specific keys, but what is the DOM keyCode value for those keys? Is it based on CE-HTML(CEA 2014) or any other standard? 907849 12 allan.jensen 2013-07-12 01:00:03 -0700 (In reply to comment #11) > (In reply to comment #10) > > > Anyhow the one who uses QtWebKit for those domain should touch the inner side of WebCore to assign their domain specific key value. > > > > It will use Qt defined keycode values. Once a key event has been created by Qt the original values are no longer used. This is also why we need the values defined in Qt in the first place, otherwise there is no keycode value for WebKit either. > > > > > Qt do have most of the keys. I am looking into getting Guide, Info and Exit added as well. > > I understood that Qt::Key enum is going to have more STB/TV specific keys, but what is the DOM keyCode value for those keys? Is it based on CE-HTML(CEA 2014) or any other standard? The keycode values in the DOM are the windows keycodes, if there is no mapping in windows there is no keycode for that key. This is why you should use the DOM standard 'key' property. 907861 13 arurajku 2013-07-12 01:35:32 -0700 (In reply to comment #12) > The keycode values in the DOM are the windows keycodes, if there is no mapping in windows there is no keycode for that key. This is why you should use the DOM standard 'key' property. It is clear now. But still I'm worrying about Interactive TV specs(HbbTV, CEHTML). They suggest to use "keyCode" & "charCode" properties of KeyboardEvent, so some change inside WebCore is needed to support it for those specifications. But I still feel passing the keycode directly(the main of the attached patch) is a good option, so the one who uses QtWebKit no need to touch source of WebKit to achieve their intention. 909700 14 allan.jensen 2013-07-18 04:14:27 -0700 (In reply to comment #13) > (In reply to comment #12) > > The keycode values in the DOM are the windows keycodes, if there is no mapping in windows there is no keycode for that key. This is why you should use the DOM standard 'key' property. > > It is clear now. But still I'm worrying about Interactive TV specs(HbbTV, CEHTML). They suggest to use "keyCode" & "charCode" properties of KeyboardEvent, so some change inside WebCore is needed to support it for those specifications. > > But I still feel passing the keycode directly(the main of the attached patch) is a good option, so the one who uses QtWebKit no need to touch source of WebKit to achieve their intention. I can see what you are trying to do, but the patch depends on a non-Qt value being stored in a QKeyEvent. There are many ways this could go wrong. 910008 15 arurajku 2013-07-18 22:19:16 -0700 (In reply to comment #14) > I can see what you are trying to do, but the patch depends on a non-Qt value being stored in a QKeyEvent. There are many ways this could go wrong. QKeyEvent takes keycode value as "int", not Qt::Key. Hope user will not be confused if we pass no Qt::Key values. So the advanced user could use this way of sending keycodes to Web Apps without hacking more inside WebCore, what do you thing? 910009 16 arurajku 2013-07-18 22:19:47 -0700 (Sorry for the typo) (In reply to comment #15) > (In reply to comment #14) > > I can see what you are trying to do, but the patch depends on a non-Qt value being stored in a QKeyEvent. There are many ways this could go wrong. > > QKeyEvent takes keycode value as "int", not Qt::Key. Hope user will not be confused if we pass no Qt::Key values. > > So the advanced user could use this way of sending keycodes to Web Apps without hacking more inside WebCore, what do you think? 910619 17 allan.jensen 2013-07-22 03:02:20 -0700 The problem with using other values in QKeyEvent is that if they happen to match something already recognized the key will trigger the wrong actions. I took a look at the HbbTv codes, and there is a big problem here. While many of the new keys use values larger than 255 and therefore do not conflict with traditional keycodes, there are several that does. For instance fast-forward and rewind are mapped differently than on GoogleTV. This means you can either have the browser working with hbbtv sites or have it working with GoogleTV sites, but not both. If you really need this, I would suggest adding another property to QtKeyEvent and pass your domain specific keycodes in that, and if present use that in the PlatformKeyEventQt to set the keycode, but we can not support a poorly thought through standard in trunk that conflicts with existing websites. 910627 18 arurajku 2013-07-22 04:11:40 -0700 (In reply to comment #17) > The problem with using other values in QKeyEvent is that if they happen to match something already recognized the key will trigger the wrong actions. > > I took a look at the HbbTv codes, and there is a big problem here. While many of the new keys use values larger than 255 and therefore do not conflict with traditional keycodes, there are several that does. Thanks for looking HbbTV specific keys :) > > For instance fast-forward and rewind are mapped differently than on GoogleTV. This means you can either have the browser working with hbbtv sites or have it working with GoogleTV sites, but not both. By default existing behaviour is not changed at all. It is upto the QtWebKit library user to decide whether to support GoogleTV/HbbTV. If the library user wants both then they can detect the application type using <meta> tags or mime types(HbbTV apps has application/ce-html or application/x-ce-html or application/vnd.hbbtv.xhtml+xml,..). > > If you really need this, I would suggest adding another property to QtKeyEvent and pass your domain specific keycodes in that, and if present use that in the PlatformKeyEventQt to set the keycode, but we can not support a poorly thought through standard in trunk that conflicts with existing websites. Hope it won't conflict, because it is decided by QtWebKit library user. 910939 19 allan.jensen 2013-07-23 02:03:15 -0700 If you can make due with the keycodes outside of what Qt uses >255 <0x01000000. We could pass them through as there is no overlap. Though I think the best solution would be a setting to let us know were are in CE mode. 910991 20 arurajku 2013-07-23 04:51:31 -0700 (In reply to comment #19) > If you can make due with the keycodes outside of what Qt uses >255 <0x01000000. We could pass them through as there is no overlap. Though I think the best solution would be a setting to let us know were are in CE mode. I'm getting your point :) But I'm sure adding a new property to a Qt's QKeyEvent is a painful job, because WebKit has to wait until the stable Qt release(with the change). What about adding a global settings(via QWebSettings)? like adding new value to QWebSettings::WebAttribute..? eg) QWebSettings::setAttribute(QWebSettings::WebAttribute::TVEnabled, true); If above attribute is set, then from PlatformKeyboardEventQt.cpp given keycode will be just passed to WebCore. What do you think? 910993 21 allan.jensen 2013-07-23 05:17:47 -0700 (In reply to comment #20) > (In reply to comment #19) > > If you can make due with the keycodes outside of what Qt uses >255 <0x01000000. We could pass them through as there is no overlap. Though I think the best solution would be a setting to let us know were are in CE mode. > > I'm getting your point :) But I'm sure adding a new property to a Qt's QKeyEvent is a painful job, because WebKit has to wait until the stable Qt release(with the change). > > What about adding a global settings(via QWebSettings)? like adding new value to QWebSettings::WebAttribute..? > > eg) > QWebSettings::setAttribute(QWebSettings::WebAttribute::TVEnabled, true); > > If above attribute is set, then from PlatformKeyboardEventQt.cpp given keycode will be just passed to WebCore. > > What do you think? I was considering that, but I still don't like the passthrough of values that could be misinterpreted. We could implement the correct conversion from Qt keycodes to CE keycodes, but it turns out it is not entirely consistant between the standards. VK_MENU and VK_BACK are mappped differently on CE-HTML than on EBIF and OCAP. 910994 22 allan.jensen 2013-07-23 05:18:43 -0700 (In reply to comment #20) > (In reply to comment #19) > > If you can make due with the keycodes outside of what Qt uses >255 <0x01000000. We could pass them through as there is no overlap. Though I think the best solution would be a setting to let us know were are in CE mode. > > I'm getting your point :) But I'm sure adding a new property to a Qt's QKeyEvent is a painful job, because WebKit has to wait until the stable Qt release(with the change). > Right, but perhaps you could use the existing nativeVirtualKeyCode field then. 911003 23 arurajku 2013-07-23 05:36:10 -0700 (In reply to comment #22) > (In reply to comment #20) > > (In reply to comment #19) > > > If you can make due with the keycodes outside of what Qt uses >255 <0x01000000. We could pass them through as there is no overlap. Though I think the best solution would be a setting to let us know were are in CE mode. > > > > I'm getting your point :) But I'm sure adding a new property to a Qt's QKeyEvent is a painful job, because WebKit has to wait until the stable Qt release(with the change). > > > Right, but perhaps you could use the existing nativeVirtualKeyCode field then. Yeah, I too thought the same, but will it cause any confusion to the one who is seeing the code? I know that 2 properties like nativeVirtualKeyCode, nativeScanCode are there. But what value it holds in X11/Windows ..? I'm thinking like incase of Windows for left arrow key, nativeVirtualKeyCode = VK_LEFT keycode = Qt::Key_Left nativeScanCode = <some keyboard driver scan code> Isn't it? 911005 24 allan.jensen 2013-07-23 05:51:10 -0700 (In reply to comment #23) > (In reply to comment #22) > > (In reply to comment #20) > > > (In reply to comment #19) > > > > If you can make due with the keycodes outside of what Qt uses >255 <0x01000000. We could pass them through as there is no overlap. Though I think the best solution would be a setting to let us know were are in CE mode. > > > > > > I'm getting your point :) But I'm sure adding a new property to a Qt's QKeyEvent is a painful job, because WebKit has to wait until the stable Qt release(with the change). > > > > > Right, but perhaps you could use the existing nativeVirtualKeyCode field then. > > Yeah, I too thought the same, but will it cause any confusion to the one who is seeing the code? > > I know that 2 properties like nativeVirtualKeyCode, nativeScanCode are there. But what value it holds in X11/Windows ..? > > I'm thinking like incase of Windows for left arrow key, > nativeVirtualKeyCode = VK_LEFT > keycode = Qt::Key_Left > nativeScanCode = <some keyboard driver scan code> > > Isn't it? True, but since you are generating your own QKeyEvents you are essentially a new "native" source of key-events. These values are usually only there for applications that need to detect keys not fully supported or detected by Qt, similar to your case. 911008 25 arurajku 2013-07-23 06:10:06 -0700 (In reply to comment #24) > (In reply to comment #23) > > (In reply to comment #22) > > > (In reply to comment #20) > > > > (In reply to comment #19) > > > > > If you can make due with the keycodes outside of what Qt uses >255 <0x01000000. We could pass them through as there is no overlap. Though I think the best solution would be a setting to let us know were are in CE mode. > > > > > > > > I'm getting your point :) But I'm sure adding a new property to a Qt's QKeyEvent is a painful job, because WebKit has to wait until the stable Qt release(with the change). > > > > > > > Right, but perhaps you could use the existing nativeVirtualKeyCode field then. > > > > Yeah, I too thought the same, but will it cause any confusion to the one who is seeing the code? > > > > I know that 2 properties like nativeVirtualKeyCode, nativeScanCode are there. But what value it holds in X11/Windows ..? > > > > I'm thinking like incase of Windows for left arrow key, > > nativeVirtualKeyCode = VK_LEFT > > keycode = Qt::Key_Left > > nativeScanCode = <some keyboard driver scan code> > > > > Isn't it? > > True, but since you are generating your own QKeyEvents you are essentially a new "native" source of key-events. OK. Understood :) >These values are usually only there for applications that need to detect keys not fully supported or detected by Qt, similar to your case. So it the platformkeyboadreventqt.cpp, instead of returning keycode directly nativeVirtualKeyCode should be passed from default: case? -default: - return keycode; +default: + return event->nativeVirtualKey(); Am I correct? 911016 26 allan.jensen 2013-07-23 06:28:07 -0700 (In reply to comment #25) > > True, but since you are generating your own QKeyEvents you are essentially a new "native" source of key-events. > > OK. Understood :) > > >These values are usually only there for applications that need to detect keys not fully supported or detected by Qt, similar to your case. > > So it the platformkeyboadreventqt.cpp, instead of returning keycode directly nativeVirtualKeyCode should be passed from default: case? > > -default: > - return keycode; > > +default: > + return event->nativeVirtualKey(); > > Am I correct? Exactly, but you will then need a setting like passThroughŃativeVirtualKeys, or something similar. We don't want the normally (except on Windows where it would be okay) 911025 27 arurajku 2013-07-23 07:04:11 -0700 (In reply to comment #26) > (In reply to comment #25) > > > True, but since you are generating your own QKeyEvents you are essentially a new "native" source of key-events. > > > > OK. Understood :) > > > > >These values are usually only there for applications that need to detect keys not fully supported or detected by Qt, similar to your case. > > > > So it the platformkeyboadreventqt.cpp, instead of returning keycode directly nativeVirtualKeyCode should be passed from default: case? > > > > -default: > > - return keycode; > > > > +default: > > + return event->nativeVirtualKey(); > > > > Am I correct? > > Exactly, but you will then need a setting like passThroughŃativeVirtualKeys, or something similar. We don't want the normally (except on Windows where it would be okay) Thanks for your suggestion. That looks good for me. Will update the patch as per your suggestion. Is it good to call QWebSettings from platformkeyboardeventqt.cpp? 912020 28 207542 arurajku 2013-07-26 11:20:33 -0700 Created attachment 207542 Patch 912475 29 207542 allan.jensen 2013-07-29 07:01:38 -0700 Comment on attachment 207542 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=207542&action=review Looks good but the keyIdentifiers will be wrong. > Source/WebCore/platform/qt/PlatformKeyboardEventQt.cpp:640 > + m_keyIdentifier = keyIdentifierForQtKeyCode(m_windowsVirtualKeyCode); This is wrong. The translation in keyIdentifierForQtKeyCode depends on the Qt keys being set correctly. 912526 30 207542 jturcotte 2013-07-29 09:51:55 -0700 Comment on attachment 207542 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=207542&action=review > Source/WebKit/qt/Api/qwebsettings.cpp:515 > + when Qt::Key to DOM key converstion fails. It might be useful for sending domain specific key values "when Qt::Key to DOM key converstion fails" is false isn't it? It seems like this will be triggered only if the key is 0. > Source/WebKit/qt/WebCoreSupport/QWebPageAdapter.cpp:1244 > - return frame->eventHandler()->keyEvent(ev); > + return frame->eventHandler()->keyEvent(PlatformKeyboardEvent(ev, settings->testAttribute(QWebSettings::UseNativeVirtualKeyAsDOMKey))); I think this is quite messy to be honest. Do we need the setting? What would you think about simply passing the nativeVirtualKey as well to windowsKeyCodeForKeyEvent, which would fall back to the nativeVirtualKey if the keycode is 0? I don't see any use case where a 0 key to a QKeyEvent is expected, so this could allow to shape legacy web key events. 912549 31 207542 arurajku 2013-07-29 10:33:22 -0700 Comment on attachment 207542 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=207542&action=review Currently I'm changing the code to use nativeVirtualKey always if 'UseNativeVirtualKeyAsDOMKey' settings is enabled. >> Source/WebKit/qt/Api/qwebsettings.cpp:515 >> + when Qt::Key to DOM key converstion fails. It might be useful for sending domain specific key values > > "when Qt::Key to DOM key converstion fails" is false isn't it? It seems like this will be triggered only if the key is 0. True, it will be triggered only if windowsKeyCodeForKeyEvent() return 0. >> Source/WebKit/qt/WebCoreSupport/QWebPageAdapter.cpp:1244 >> + return frame->eventHandler()->keyEvent(PlatformKeyboardEvent(ev, settings->testAttribute(QWebSettings::UseNativeVirtualKeyAsDOMKey))); > > I think this is quite messy to be honest. > Do we need the setting? What would you think about simply passing the nativeVirtualKey as well to windowsKeyCodeForKeyEvent, which would fall back to the nativeVirtualKey if the keycode is 0? > > I don't see any use case where a 0 key to a QKeyEvent is expected, so this could allow to shape legacy web key events. nativeVirtualKey() property may have some other value in window systems like X11(xcb_keycode_t), DirectFB,.. If I say simply, Allen(& me too) don't want to break the existing behavior unless QtWebKit embedder decided to override by enabling a QWebSettings :) 912561 32 207542 arurajku 2013-07-29 11:04:35 -0700 Comment on attachment 207542 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=207542&action=review >>> Source/WebKit/qt/WebCoreSupport/QWebPageAdapter.cpp:1244 >>> + return frame->eventHandler()->keyEvent(PlatformKeyboardEvent(ev, settings->testAttribute(QWebSettings::UseNativeVirtualKeyAsDOMKey))); >> >> I think this is quite messy to be honest. >> Do we need the setting? What would you think about simply passing the nativeVirtualKey as well to windowsKeyCodeForKeyEvent, which would fall back to the nativeVirtualKey if the keycode is 0? >> >> I don't see any use case where a 0 key to a QKeyEvent is expected, so this could allow to shape legacy web key events. > > nativeVirtualKey() property may have some other value in window systems like X11(xcb_keycode_t), DirectFB,.. If I say simply, Allen(& me too) don't want to break the existing behavior unless QtWebKit embedder decided to override by enabling a QWebSettings :) One more point, if QtWebKit embedder wants to override some of Qt::Key to Windows conversion then it is not possible with the approach you mentioned(my prev. patch also has the issue), for example for Qt::Key_Pause it maps to VK_PAUSE(0x13), but in CE-HTML it should be VK_PAUSE(0x51). So I'm going to modify the patch like below, m_nativeVirtualKeyCode = event->nativeVirtualKey(); if (allowNativeVirtualKeyAsDOMKey && m_nativeVirtualKeyCode) m_windowsVirtualKeyCode = m_nativeVirtualKeyCode; else m_windowsVirtualKeyCode = windowsKeyCodeForKeyEvent(event->key(), m_isKeypad); 912590 33 207669 arurajku 2013-07-29 13:15:54 -0700 Created attachment 207669 Patch 912591 34 207669 arurajku 2013-07-29 13:20:26 -0700 Comment on attachment 207669 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=207669&action=review > Source/WebCore/platform/qt/PlatformKeyboardEventQt.cpp:665 > + if (!m_allowNativeVirtualKeyAsDOMKey && m_text.isEmpty() && m_windowsVirtualKeyCode && isVirtualKeyCodeRepresentingCharacter(m_windowsVirtualKeyCode)) In-case of using nativeVirtualKey as DOM key don't resolve Char Event type in disambiguateKeyDown. isVirtualKeyCodeRepresentingCharacter() function checks for visual representation, it may unnecessarily generate keypress event for invisible keys.(sending visible keys is not a problem for us) 912778 35 jturcotte 2013-07-30 04:45:32 -0700 (In reply to comment #31) > > I don't see any use case where a 0 key to a QKeyEvent is expected, so this could allow to shape legacy web key events. > > nativeVirtualKey() property may have some other value in window systems like X11(xcb_keycode_t), DirectFB,.. If I say simply, Allen(& me too) don't want to break the existing behavior unless QtWebKit embedder decided to override by enabling a QWebSettings :) The switch of behavior would be done when QKeyEvent::key() returns 0, which isn't a normal use case at all in Qt, and should never happen. What I mean is that using a QWebSettings + key() = 0 should have the same scope of effect as just key() = 0. I just don't like this boolean passing of the QWebSetting down to PlatformKeyboardEvent on each event. (btw, his name is Allan, not Allen) 912781 36 arurajku 2013-07-30 04:59:37 -0700 (In reply to comment #35) > (In reply to comment #31) > > > I don't see any use case where a 0 key to a QKeyEvent is expected, so this could allow to shape legacy web key events. > > > > nativeVirtualKey() property may have some other value in window systems like X11(xcb_keycode_t), DirectFB,.. If I say simply, Allen(& me too) don't want to break the existing behavior unless QtWebKit embedder decided to override by enabling a QWebSettings :) > > The switch of behavior would be done when QKeyEvent::key() returns 0, which isn't a normal use case at all in Qt, and should never happen. What I mean is that using a QWebSettings + key() = 0 should have the same scope of effect as just key() = 0. > > I just don't like this boolean passing of the QWebSetting down to PlatformKeyboardEvent on each event. > > (btw, his name is Allan, not Allen) (In reply to comment #35) > (In reply to comment #31) > > > I don't see any use case where a 0 key to a QKeyEvent is expected, so this could allow to shape legacy web key events. > > > > nativeVirtualKey() property may have some other value in window systems like X11(xcb_keycode_t), DirectFB,.. If I say simply, Allen(& me too) don't want to break the existing behavior unless QtWebKit embedder decided to override by enabling a QWebSettings :) > > The switch of behavior would be done when QKeyEvent::key() returns 0, which isn't a normal use case at all in Qt, and should never happen. What I mean is that using a QWebSettings + key() = 0 should have the same scope of effect as just key() = 0. True. But in the new patch, I modified to use nativeVirtualKey always incase settings is enabled. Because there is a use case to override the keyCode value for Qt's standard key also. > > I just don't like this boolean passing of the QWebSetting down to PlatformKeyboardEvent on each event. > I agree with you. It causes QList lookup during each KeyboardEvent. But settings is became necessary for the new implementation. > (btw, his name is Allan, not Allen) sorry :( 914531 37 207669 allan.jensen 2013-08-05 02:59:53 -0700 Comment on attachment 207669 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=207669&action=review > Source/WebKit/qt/Api/qwebsettings.cpp:516 > + \value UseNativeVirtualKeyAsDOMKey Specifies whether to use QKeyEvent::nativeVirtualKey as a DOM keyCode > + value. It might be useful for sending domain specific key values to Web Application. It is disabled > + by default. Specifies whether to use QKeyEvent::nativeVirtualKey as the DOM KeyboardEvent keyCode value instead of Windows virtual key codes. This can be used to send domain specific key values to a Web Application. This is disabled by default. 914607 38 208130 arurajku 2013-08-05 09:52:56 -0700 Created attachment 208130 Patch 915712 39 208401 arurajku 2013-08-09 00:31:26 -0700 Created attachment 208401 Patch 915722 40 208401 hausmann 2013-08-09 00:53:07 -0700 Comment on attachment 208401 Patch LGTM. Jocelyn, Allan, what do you think? 915759 41 208401 allan.jensen 2013-08-09 04:46:07 -0700 Comment on attachment 208401 Patch LGTMT 915763 42 208401 commit-queue 2013-08-09 05:10:09 -0700 Comment on attachment 208401 Patch Clearing flags on attachment: 208401 Committed r153884: <http://trac.webkit.org/changeset/153884> 915764 43 commit-queue 2013-08-09 05:10:13 -0700 All reviewed patches have been landed. Closing bug. 206194 2013-07-06 12:43:36 -0700 2013-07-26 11:20:10 -0700 Patch bug-118445-20130707011125.patch text/plain 4517 arurajku U3VidmVyc2lvbiBSZXZpc2lvbjogMTUyNDE3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggOWE2M2VjYWYwN2M5YmFj Y2Q0YzE5ODYxYzMzODg5Nzc5MTYzODJjZC4uNDkwMTZlYmQyMzY3YzFiODIzY2FmZDI3Njk3Y2M2 NGNhYTcwOGFhYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDEzLTA3LTA2ICBBcnVu cHJhc2FkIFJhamt1bWFyICA8YXJ1cmFqa3VAY2lzY28uY29tPgorCisgICAgICAgIFtRdF0gUXRX ZWJLaXQgc2hvdWxkIGFsbG93IHNlbmRpbmcgZG9tYWluIHNwZWNpZmljIGtleWNvZGUgdG8gSFRN TCBhcHBsaWNhdGlvbnMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTExODQ0NQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIE5vIG5ldyB0ZXN0IHJlcXVpcmVkLCBpdCBpcyBjb3ZlcmVkIGJ5IFF0V2ViS2l0IEFQ SSB0ZXN0LgorCisgICAgICAgIFRoaXMgZml4IGFsbG93cyBzZW5kaW5nIGN1c3RvbSBrZXkgdmFs dWUgdG8gSFRNTCBhcHBsaWNhdGlvbnMuIFByaW9yIHRoaXMgZml4LCBRdFdlYktpdCB3b3VsZCBh bGxvdworICAgICAgICBvbmx5IGtleSB2YWx1ZXMgd2hpY2ggcHJlc2VudCBpcyBpbiBQQyBrZXli b2FyZC4KKworICAgICAgICAqIHBsYXRmb3JtL3F0L1BsYXRmb3JtS2V5Ym9hcmRFdmVudFF0LmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OndpbmRvd3NLZXlDb2RlRm9yS2V5RXZlbnQpOiBJZiB0aGUg Z2l2ZW4ga2V5Q29kZSBkb2Vzbid0IG1hdGNoZXMgdG8gYW55IFF0OjpLZXkgcmFuZ2UsIHNlbmQg YXMgaXQgaXMKKyAgICAgICAgdG8gV2ViS2l0LiBTaW5jZSBpdCBpcyBhIGRvbWFpbiBzcGVjaWZp YyBrZXksIGNvcnJlc3BvbmRpbmcgSFRNTCBhcHAga25vd3MgaG93IHRvIGhhbmRsZSBpdC4KKwog MjAxMy0wNy0wNSAgQmVuamFtaW4gRHVwb250ICAgPGJkdXBvbnRAbmRzLmNvbT4KIAogICAgICAg ICBTZWdtZW50YXRpb24gZmF1bHQgb2NjdXJyZWQgd2hlbiBJQ1UgZGF0YSBsaWJyYXJ5IGRvZXNu J3QgZW1iZWQgdGhlIGV4cGVjdGVkIGVuY29kaW5nLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dC9xdC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L3F0L0NoYW5nZUxvZwppbmRleCBjYzlhZDE1 ZDMzZTRlOGU5M2FiM2NmZThlZWEzMjFiYmY1NTgzMzMxLi5lYjEzMDI4NmRhN2Y2NzJmZWI1NTFh NTE3M2I3ZjJhOTk1MWEyOTFkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L3F0L0NoYW5nZUxv ZworKysgYi9Tb3VyY2UvV2ViS2l0L3F0L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDEz LTA3LTA2ICBBcnVucHJhc2FkIFJhamt1bWFyICA8YXJ1cmFqa3VAY2lzY28uY29tPgorCisgICAg ICAgIFtRdF0gUXRXZWJLaXQgc2hvdWxkIGFsbG93IHNlbmRpbmcgZG9tYWluIHNwZWNpZmljIGtl eWNvZGUgdG8gSFRNTCBhcHBsaWNhdGlvbnMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTExODQ0NQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIEFkZGVkIEFQSSB0ZXN0LgorCisgICAgICAgICogdGVzdHMvcXdl YnZpZXcvdHN0X3F3ZWJ2aWV3LmNwcDoKKyAgICAgICAgKHRzdF9RV2ViVmlldzo6ZG9tYWluU3Bl Y2lmaWNLZXlFdmVudCk6CisKIDIwMTMtMDctMDEgIEpvY2hlbiBFaXNpbmdlciAgPGpvY2hlbkBj aHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmVtb3ZlIHN1cHBvcnQgZm9yIGNvbnN1bWFibGUgdXNl ciBnZXN0dXJlcwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vcXQvUGxhdGZv cm1LZXlib2FyZEV2ZW50UXQuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vcXQvUGxhdGZv cm1LZXlib2FyZEV2ZW50UXQuY3BwCmluZGV4IGZjNGI3MjZmZDA4OWNjNjU1YjgwMTI4NjZmYzJl NDZjNTEyYmQzOTAuLmRiNTM3MDQ0N2UzMjc1Y2IxNzE1YTg3MDQ4N2MyNGY3NjFiOTNjYjIgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3F0L1BsYXRmb3JtS2V5Ym9hcmRFdmVu dFF0LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9xdC9QbGF0Zm9ybUtleWJvYXJk RXZlbnRRdC5jcHAKQEAgLTUxNyw3ICs1MTcsNyBAQCBpbnQgd2luZG93c0tleUNvZGVGb3JLZXlF dmVudCh1bnNpZ25lZCBpbnQga2V5Y29kZSwgYm9vbCBpc0tleXBhZCkKICAgICAgICAgLy8gVktf UEExIChGRCkgUEExIGtleQogICAgICAgICAvLyBWS19PRU1fQ0xFQVIgKEZFKSBDbGVhciBrZXkK ICAgICBkZWZhdWx0OgotICAgICAgICByZXR1cm4gMDsKKyAgICAgICAgcmV0dXJuIGtleWNvZGU7 IC8vIFJldHVybiB0aGUgZ2l2ZW4ga2V5Y29kZSBhcyBpdCBpcy4gSXQgbWlnaHQgYmUgdXNlZnVs IGZvciBzZW5kaW5nIGRvbWFpbiBzcGVjaWZpYyBrZXlzKENFSFRNTC9IYmJUVi8uLmV0YykKICAg ICB9CiB9CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvcXQvdGVzdHMvcXdlYnZpZXcvdHN0 X3F3ZWJ2aWV3LmNwcCBiL1NvdXJjZS9XZWJLaXQvcXQvdGVzdHMvcXdlYnZpZXcvdHN0X3F3ZWJ2 aWV3LmNwcAppbmRleCBhOTkwYWQwZjI0ZjM1Njg1ZTJjY2M2MGRmMTY2ZGVhNzA5ZTA0NjdhLi40 NGQyMzY2YWZkN2IxMGQ3MTVhYTUxM2Y3NDM4NTJmYjRkMzJlNTFmIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViS2l0L3F0L3Rlc3RzL3F3ZWJ2aWV3L3RzdF9xd2Vidmlldy5jcHAKKysrIGIvU291cmNl L1dlYktpdC9xdC90ZXN0cy9xd2Vidmlldy90c3RfcXdlYnZpZXcuY3BwCkBAIC01MSw2ICs1MSw3 IEBAIHByaXZhdGUgUV9TTE9UUzoKICAgICB2b2lkIHJldXNlUGFnZV9kYXRhKCk7CiAgICAgdm9p ZCByZXVzZVBhZ2UoKTsKICAgICB2b2lkIG1pY3JvRm9jdXNDb29yZGluYXRlcygpOworICAgIHZv aWQgZG9tYWluU3BlY2lmaWNLZXlFdmVudCgpOyAgICAKICAgICB2b2lkIGZvY3VzSW5wdXRUeXBl cygpOwogICAgIHZvaWQgaG9yaXpvbnRhbFNjcm9sbGJhclRlc3QoKTsKIApAQCAtMjMwLDYgKzIz MSwzMyBAQCB2b2lkIHRzdF9RV2ViVmlldzo6bWljcm9Gb2N1c0Nvb3JkaW5hdGVzKCkKICAgICBR Q09NUEFSRShpbml0aWFsTWljcm9Gb2N1cy50b1JlY3QoKS50cmFuc2xhdGVkKFFQb2ludCgwLC01 MCkpLCBjdXJyZW50TWljcm9Gb2N1cy50b1JlY3QoKSk7CiB9CiAKK3ZvaWQgdHN0X1FXZWJWaWV3 Ojpkb21haW5TcGVjaWZpY0tleUV2ZW50KCkKK3sKKyAgICBRV2ViVmlldyB3ZWJWaWV3OworICAg IHdlYlZpZXcuc2hvdygpOworICAgIFFUZXN0OjpxV2FpdEZvcldpbmRvd0V4cG9zZWQoJndlYlZp ZXcpOworCisgICAgd2ViVmlldy5zZXRIdG1sKFFMYXRpbjFTdHJpbmcoIjxodG1sPjxoZWFkPiIK KyAgICAgICAgIjxzY3JpcHQ+IgorICAgICAgICAidmFyIHJlY2VpdmVkS2V5QXJyYXkgPSBuZXcg QXJyYXkoKTsiCisgICAgICAgICJmdW5jdGlvbiBrZXlFdmVudChlKSB7IgorICAgICAgICAicmVj ZWl2ZWRLZXlBcnJheS5wdXNoKGUudHlwZSsnOicrZS5rZXlDb2RlKyc6JytlLmNoYXJDb2RlKTsi CisgICAgICAgICJ9OyIKKyAgICAgICAgIndpbmRvdy5vbmtleXVwID0ga2V5RXZlbnQ7IHdpbmRv dy5vbmtleXByZXNzID0ga2V5RXZlbnQ7IHdpbmRvdy5vbmtleWRvd24gPSBrZXlFdmVudDsiCisg ICAgICAgICI8L3NjcmlwdD48L2hlYWQ+PGJvZHk+dGVzdDwvYm9keT48L2h0bWw+IikpOworCisg ICAgLy8gU2ltdWxhdGUgZG9tYWluIHNwZWNpZmljIGtleWV2ZW50IHRvIFdlYktpdC4KKyAgICBR S2V5RXZlbnQga2V5RXZlbnQoUUV2ZW50OjpLZXlQcmVzcywgNDAzLCBRdDo6Tm9Nb2RpZmllciwg UVN0cmluZyhRQ2hhcig0MDMpKSk7CisgICAgUUFwcGxpY2F0aW9uOjpzZW5kRXZlbnQoJndlYlZp ZXcsICZrZXlFdmVudCk7CisgICAga2V5RXZlbnQgPSBRS2V5RXZlbnQoUUV2ZW50OjpLZXlSZWxl YXNlLCA0MDMsIFF0OjpOb01vZGlmaWVyLCBRU3RyaW5nKFFDaGFyKDQwMykpKTsKKyAgICBRQXBw bGljYXRpb246OnNlbmRFdmVudCgmd2ViVmlldywgJmtleUV2ZW50KTsKKworICAgIGNvbnN0IFFM YXRpbjFTdHJpbmcgZXhwZWN0ZWRSZWNlaXZlZEtleUFycmF5KCJrZXlkb3duOjQwMzowLGtleXBy ZXNzOjQwMzo0MDMsa2V5dXA6NDAzOjAiKTsKKyAgICBRU3RyaW5nIHJlY2VpdmVkS2V5QXJyYXkg PSB3ZWJWaWV3LnBhZ2UoKS0+bWFpbkZyYW1lKCktPmV2YWx1YXRlSmF2YVNjcmlwdChRTGF0aW4x U3RyaW5nKCJyZWNlaXZlZEtleUFycmF5IikpLnRvU3RyaW5nTGlzdCgpLmpvaW4oIiwiKTsKKwor ICAgIFFWRVJJRlkocmVjZWl2ZWRLZXlBcnJheSA9PSBleHBlY3RlZFJlY2VpdmVkS2V5QXJyYXkp OworfQorCiB2b2lkIHRzdF9RV2ViVmlldzo6Zm9jdXNJbnB1dFR5cGVzKCkKIHsKICAgICBRV2Vi VmlldyB3ZWJWaWV3Owo= 207542 2013-07-26 11:20:33 -0700 2013-07-29 13:15:43 -0700 Patch bug-118445-20130726235019.patch text/plain 11398 arurajku U3VidmVyc2lvbiBSZXZpc2lvbjogMTUyOTQ5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMDkyNGY2ZWRkMDNkYjc3 ZDU4M2I0NmQ5MGRhYjM5ZTdkZDY3MWY4My4uOTQ4ZjVjZmIyNmM4OWJhMjAxOWJjODBhM2FmYzBl MGEyYzE4ZDIxNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDEzLTA3LTI2ICBBcnVu cHJhc2FkIFJhamt1bWFyICA8YXJ1cmFqa3VAY2lzY28uY29tPgorCisgICAgICAgIFtRdF0gUXRX ZWJLaXQgc2hvdWxkIGFsbG93IHNlbmRpbmcgZG9tYWluIHNwZWNpZmljIGtleWNvZGUgdG8gSFRN TCBhcHBsaWNhdGlvbnMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTExODQ0NQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIE5vIG5ldyB0ZXN0IHJlcXVpcmVkLCBpdCBpcyBjb3ZlcmVkIGJ5IFF0V2ViS2l0IEFQ SSB0ZXN0LgorCisgICAgICAgIFRoaXMgZml4IGFsbG93cyBzZW5kaW5nIGN1c3RvbSBrZXkgdmFs dWUgdG8gSFRNTCBhcHBsaWNhdGlvbnMuIFByaW9yIHRoaXMgZml4LCBRdFdlYktpdCB3b3VsZCBh bGxvdworICAgICAgICBvbmx5IGtleSB2YWx1ZXMgd2hpY2ggcHJlc2VudCBpcyBpbiBQQyBrZXli b2FyZC4KKworICAgICAgICAqIHBsYXRmb3JtL1BsYXRmb3JtS2V5Ym9hcmRFdmVudC5oOgorICAg ICAgICAqIHBsYXRmb3JtL3F0L1BsYXRmb3JtS2V5Ym9hcmRFdmVudFF0LmNwcDoKKyAgICAgICAg KFdlYkNvcmU6OlBsYXRmb3JtS2V5Ym9hcmRFdmVudDo6UGxhdGZvcm1LZXlib2FyZEV2ZW50KToK KwogMjAxMy0wNy0yMCAgQmVuamFtaW4gUG91bGFpbiAgPGJlbmphbWluQHdlYmtpdC5vcmc+CiAK ICAgICAgICAgQWRkIEFTQ0lJTGl0ZXJhbCgpIG9uIHN0cmluZ3MgYWxsb2NhdGVkIG9mdGVuIGVu b3VnaCB0byBhcHBlYXIgaW4gbXkgSW5zdHJ1bWVudHMKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQvcXQvQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9xdC9DaGFuZ2VMb2cKaW5kZXggMjIzYzEx YWRjMjYxYThlZmUxMDA2YjYzNDU0ZWZhOTBhZjA1NDY3Ni4uM2NhOGU1NDdiNWMyYTRkOTQ1NGZj MTgxMGM1MTEyNmRjMzA5MjM5ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9xdC9DaGFuZ2VM b2cKKysrIGIvU291cmNlL1dlYktpdC9xdC9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMSBAQAorMjAx My0wNy0yNiAgQXJ1bnByYXNhZCBSYWprdW1hciAgPGFydXJhamt1QGNpc2NvLmNvbT4KKworICAg ICAgICBbUXRdIFF0V2ViS2l0IHNob3VsZCBhbGxvdyBzZW5kaW5nIGRvbWFpbiBzcGVjaWZpYyBr ZXljb2RlIHRvIEhUTUwgYXBwbGljYXRpb25zCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xMTg0NDUKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBBZGRlZCBBUEkgdGVzdC4KKyAgICAgICAgCisgICAgICAgICog QXBpL3F3ZWJzZXR0aW5ncy5jcHA6CisgICAgICAgIChRV2ViU2V0dGluZ3NQcml2YXRlOjphcHBs eSk6CisgICAgICAgIChRV2ViU2V0dGluZ3M6OlFXZWJTZXR0aW5ncyk6CisgICAgICAgICogQXBp L3F3ZWJzZXR0aW5ncy5oOgorICAgICAgICAqIFdlYkNvcmVTdXBwb3J0L1FXZWJQYWdlQWRhcHRl ci5jcHA6CisgICAgICAgIChRV2ViUGFnZUFkYXB0ZXI6OmhhbmRsZUtleUV2ZW50KToKKyAgICAg ICAgKiB0ZXN0cy9xd2Vidmlldy90c3RfcXdlYnZpZXcuY3BwOgorICAgICAgICAodHN0X1FXZWJW aWV3Ojpkb21haW5TcGVjaWZpY0tleUV2ZW50KToKKwogMjAxMy0wNy0xOCAgR2Fib3IgQWJyYWhh bSAgPGFicmhtQGluZi51LXN6ZWdlZC5odT4KIAogICAgICAgICBbUXRdW1dLMV0gTWFyayBmYWls aW5nIEFQSSB0ZXN0cyBhcyBYRkFJTApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vUGxhdGZvcm1LZXlib2FyZEV2ZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9QbGF0 Zm9ybUtleWJvYXJkRXZlbnQuaAppbmRleCBhYzMyYWU0MDE4NDdkYmVhY2QxNjliODY3NjYwMzgw OWNjMDhjYTFkLi40Nzk1NWEzMGQ1ZWZmYmJiNDc1ZDU3OTY1ODI0NWE2Mzg3MzI1M2YwIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9QbGF0Zm9ybUtleWJvYXJkRXZlbnQuaAor KysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9QbGF0Zm9ybUtleWJvYXJkRXZlbnQuaApAQCAt MTU3LDcgKzE1Nyw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICNlbmRpZgogCiAjaWYgUExBVEZP Uk0oUVQpCi0gICAgICAgIFBsYXRmb3JtS2V5Ym9hcmRFdmVudChRS2V5RXZlbnQqKTsKKyAgICAg ICAgUGxhdGZvcm1LZXlib2FyZEV2ZW50KFFLZXlFdmVudCosIGJvb2wpOwogICAgICAgICBRS2V5 RXZlbnQqIHF0RXZlbnQoKSBjb25zdCB7IHJldHVybiBtX3F0RXZlbnQ7IH0KICAgICAgICAgdWlu dDMyX3QgbmF0aXZlTW9kaWZpZXJzKCkgY29uc3Q7CiAgICAgICAgIHVpbnQzMl90IG5hdGl2ZVNj YW5Db2RlKCkgY29uc3Q7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9xdC9Q bGF0Zm9ybUtleWJvYXJkRXZlbnRRdC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9xdC9Q bGF0Zm9ybUtleWJvYXJkRXZlbnRRdC5jcHAKaW5kZXggZmM0YjcyNmZkMDg5Y2M2NTViODAxMjg2 NmZjMmU0NmM1MTJiZDM5MC4uYjA1MWU4ZDVmYTJmMjQzMDUwMDZmNWRmOWFmMzkzYjFkYzE2ODk2 MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vcXQvUGxhdGZvcm1LZXlib2Fy ZEV2ZW50UXQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3F0L1BsYXRmb3JtS2V5 Ym9hcmRFdmVudFF0LmNwcApAQCAtNjEwLDcgKzYxMCw3IEBAIHN0YXRpYyBTdHJpbmcga2V5VGV4 dEZvcktleUV2ZW50KGNvbnN0IFFLZXlFdmVudCogZXZlbnQpCiAgICAgcmV0dXJuIGV2ZW50LT50 ZXh0KCk7CiB9CiAKLVBsYXRmb3JtS2V5Ym9hcmRFdmVudDo6UGxhdGZvcm1LZXlib2FyZEV2ZW50 KFFLZXlFdmVudCogZXZlbnQpCitQbGF0Zm9ybUtleWJvYXJkRXZlbnQ6OlBsYXRmb3JtS2V5Ym9h cmRFdmVudChRS2V5RXZlbnQqIGV2ZW50LCBib29sIGFsbG93TmF0aXZlVmlydHVhbEtleUFzRE9N S2V5KQogewogICAgIGNvbnN0IGludCBzdGF0ZSA9IGV2ZW50LT5tb2RpZmllcnMoKTsKICAgICBt X3R5cGUgPSAoZXZlbnQtPnR5cGUoKSA9PSBRRXZlbnQ6OktleVJlbGVhc2UpID8gUGxhdGZvcm1F dmVudDo6S2V5VXAgOiBQbGF0Zm9ybUV2ZW50OjpLZXlEb3duOwpAQCAtNjI3LDEyICs2MjcsMjAg QEAgUGxhdGZvcm1LZXlib2FyZEV2ZW50OjpQbGF0Zm9ybUtleWJvYXJkRXZlbnQoUUtleUV2ZW50 KiBldmVudCkKIAogICAgIG1fdGV4dCA9IGtleVRleHRGb3JLZXlFdmVudChldmVudCk7CiAgICAg bV91bm1vZGlmaWVkVGV4dCA9IG1fdGV4dDsgLy8gRklYTUU6IG5vdCBjb3JyZWN0Ci0gICAgbV9r ZXlJZGVudGlmaWVyID0ga2V5SWRlbnRpZmllckZvclF0S2V5Q29kZShldmVudC0+a2V5KCkpOwog ICAgIG1fYXV0b1JlcGVhdCA9IGV2ZW50LT5pc0F1dG9SZXBlYXQoKTsKICAgICBtX2lzS2V5cGFk ID0gKHN0YXRlICYgUXQ6OktleXBhZE1vZGlmaWVyKTsKICAgICBtX2lzU3lzdGVtS2V5ID0gZmFs c2U7CiAgICAgbV93aW5kb3dzVmlydHVhbEtleUNvZGUgPSB3aW5kb3dzS2V5Q29kZUZvcktleUV2 ZW50KGV2ZW50LT5rZXkoKSwgbV9pc0tleXBhZCk7CiAgICAgbV9uYXRpdmVWaXJ0dWFsS2V5Q29k ZSA9IGV2ZW50LT5uYXRpdmVWaXJ0dWFsS2V5KCk7CisgICAgLy8gSWYgbV93aW5kb3dzVmlydHVh bEtleUNvZGUgaXMgMCB0aGVuIHVzZSB0aGUgdmFsdWUgZnJvbSBRS2V5RXZlbnQ6Om5hdGl2ZVZp cnR1YWxLZXkoKS4KKyAgICAvLyBJdCBpcyBhIHNwZWNpYWwgY2FzZSBkZXNpcmVkIGJ5IFF0V2Vi S2l0IGVtYmVkZGVyIHRvIHNlbmQgZG9tYWluIHNwZWNpZmljIGtleXMKKyAgICAvLyB0byBXZWIg QXBwbGljYXRpb25zIGludGVudGVkIGZvciBwbGF0Zm9ybXMgbGlrZSBIYmJUVixDRS1IVE1MLE9J UEYsLi5ldGMuCisgICAgaWYgKCFtX3dpbmRvd3NWaXJ0dWFsS2V5Q29kZSAmJiBhbGxvd05hdGl2 ZVZpcnR1YWxLZXlBc0RPTUtleSkgeworICAgICAgICBtX3dpbmRvd3NWaXJ0dWFsS2V5Q29kZSAg PSBtX25hdGl2ZVZpcnR1YWxLZXlDb2RlOworICAgICAgICBtX2tleUlkZW50aWZpZXIgPSBrZXlJ ZGVudGlmaWVyRm9yUXRLZXlDb2RlKG1fd2luZG93c1ZpcnR1YWxLZXlDb2RlKTsKKyAgICB9IGVs c2UKKyAgICAgICAgbV9rZXlJZGVudGlmaWVyID0ga2V5SWRlbnRpZmllckZvclF0S2V5Q29kZShl dmVudC0+a2V5KCkpOworCiAgICAgbV9tYWNDaGFyQ29kZSA9IDA7CiAgICAgbV9xdEV2ZW50ID0g ZXZlbnQ7CiAgICAgbV90aW1lc3RhbXAgPSBXVEY6OmN1cnJlbnRUaW1lKCk7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0L3F0L0FwaS9xd2Vic2V0dGluZ3MuY3BwIGIvU291cmNlL1dlYktpdC9x dC9BcGkvcXdlYnNldHRpbmdzLmNwcAppbmRleCA3MzQ0YmFlNTk3MGFkNDFjZDAyMzdlZTFkYjY4 MTRiMTJmNTZhYzBhLi41MGRiOWMzYmEyNTZiZmQ0MWQ1YjUwMmRiM2EzM2U2ZjIxYTlkNTY0IDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L3F0L0FwaS9xd2Vic2V0dGluZ3MuY3BwCisrKyBiL1Nv dXJjZS9XZWJLaXQvcXQvQXBpL3F3ZWJzZXR0aW5ncy5jcHAKQEAgLTI5Nyw2ICsyOTcsOSBAQCB2 b2lkIFFXZWJTZXR0aW5nc1ByaXZhdGU6OmFwcGx5KCkKICAgICAgICAgc2V0dGluZ3MtPnNldE5l ZWRzU2l0ZVNwZWNpZmljUXVpcmtzKHZhbHVlKTsKIAogICAgICAgICBzZXR0aW5ncy0+c2V0VXNl c1BhZ2VDYWNoZShXZWJDb3JlOjpwYWdlQ2FjaGUoKS0+Y2FwYWNpdHkoKSk7CisKKyAgICAgICAg YXR0cmlidXRlcy52YWx1ZShRV2ViU2V0dGluZ3M6OlVzZU5hdGl2ZVZpcnR1YWxLZXlBc0RPTUtl eSwKKyAgICAgICAgICAgIGdsb2JhbC0+YXR0cmlidXRlcy52YWx1ZShRV2ViU2V0dGluZ3M6OlVz ZU5hdGl2ZVZpcnR1YWxLZXlBc0RPTUtleSkpOwogICAgIH0gZWxzZSB7CiAgICAgICAgIFFMaXN0 PFFXZWJTZXR0aW5nc1ByaXZhdGUqPiBzZXR0aW5ncyA9ICo6OmFsbFNldHRpbmdzKCk7CiAgICAg ICAgIGZvciAoaW50IGkgPSAwOyBpIDwgc2V0dGluZ3MuY291bnQoKTsgKytpKQpAQCAtNTA4LDYg KzUxMSw5IEBAIFFXZWJTZXR0aW5ncyogUVdlYlNldHRpbmdzOjpnbG9iYWxTZXR0aW5ncygpCiAg ICAgXHZhbHVlIENhcmV0QnJvd3NpbmdFbmFibGVkIFRoaXMgc2V0dGluZyBlbmFibGVzIGNhcmV0 IGJyb3dzaW5nLiBJdCBpcyBkaXNhYmxlZCBieSBkZWZhdWx0LgogICAgIFx2YWx1ZSBOb3RpZmlj YXRpb25zRW5hYmxlZCBTcGVjaWZpZXMgd2hldGhlciBzdXBwb3J0IGZvciB0aGUgSFRNTCA1IHdl YiBub3RpZmljYXRpb25zIGlzIGVuYWJsZWQKICAgICAgICAgb3Igbm90LiBUaGlzIGlzIGVuYWJs ZWQgYnkgZGVmYXVsdC4KKyAgICBcdmFsdWUgVXNlTmF0aXZlVmlydHVhbEtleUFzRE9NS2V5IFNw ZWNpZmllcyB3aGV0aGVyIHRvIHVzZSBRS2V5RXZlbnQ6Om5hdGl2ZVZpcnR1YWxLZXkgYXMgYSBr ZXlDb2RlIHZhbHVlCisgICAgICAgIHdoZW4gUXQ6OktleSB0byBET00ga2V5IGNvbnZlcnN0aW9u IGZhaWxzLiBJdCBtaWdodCBiZSB1c2VmdWwgZm9yIHNlbmRpbmcgZG9tYWluIHNwZWNpZmljIGtl eSB2YWx1ZXMKKyAgICAgICAgdG8gV2ViIEFwcGxpY2F0aW9uLiBUaGlzIGlzIGRpc2FibGVkIGJ5 IGRlZmF1bHQuCiAqLwogCiAvKiEKQEAgLTU2NCw2ICs1NzAsNyBAQCBRV2ViU2V0dGluZ3M6OlFX ZWJTZXR0aW5ncygpCiAgICAgZC0+YXR0cmlidXRlcy5pbnNlcnQoUVdlYlNldHRpbmdzOjpTY3Jv bGxBbmltYXRvckVuYWJsZWQsIGZhbHNlKTsKICAgICBkLT5hdHRyaWJ1dGVzLmluc2VydChRV2Vi U2V0dGluZ3M6OkNhcmV0QnJvd3NpbmdFbmFibGVkLCBmYWxzZSk7CiAgICAgZC0+YXR0cmlidXRl cy5pbnNlcnQoUVdlYlNldHRpbmdzOjpOb3RpZmljYXRpb25zRW5hYmxlZCwgdHJ1ZSk7CisgICAg ZC0+YXR0cmlidXRlcy5pbnNlcnQoUVdlYlNldHRpbmdzOjpVc2VOYXRpdmVWaXJ0dWFsS2V5QXNE T01LZXksIGZhbHNlKTsKICAgICBkLT5vZmZsaW5lU3RvcmFnZURlZmF1bHRRdW90YSA9IDUgKiAx MDI0ICogMTAyNDsKICAgICBkLT5kZWZhdWx0VGV4dEVuY29kaW5nID0gUUxhdGluMVN0cmluZygi aXNvLTg4NTktMSIpOwogICAgIGQtPnRoaXJkUGFydHlDb29raWVQb2xpY3kgPSBBbHdheXNBbGxv d1RoaXJkUGFydHlDb29raWVzOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9xdC9BcGkvcXdl YnNldHRpbmdzLmggYi9Tb3VyY2UvV2ViS2l0L3F0L0FwaS9xd2Vic2V0dGluZ3MuaAppbmRleCA2 MWZmOTMwYzgwYzc4NGIwMTJkMzI1M2NiZDYxODljMTNkOGZiNWJmLi45YWY0NWNlNDFjOTI3ZjQ0 MGIzM2ZjMjAzNTYzYzk0MjgyYzU2N2NjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L3F0L0Fw aS9xd2Vic2V0dGluZ3MuaAorKysgYi9Tb3VyY2UvV2ViS2l0L3F0L0FwaS9xd2Vic2V0dGluZ3Mu aApAQCAtODYsNyArODYsOCBAQCBwdWJsaWM6CiAgICAgICAgIFNjcm9sbEFuaW1hdG9yRW5hYmxl ZCwKICAgICAgICAgQ2FyZXRCcm93c2luZ0VuYWJsZWQsCiAgICAgICAgIE5vdGlmaWNhdGlvbnNF bmFibGVkLAotICAgICAgICBXZWJBdWRpb0VuYWJsZWQKKyAgICAgICAgV2ViQXVkaW9FbmFibGVk LAorICAgICAgICBVc2VOYXRpdmVWaXJ0dWFsS2V5QXNET01LZXkKICAgICB9OwogICAgIGVudW0g V2ViR3JhcGhpYyB7CiAgICAgICAgIE1pc3NpbmdJbWFnZUdyYXBoaWMsCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L1FXZWJQYWdlQWRhcHRlci5jcHAgYi9Tb3Vy Y2UvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L1FXZWJQYWdlQWRhcHRlci5jcHAKaW5kZXggMjEw ZWE0MWYzZjQ2OWMzZjk2MzQzOTdmMjBhZTdlYjI5MGJiNGNjNC4uMjA4NmNiMzViMDQ3YjM4ZmIz ZGMzMWU3ZDlhYTMzYWZhMzY1ODYyYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9xdC9XZWJD b3JlU3VwcG9ydC9RV2ViUGFnZUFkYXB0ZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvcXQvV2Vi Q29yZVN1cHBvcnQvUVdlYlBhZ2VBZGFwdGVyLmNwcApAQCAtMTI0MSw3ICsxMjQxLDcgQEAgUVdl YlBhZ2VBZGFwdGVyOjpWaWV3cG9ydEF0dHJpYnV0ZXMgUVdlYlBhZ2VBZGFwdGVyOjp2aWV3cG9y dEF0dHJpYnV0ZXNGb3JTaXplKGMKIGJvb2wgUVdlYlBhZ2VBZGFwdGVyOjpoYW5kbGVLZXlFdmVu dChRS2V5RXZlbnQgKmV2KQogewogICAgIEZyYW1lKiBmcmFtZSA9IHBhZ2UtPmZvY3VzQ29udHJv bGxlcigpLT5mb2N1c2VkT3JNYWluRnJhbWUoKTsKLSAgICByZXR1cm4gZnJhbWUtPmV2ZW50SGFu ZGxlcigpLT5rZXlFdmVudChldik7CisgICAgcmV0dXJuIGZyYW1lLT5ldmVudEhhbmRsZXIoKS0+ a2V5RXZlbnQoUGxhdGZvcm1LZXlib2FyZEV2ZW50KGV2LCBzZXR0aW5ncy0+dGVzdEF0dHJpYnV0 ZShRV2ViU2V0dGluZ3M6OlVzZU5hdGl2ZVZpcnR1YWxLZXlBc0RPTUtleSkpKTsKIH0KIAogYm9v bCBRV2ViUGFnZUFkYXB0ZXI6OmhhbmRsZVNjcm9sbGluZyhRS2V5RXZlbnQgKmV2KQpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYktpdC9xdC90ZXN0cy9xd2Vidmlldy90c3RfcXdlYnZpZXcuY3BwIGIv U291cmNlL1dlYktpdC9xdC90ZXN0cy9xd2Vidmlldy90c3RfcXdlYnZpZXcuY3BwCmluZGV4IGE5 OTBhZDBmMjRmMzU2ODVlMmNjYzYwZGYxNjZkZWE3MDllMDQ2N2EuLjFhOTVmNGE3NTg2MDZiM2U0 NTE0MTBmNDRjYjkyN2I4ZmIxZTkzZTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvcXQvdGVz dHMvcXdlYnZpZXcvdHN0X3F3ZWJ2aWV3LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L3F0L3Rlc3Rz L3F3ZWJ2aWV3L3RzdF9xd2Vidmlldy5jcHAKQEAgLTUxLDYgKzUxLDcgQEAgcHJpdmF0ZSBRX1NM T1RTOgogICAgIHZvaWQgcmV1c2VQYWdlX2RhdGEoKTsKICAgICB2b2lkIHJldXNlUGFnZSgpOwog ICAgIHZvaWQgbWljcm9Gb2N1c0Nvb3JkaW5hdGVzKCk7CisgICAgdm9pZCBkb21haW5TcGVjaWZp Y0tleUV2ZW50KCk7CiAgICAgdm9pZCBmb2N1c0lucHV0VHlwZXMoKTsKICAgICB2b2lkIGhvcml6 b250YWxTY3JvbGxiYXJUZXN0KCk7CiAKQEAgLTIzMCw2ICsyMzEsNTUgQEAgdm9pZCB0c3RfUVdl YlZpZXc6Om1pY3JvRm9jdXNDb29yZGluYXRlcygpCiAgICAgUUNPTVBBUkUoaW5pdGlhbE1pY3Jv Rm9jdXMudG9SZWN0KCkudHJhbnNsYXRlZChRUG9pbnQoMCwtNTApKSwgY3VycmVudE1pY3JvRm9j dXMudG9SZWN0KCkpOwogfQogCit2b2lkIHRzdF9RV2ViVmlldzo6ZG9tYWluU3BlY2lmaWNLZXlF dmVudCgpCit7CisgICAgUVdlYlZpZXcgd2ViVmlldzsKKyAgICB3ZWJWaWV3LnNob3coKTsKKyAg ICBRVGVzdDo6cVdhaXRGb3JXaW5kb3dFeHBvc2VkKCZ3ZWJWaWV3KTsKKworICAgIHdlYlZpZXcu c2V0SHRtbChRTGF0aW4xU3RyaW5nKCI8aHRtbD48aGVhZD4iCisgICAgICAgICI8c2NyaXB0PiIK KyAgICAgICAgInZhciByZWNlaXZlZEtleUFycmF5ID0gbmV3IEFycmF5KCk7IgorICAgICAgICAi ZnVuY3Rpb24ga2V5RXZlbnQoZSkgeyIKKyAgICAgICAgInJlY2VpdmVkS2V5QXJyYXkucHVzaChl LnR5cGUrJzonK2Uua2V5Q29kZSsnOicrZS5jaGFyQ29kZSk7IgorICAgICAgICAifTsiCisgICAg ICAgICJ3aW5kb3cub25rZXl1cCA9IGtleUV2ZW50OyB3aW5kb3cub25rZXlwcmVzcyA9IGtleUV2 ZW50OyB3aW5kb3cub25rZXlkb3duID0ga2V5RXZlbnQ7IgorICAgICAgICAiPC9zY3JpcHQ+PC9o ZWFkPjxib2R5PnRlc3Q8L2JvZHk+PC9odG1sPiIpKTsKKyAgICAKKyAgICAvLyBFbmFibGUgc2V0 dGluZ3MgdG8gdXNlIG5hdGl2ZVZpcnR1YWxLZXkgYXMgRE9NIGtleSB2YWx1ZS4KKyAgICB3ZWJW aWV3LnNldHRpbmdzKCktPnNldEF0dHJpYnV0ZShRV2ViU2V0dGluZ3M6OlVzZU5hdGl2ZVZpcnR1 YWxLZXlBc0RPTUtleSwgdHJ1ZSk7CisgICAgLy8gU2ltdWxhdGUgZG9tYWluIHNwZWNpZmljIGtl eWV2ZW50IHRvIFdlYktpdCBieSBwYXNzaW5nIGl0IGFzIG5hdGl2ZVZpcnR1YWxLZXkgaW4gUUtl eUV2ZW50LgorICAgIFFLZXlFdmVudCBrZXlFdmVudChRRXZlbnQ6OktleVByZXNzLCAwLCBRdDo6 Tm9Nb2RpZmllciwgMCwgNDAzLCAwKTsKKyAgICBRQXBwbGljYXRpb246OnNlbmRFdmVudCgmd2Vi VmlldywgJmtleUV2ZW50KTsKKyAgICBrZXlFdmVudCA9IFFLZXlFdmVudChRRXZlbnQ6OktleVJl bGVhc2UsIDAsIFF0OjpOb01vZGlmaWVyLCAwLCA0MDMsIDApOworICAgIFFBcHBsaWNhdGlvbjo6 c2VuZEV2ZW50KCZ3ZWJWaWV3LCAma2V5RXZlbnQpOworICAgIGNvbnN0IFFMYXRpbjFTdHJpbmcg ZXhwZWN0ZWRSZWNlaXZlZEtleUFycmF5MSgia2V5ZG93bjo0MDM6MCxrZXl1cDo0MDM6MCIpOwor ICAgIFFTdHJpbmcgcmVjZWl2ZWRLZXlBcnJheSA9IHdlYlZpZXcucGFnZSgpLT5tYWluRnJhbWUo KS0+ZXZhbHVhdGVKYXZhU2NyaXB0KFFMYXRpbjFTdHJpbmcoInJlY2VpdmVkS2V5QXJyYXkiKSku dG9TdHJpbmdMaXN0KCkuam9pbigiLCIpOworICAgIFFWRVJJRlkocmVjZWl2ZWRLZXlBcnJheSA9 PSBleHBlY3RlZFJlY2VpdmVkS2V5QXJyYXkxKTsKKworICAgIC8vIE5vcm1hbCBQQyBrZXlib2Fy ZCBrZXkgY29udmVyc3Rpb24gZmxvdyBzaG91bGRuJ3QgYmUgYWZmZWN0ZWQuCisgICAgd2ViVmll dy5wYWdlKCktPm1haW5GcmFtZSgpLT5ldmFsdWF0ZUphdmFTY3JpcHQoUUxhdGluMVN0cmluZygi cmVjZWl2ZWRLZXlBcnJheSA9IG5ldyBBcnJheSgpIikpOyAvLyBSZXNldAorICAgIGtleUV2ZW50 ID0gUUtleUV2ZW50KFFFdmVudDo6S2V5UHJlc3MsIFF0OjpLZXlfTGVmdCwgUXQ6Ok5vTW9kaWZp ZXIsIDAsIDQwMywgMCk7CisgICAgUUFwcGxpY2F0aW9uOjpzZW5kRXZlbnQoJndlYlZpZXcsICZr ZXlFdmVudCk7CisgICAga2V5RXZlbnQgPSBRS2V5RXZlbnQoUUV2ZW50OjpLZXlSZWxlYXNlLCBR dDo6S2V5X0xlZnQsIFF0OjpOb01vZGlmaWVyLCAwLCA0MDMsIDApOworICAgIFFBcHBsaWNhdGlv bjo6c2VuZEV2ZW50KCZ3ZWJWaWV3LCAma2V5RXZlbnQpOworICAgIGNvbnN0IFFMYXRpbjFTdHJp bmcgZXhwZWN0ZWRSZWNlaXZlZEtleUFycmF5Migia2V5ZG93bjozNzowLGtleXVwOjM3OjAiKTsK KyAgICByZWNlaXZlZEtleUFycmF5ID0gd2ViVmlldy5wYWdlKCktPm1haW5GcmFtZSgpLT5ldmFs dWF0ZUphdmFTY3JpcHQoUUxhdGluMVN0cmluZygicmVjZWl2ZWRLZXlBcnJheSIpKS50b1N0cmlu Z0xpc3QoKS5qb2luKCIsIik7CisgICAgUVZFUklGWShyZWNlaXZlZEtleUFycmF5ID09IGV4cGVj dGVkUmVjZWl2ZWRLZXlBcnJheTIpOworCisgICAgLy8gTmVnYXRpdmUgY2FzZS4KKyAgICAvLyBE aXNhYmxlIHNldHRpbmdzIHRvIHVzZSBuYXRpdmVWaXJ0dWFsS2V5IGFzIERPTSBrZXkgdmFsdWUu CisgICAgd2ViVmlldy5wYWdlKCktPm1haW5GcmFtZSgpLT5ldmFsdWF0ZUphdmFTY3JpcHQoUUxh dGluMVN0cmluZygicmVjZWl2ZWRLZXlBcnJheSA9IG5ldyBBcnJheSgpIikpOyAvLyBSZXNldAor ICAgIHdlYlZpZXcuc2V0dGluZ3MoKS0+c2V0QXR0cmlidXRlKFFXZWJTZXR0aW5nczo6VXNlTmF0 aXZlVmlydHVhbEtleUFzRE9NS2V5LCBmYWxzZSk7CisgICAga2V5RXZlbnQgPSBRS2V5RXZlbnQo UUV2ZW50OjpLZXlQcmVzcywgMCwgUXQ6Ok5vTW9kaWZpZXIsIDAsIDQwMywgMCk7CisgICAgUUFw cGxpY2F0aW9uOjpzZW5kRXZlbnQoJndlYlZpZXcsICZrZXlFdmVudCk7CisgICAga2V5RXZlbnQg PSBRS2V5RXZlbnQoUUV2ZW50OjpLZXlSZWxlYXNlLCAwLCBRdDo6Tm9Nb2RpZmllciwgMCwgNDAz LCAwKTsKKyAgICBRQXBwbGljYXRpb246OnNlbmRFdmVudCgmd2ViVmlldywgJmtleUV2ZW50KTsK KyAgICBjb25zdCBRTGF0aW4xU3RyaW5nIGV4cGVjdGVkUmVjZWl2ZWRLZXlBcnJheTMoImtleWRv d246MDowLGtleXVwOjA6MCIpOworICAgIHJlY2VpdmVkS2V5QXJyYXkgPSB3ZWJWaWV3LnBhZ2Uo KS0+bWFpbkZyYW1lKCktPmV2YWx1YXRlSmF2YVNjcmlwdChRTGF0aW4xU3RyaW5nKCJyZWNlaXZl ZEtleUFycmF5IikpLnRvU3RyaW5nTGlzdCgpLmpvaW4oIiwiKTsKKyAgICBRVkVSSUZZKHJlY2Vp dmVkS2V5QXJyYXkgPT0gZXhwZWN0ZWRSZWNlaXZlZEtleUFycmF5Myk7Cit9CisKIHZvaWQgdHN0 X1FXZWJWaWV3Ojpmb2N1c0lucHV0VHlwZXMoKQogewogICAgIFFXZWJWaWV3IHdlYlZpZXc7Cg== 207669 2013-07-29 13:15:54 -0700 2013-08-05 09:52:42 -0700 Patch bug-118445-20130730014541.patch text/plain 12622 arurajku U3VidmVyc2lvbiBSZXZpc2lvbjogMTUyOTQ5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMDkyNGY2ZWRkMDNkYjc3 ZDU4M2I0NmQ5MGRhYjM5ZTdkZDY3MWY4My4uOTQ4ZjVjZmIyNmM4OWJhMjAxOWJjODBhM2FmYzBl MGEyYzE4ZDIxNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDEzLTA3LTI2ICBBcnVu cHJhc2FkIFJhamt1bWFyICA8YXJ1cmFqa3VAY2lzY28uY29tPgorCisgICAgICAgIFtRdF0gUXRX ZWJLaXQgc2hvdWxkIGFsbG93IHNlbmRpbmcgZG9tYWluIHNwZWNpZmljIGtleWNvZGUgdG8gSFRN TCBhcHBsaWNhdGlvbnMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTExODQ0NQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIE5vIG5ldyB0ZXN0IHJlcXVpcmVkLCBpdCBpcyBjb3ZlcmVkIGJ5IFF0V2ViS2l0IEFQ SSB0ZXN0LgorCisgICAgICAgIFRoaXMgZml4IGFsbG93cyBzZW5kaW5nIGN1c3RvbSBrZXkgdmFs dWUgdG8gSFRNTCBhcHBsaWNhdGlvbnMuIFByaW9yIHRoaXMgZml4LCBRdFdlYktpdCB3b3VsZCBh bGxvdworICAgICAgICBvbmx5IGtleSB2YWx1ZXMgd2hpY2ggcHJlc2VudCBpcyBpbiBQQyBrZXli b2FyZC4KKworICAgICAgICAqIHBsYXRmb3JtL1BsYXRmb3JtS2V5Ym9hcmRFdmVudC5oOgorICAg ICAgICAqIHBsYXRmb3JtL3F0L1BsYXRmb3JtS2V5Ym9hcmRFdmVudFF0LmNwcDoKKyAgICAgICAg KFdlYkNvcmU6OlBsYXRmb3JtS2V5Ym9hcmRFdmVudDo6UGxhdGZvcm1LZXlib2FyZEV2ZW50KToK KwogMjAxMy0wNy0yMCAgQmVuamFtaW4gUG91bGFpbiAgPGJlbmphbWluQHdlYmtpdC5vcmc+CiAK ICAgICAgICAgQWRkIEFTQ0lJTGl0ZXJhbCgpIG9uIHN0cmluZ3MgYWxsb2NhdGVkIG9mdGVuIGVu b3VnaCB0byBhcHBlYXIgaW4gbXkgSW5zdHJ1bWVudHMKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQvcXQvQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9xdC9DaGFuZ2VMb2cKaW5kZXggMjIzYzEx YWRjMjYxYThlZmUxMDA2YjYzNDU0ZWZhOTBhZjA1NDY3Ni4uMTQxNzc4OWVhOTM5YmZhMDVmOWE5 NDM0MzBhNTc3Mzk2MzdkM2Y5NSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9xdC9DaGFuZ2VM b2cKKysrIGIvU291cmNlL1dlYktpdC9xdC9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMSBAQAorMjAx My0wNy0yNiAgQXJ1bnByYXNhZCBSYWprdW1hciAgPGFydXJhamt1QGNpc2NvLmNvbT4KKworICAg ICAgICBbUXRdIFF0V2ViS2l0IHNob3VsZCBhbGxvdyBzZW5kaW5nIGRvbWFpbiBzcGVjaWZpYyBr ZXljb2RlIHRvIEhUTUwgYXBwbGljYXRpb25zCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xMTg0NDUKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBBZGRlZCBBUEkgdGVzdC4KKworICAgICAgICAqIEFwaS9xd2Vi c2V0dGluZ3MuY3BwOgorICAgICAgICAoUVdlYlNldHRpbmdzUHJpdmF0ZTo6YXBwbHkpOgorICAg ICAgICAoUVdlYlNldHRpbmdzOjpRV2ViU2V0dGluZ3MpOgorICAgICAgICAqIEFwaS9xd2Vic2V0 dGluZ3MuaDoKKyAgICAgICAgKiBXZWJDb3JlU3VwcG9ydC9RV2ViUGFnZUFkYXB0ZXIuY3BwOgor ICAgICAgICAoUVdlYlBhZ2VBZGFwdGVyOjpoYW5kbGVLZXlFdmVudCk6CisgICAgICAgICogdGVz dHMvcXdlYnZpZXcvdHN0X3F3ZWJ2aWV3LmNwcDoKKyAgICAgICAgKHRzdF9RV2ViVmlldzo6ZG9t YWluU3BlY2lmaWNLZXlFdmVudCk6CisKIDIwMTMtMDctMTggIEdhYm9yIEFicmFoYW0gIDxhYnJo bUBpbmYudS1zemVnZWQuaHU+CiAKICAgICAgICAgW1F0XVtXSzFdIE1hcmsgZmFpbGluZyBBUEkg dGVzdHMgYXMgWEZBSUwKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1BsYXRm b3JtS2V5Ym9hcmRFdmVudC5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vUGxhdGZvcm1LZXli b2FyZEV2ZW50LmgKaW5kZXggYWMzMmFlNDAxODQ3ZGJlYWNkMTY5Yjg2NzY2MDM4MDljYzA4Y2Ex ZC4uNzhhMDU2ZDE4NmQxYTQwZjI4MWJhMzcyZTYzYzYyY2I4OWY1YzlmOSAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vUGxhdGZvcm1LZXlib2FyZEV2ZW50LmgKKysrIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vUGxhdGZvcm1LZXlib2FyZEV2ZW50LmgKQEAgLTgzLDYgKzgz LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogI2VuZGlmCiAjaWYgUExBVEZPUk0oUVQpCiAgICAg ICAgICAgICAsIG1fcXRFdmVudCgwKQorICAgICAgICAgICAgLCBtX2FsbG93TmF0aXZlVmlydHVh bEtleUFzRE9NS2V5KGZhbHNlKQogI2VuZGlmCiAgICAgICAgIHsKICAgICAgICAgfQpAQCAtMTU3 LDcgKzE1OCw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICNlbmRpZgogCiAjaWYgUExBVEZPUk0o UVQpCi0gICAgICAgIFBsYXRmb3JtS2V5Ym9hcmRFdmVudChRS2V5RXZlbnQqKTsKKyAgICAgICAg UGxhdGZvcm1LZXlib2FyZEV2ZW50KFFLZXlFdmVudCosIGJvb2wpOwogICAgICAgICBRS2V5RXZl bnQqIHF0RXZlbnQoKSBjb25zdCB7IHJldHVybiBtX3F0RXZlbnQ7IH0KICAgICAgICAgdWludDMy X3QgbmF0aXZlTW9kaWZpZXJzKCkgY29uc3Q7CiAgICAgICAgIHVpbnQzMl90IG5hdGl2ZVNjYW5D b2RlKCkgY29uc3Q7CkBAIC0xOTYsNiArMTk3LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogI2Vu ZGlmCiAjaWYgUExBVEZPUk0oUVQpCiAgICAgICAgIFFLZXlFdmVudCogbV9xdEV2ZW50OworICAg ICAgICBib29sIG1fYWxsb3dOYXRpdmVWaXJ0dWFsS2V5QXNET01LZXk7CiAjZW5kaWYKICAgICB9 OwogICAgIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vcXQvUGxhdGZvcm1L ZXlib2FyZEV2ZW50UXQuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vcXQvUGxhdGZvcm1L ZXlib2FyZEV2ZW50UXQuY3BwCmluZGV4IGZjNGI3MjZmZDA4OWNjNjU1YjgwMTI4NjZmYzJlNDZj NTEyYmQzOTAuLmViMDViYTVlNGM4YmQ1ODA5YTI1NDQyYTBhY2E5OWIzNTQ1OTgxMzcgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3F0L1BsYXRmb3JtS2V5Ym9hcmRFdmVudFF0 LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9xdC9QbGF0Zm9ybUtleWJvYXJkRXZl bnRRdC5jcHAKQEAgLTYxMCw3ICs2MTAsNyBAQCBzdGF0aWMgU3RyaW5nIGtleVRleHRGb3JLZXlF dmVudChjb25zdCBRS2V5RXZlbnQqIGV2ZW50KQogICAgIHJldHVybiBldmVudC0+dGV4dCgpOwog fQogCi1QbGF0Zm9ybUtleWJvYXJkRXZlbnQ6OlBsYXRmb3JtS2V5Ym9hcmRFdmVudChRS2V5RXZl bnQqIGV2ZW50KQorUGxhdGZvcm1LZXlib2FyZEV2ZW50OjpQbGF0Zm9ybUtleWJvYXJkRXZlbnQo UUtleUV2ZW50KiBldmVudCwgYm9vbCBhbGxvd05hdGl2ZVZpcnR1YWxLZXlBc0RPTUtleSkKIHsK ICAgICBjb25zdCBpbnQgc3RhdGUgPSBldmVudC0+bW9kaWZpZXJzKCk7CiAgICAgbV90eXBlID0g KGV2ZW50LT50eXBlKCkgPT0gUUV2ZW50OjpLZXlSZWxlYXNlKSA/IFBsYXRmb3JtRXZlbnQ6Oktl eVVwIDogUGxhdGZvcm1FdmVudDo6S2V5RG93bjsKQEAgLTYyNSwxNCArNjI1LDIyIEBAIFBsYXRm b3JtS2V5Ym9hcmRFdmVudDo6UGxhdGZvcm1LZXlib2FyZEV2ZW50KFFLZXlFdmVudCogZXZlbnQp CiAgICAgaWYgKHN0YXRlICYgUXQ6Ok1ldGFNb2RpZmllcikKICAgICAgICAgbV9tb2RpZmllcnMg fD0gTWV0YUtleTsKIAorICAgIG1fYWxsb3dOYXRpdmVWaXJ0dWFsS2V5QXNET01LZXkgPSBhbGxv d05hdGl2ZVZpcnR1YWxLZXlBc0RPTUtleTsKICAgICBtX3RleHQgPSBrZXlUZXh0Rm9yS2V5RXZl bnQoZXZlbnQpOwogICAgIG1fdW5tb2RpZmllZFRleHQgPSBtX3RleHQ7IC8vIEZJWE1FOiBub3Qg Y29ycmVjdAogICAgIG1fa2V5SWRlbnRpZmllciA9IGtleUlkZW50aWZpZXJGb3JRdEtleUNvZGUo ZXZlbnQtPmtleSgpKTsKICAgICBtX2F1dG9SZXBlYXQgPSBldmVudC0+aXNBdXRvUmVwZWF0KCk7 CiAgICAgbV9pc0tleXBhZCA9IChzdGF0ZSAmIFF0OjpLZXlwYWRNb2RpZmllcik7CiAgICAgbV9p c1N5c3RlbUtleSA9IGZhbHNlOwotICAgIG1fd2luZG93c1ZpcnR1YWxLZXlDb2RlID0gd2luZG93 c0tleUNvZGVGb3JLZXlFdmVudChldmVudC0+a2V5KCksIG1faXNLZXlwYWQpOwogICAgIG1fbmF0 aXZlVmlydHVhbEtleUNvZGUgPSBldmVudC0+bmF0aXZlVmlydHVhbEtleSgpOworICAgIC8vIElm IFFLZXlFdmVudDo6bmF0aXZlVmlydHVhbEtleSgpIGlzIHZhbGlkICghPTApIGFuZCBhbGxvd05h dGl2ZVZpcnR1YWxLZXlBc0RPTUtleSBpcyBzZXQsCisgICAgLy8gdGhlbiBpdCBpcyBhIHNwZWNp YWwgY2FzZSBkZXNpcmVkIGJ5IFF0V2ViS2l0IGVtYmVkZGVyIHRvIHNlbmQgZG9tYWluIHNwZWNp ZmljIGtleXMKKyAgICAvLyB0byBXZWIgQXBwbGljYXRpb25zIGludGVudGVkIGZvciBwbGF0Zm9y bXMgbGlrZSBIYmJUVixDRS1IVE1MLE9JUEYsLi5ldGMuCisgICAgaWYgKGFsbG93TmF0aXZlVmly dHVhbEtleUFzRE9NS2V5ICYmIG1fbmF0aXZlVmlydHVhbEtleUNvZGUpCisgICAgICAgIG1fd2lu ZG93c1ZpcnR1YWxLZXlDb2RlICA9IG1fbmF0aXZlVmlydHVhbEtleUNvZGU7CisgICAgZWxzZQor ICAgICAgICBtX3dpbmRvd3NWaXJ0dWFsS2V5Q29kZSA9IHdpbmRvd3NLZXlDb2RlRm9yS2V5RXZl bnQoZXZlbnQtPmtleSgpLCBtX2lzS2V5cGFkKTsKKwogICAgIG1fbWFjQ2hhckNvZGUgPSAwOwog ICAgIG1fcXRFdmVudCA9IGV2ZW50OwogICAgIG1fdGltZXN0YW1wID0gV1RGOjpjdXJyZW50VGlt ZSgpOwpAQCAtNjU0LDcgKzY2Miw3IEBAIHZvaWQgUGxhdGZvcm1LZXlib2FyZEV2ZW50OjpkaXNh bWJpZ3VhdGVLZXlEb3duRXZlbnQoVHlwZSB0eXBlLCBib29sKQogICAgICAgICAgICAgd2UgdHJ5 IHRvIGRldGVjdCB0aGlzIHNpdHVhdGlvbiBhbmQgc3RpbGwgc2V0IHRoZSB0ZXh0LCB0byBlbnN1 cmUgdGhhdCB0aGUKICAgICAgICAgICAgIGdlbmVyYWwgZXZlbnQgaGFuZGxpbmcgc2VuZHMgYSBr ZXkgcHJlc3MgZXZlbnQgYWZ0ZXIgdGhpcyBkaXNhbWJpZ3VhdGlvbi4KICAgICAgICAgKi8KLSAg ICAgICAgaWYgKG1fdGV4dC5pc0VtcHR5KCkgJiYgbV93aW5kb3dzVmlydHVhbEtleUNvZGUgJiYg aXNWaXJ0dWFsS2V5Q29kZVJlcHJlc2VudGluZ0NoYXJhY3RlcihtX3dpbmRvd3NWaXJ0dWFsS2V5 Q29kZSkpCisgICAgICAgIGlmICghbV9hbGxvd05hdGl2ZVZpcnR1YWxLZXlBc0RPTUtleSAmJiBt X3RleHQuaXNFbXB0eSgpICYmIG1fd2luZG93c1ZpcnR1YWxLZXlDb2RlICYmIGlzVmlydHVhbEtl eUNvZGVSZXByZXNlbnRpbmdDaGFyYWN0ZXIobV93aW5kb3dzVmlydHVhbEtleUNvZGUpKQogICAg ICAgICAgICAgbV90ZXh0LmFwcGVuZChVQ2hhcihtX3dpbmRvd3NWaXJ0dWFsS2V5Q29kZSkpOwog CiAgICAgICAgIG1fa2V5SWRlbnRpZmllciA9IFN0cmluZygpOwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdC9xdC9BcGkvcXdlYnNldHRpbmdzLmNwcCBiL1NvdXJjZS9XZWJLaXQvcXQvQXBpL3F3 ZWJzZXR0aW5ncy5jcHAKaW5kZXggNzM0NGJhZTU5NzBhZDQxY2QwMjM3ZWUxZGI2ODE0YjEyZjU2 YWMwYS4uYjFhN2U3MjVkMWE3NTZiYzBlMDZmZDQ5OGUxNzAxYmQ3YTY5YTA2MyAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdC9xdC9BcGkvcXdlYnNldHRpbmdzLmNwcAorKysgYi9Tb3VyY2UvV2Vi S2l0L3F0L0FwaS9xd2Vic2V0dGluZ3MuY3BwCkBAIC0yOTcsNiArMjk3LDkgQEAgdm9pZCBRV2Vi U2V0dGluZ3NQcml2YXRlOjphcHBseSgpCiAgICAgICAgIHNldHRpbmdzLT5zZXROZWVkc1NpdGVT cGVjaWZpY1F1aXJrcyh2YWx1ZSk7CiAKICAgICAgICAgc2V0dGluZ3MtPnNldFVzZXNQYWdlQ2Fj aGUoV2ViQ29yZTo6cGFnZUNhY2hlKCktPmNhcGFjaXR5KCkpOworCisgICAgICAgIGF0dHJpYnV0 ZXMudmFsdWUoUVdlYlNldHRpbmdzOjpVc2VOYXRpdmVWaXJ0dWFsS2V5QXNET01LZXksCisgICAg ICAgICAgICBnbG9iYWwtPmF0dHJpYnV0ZXMudmFsdWUoUVdlYlNldHRpbmdzOjpVc2VOYXRpdmVW aXJ0dWFsS2V5QXNET01LZXkpKTsKICAgICB9IGVsc2UgewogICAgICAgICBRTGlzdDxRV2ViU2V0 dGluZ3NQcml2YXRlKj4gc2V0dGluZ3MgPSAqOjphbGxTZXR0aW5ncygpOwogICAgICAgICBmb3Ig KGludCBpID0gMDsgaSA8IHNldHRpbmdzLmNvdW50KCk7ICsraSkKQEAgLTUwOCw2ICs1MTEsOSBA QCBRV2ViU2V0dGluZ3MqIFFXZWJTZXR0aW5nczo6Z2xvYmFsU2V0dGluZ3MoKQogICAgIFx2YWx1 ZSBDYXJldEJyb3dzaW5nRW5hYmxlZCBUaGlzIHNldHRpbmcgZW5hYmxlcyBjYXJldCBicm93c2lu Zy4gSXQgaXMgZGlzYWJsZWQgYnkgZGVmYXVsdC4KICAgICBcdmFsdWUgTm90aWZpY2F0aW9uc0Vu YWJsZWQgU3BlY2lmaWVzIHdoZXRoZXIgc3VwcG9ydCBmb3IgdGhlIEhUTUwgNSB3ZWIgbm90aWZp Y2F0aW9ucyBpcyBlbmFibGVkCiAgICAgICAgIG9yIG5vdC4gVGhpcyBpcyBlbmFibGVkIGJ5IGRl ZmF1bHQuCisgICAgXHZhbHVlIFVzZU5hdGl2ZVZpcnR1YWxLZXlBc0RPTUtleSBTcGVjaWZpZXMg d2hldGhlciB0byB1c2UgUUtleUV2ZW50OjpuYXRpdmVWaXJ0dWFsS2V5IGFzIGEgRE9NIGtleUNv ZGUgCisgICAgICAgIHZhbHVlLiBJdCBtaWdodCBiZSB1c2VmdWwgZm9yIHNlbmRpbmcgZG9tYWlu IHNwZWNpZmljIGtleSB2YWx1ZXMgdG8gV2ViIEFwcGxpY2F0aW9uLiBJdCBpcyBkaXNhYmxlZCAK KyAgICAgICAgYnkgZGVmYXVsdC4KICovCiAKIC8qIQpAQCAtNTY0LDYgKzU3MCw3IEBAIFFXZWJT ZXR0aW5nczo6UVdlYlNldHRpbmdzKCkKICAgICBkLT5hdHRyaWJ1dGVzLmluc2VydChRV2ViU2V0 dGluZ3M6OlNjcm9sbEFuaW1hdG9yRW5hYmxlZCwgZmFsc2UpOwogICAgIGQtPmF0dHJpYnV0ZXMu aW5zZXJ0KFFXZWJTZXR0aW5nczo6Q2FyZXRCcm93c2luZ0VuYWJsZWQsIGZhbHNlKTsKICAgICBk LT5hdHRyaWJ1dGVzLmluc2VydChRV2ViU2V0dGluZ3M6Ok5vdGlmaWNhdGlvbnNFbmFibGVkLCB0 cnVlKTsKKyAgICBkLT5hdHRyaWJ1dGVzLmluc2VydChRV2ViU2V0dGluZ3M6OlVzZU5hdGl2ZVZp cnR1YWxLZXlBc0RPTUtleSwgZmFsc2UpOwogICAgIGQtPm9mZmxpbmVTdG9yYWdlRGVmYXVsdFF1 b3RhID0gNSAqIDEwMjQgKiAxMDI0OwogICAgIGQtPmRlZmF1bHRUZXh0RW5jb2RpbmcgPSBRTGF0 aW4xU3RyaW5nKCJpc28tODg1OS0xIik7CiAgICAgZC0+dGhpcmRQYXJ0eUNvb2tpZVBvbGljeSA9 IEFsd2F5c0FsbG93VGhpcmRQYXJ0eUNvb2tpZXM7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 L3F0L0FwaS9xd2Vic2V0dGluZ3MuaCBiL1NvdXJjZS9XZWJLaXQvcXQvQXBpL3F3ZWJzZXR0aW5n cy5oCmluZGV4IDYxZmY5MzBjODBjNzg0YjAxMmQzMjUzY2JkNjE4OWMxM2Q4ZmI1YmYuLjlhZjQ1 Y2U0MWM5MjdmNDQwYjMzZmMyMDM1NjNjOTQyODJjNTY3Y2MgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJLaXQvcXQvQXBpL3F3ZWJzZXR0aW5ncy5oCisrKyBiL1NvdXJjZS9XZWJLaXQvcXQvQXBpL3F3 ZWJzZXR0aW5ncy5oCkBAIC04Niw3ICs4Niw4IEBAIHB1YmxpYzoKICAgICAgICAgU2Nyb2xsQW5p bWF0b3JFbmFibGVkLAogICAgICAgICBDYXJldEJyb3dzaW5nRW5hYmxlZCwKICAgICAgICAgTm90 aWZpY2F0aW9uc0VuYWJsZWQsCi0gICAgICAgIFdlYkF1ZGlvRW5hYmxlZAorICAgICAgICBXZWJB dWRpb0VuYWJsZWQsCisgICAgICAgIFVzZU5hdGl2ZVZpcnR1YWxLZXlBc0RPTUtleQogICAgIH07 CiAgICAgZW51bSBXZWJHcmFwaGljIHsKICAgICAgICAgTWlzc2luZ0ltYWdlR3JhcGhpYywKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvUVdlYlBhZ2VBZGFwdGVy LmNwcCBiL1NvdXJjZS9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvUVdlYlBhZ2VBZGFwdGVyLmNw cAppbmRleCAyMTBlYTQxZjNmNDY5YzNmOTYzNDM5N2YyMGFlN2ViMjkwYmI0Y2M0Li4yMDg2Y2Iz NWIwNDdiMzhmYjNkYzMxZTdkOWFhMzNhZmEzNjU4NjJjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi S2l0L3F0L1dlYkNvcmVTdXBwb3J0L1FXZWJQYWdlQWRhcHRlci5jcHAKKysrIGIvU291cmNlL1dl YktpdC9xdC9XZWJDb3JlU3VwcG9ydC9RV2ViUGFnZUFkYXB0ZXIuY3BwCkBAIC0xMjQxLDcgKzEy NDEsNyBAQCBRV2ViUGFnZUFkYXB0ZXI6OlZpZXdwb3J0QXR0cmlidXRlcyBRV2ViUGFnZUFkYXB0 ZXI6OnZpZXdwb3J0QXR0cmlidXRlc0ZvclNpemUoYwogYm9vbCBRV2ViUGFnZUFkYXB0ZXI6Omhh bmRsZUtleUV2ZW50KFFLZXlFdmVudCAqZXYpCiB7CiAgICAgRnJhbWUqIGZyYW1lID0gcGFnZS0+ Zm9jdXNDb250cm9sbGVyKCktPmZvY3VzZWRPck1haW5GcmFtZSgpOwotICAgIHJldHVybiBmcmFt ZS0+ZXZlbnRIYW5kbGVyKCktPmtleUV2ZW50KGV2KTsKKyAgICByZXR1cm4gZnJhbWUtPmV2ZW50 SGFuZGxlcigpLT5rZXlFdmVudChQbGF0Zm9ybUtleWJvYXJkRXZlbnQoZXYsIHNldHRpbmdzLT50 ZXN0QXR0cmlidXRlKFFXZWJTZXR0aW5nczo6VXNlTmF0aXZlVmlydHVhbEtleUFzRE9NS2V5KSkp OwogfQogCiBib29sIFFXZWJQYWdlQWRhcHRlcjo6aGFuZGxlU2Nyb2xsaW5nKFFLZXlFdmVudCAq ZXYpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L3F0L3Rlc3RzL3F3ZWJ2aWV3L3RzdF9xd2Vi dmlldy5jcHAgYi9Tb3VyY2UvV2ViS2l0L3F0L3Rlc3RzL3F3ZWJ2aWV3L3RzdF9xd2Vidmlldy5j cHAKaW5kZXggYTk5MGFkMGYyNGYzNTY4NWUyY2NjNjBkZjE2NmRlYTcwOWUwNDY3YS4uZmZjMmM5 YzQ3OWM3NzMxN2ZiMzJkNTAyMDAyNjBlMGIzNjFlYmMzMyAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdC9xdC90ZXN0cy9xd2Vidmlldy90c3RfcXdlYnZpZXcuY3BwCisrKyBiL1NvdXJjZS9XZWJL aXQvcXQvdGVzdHMvcXdlYnZpZXcvdHN0X3F3ZWJ2aWV3LmNwcApAQCAtNTEsNiArNTEsNyBAQCBw cml2YXRlIFFfU0xPVFM6CiAgICAgdm9pZCByZXVzZVBhZ2VfZGF0YSgpOwogICAgIHZvaWQgcmV1 c2VQYWdlKCk7CiAgICAgdm9pZCBtaWNyb0ZvY3VzQ29vcmRpbmF0ZXMoKTsKKyAgICB2b2lkIGRv bWFpblNwZWNpZmljS2V5RXZlbnQoKTsKICAgICB2b2lkIGZvY3VzSW5wdXRUeXBlcygpOwogICAg IHZvaWQgaG9yaXpvbnRhbFNjcm9sbGJhclRlc3QoKTsKIApAQCAtMjMwLDYgKzIzMSw1OCBAQCB2 b2lkIHRzdF9RV2ViVmlldzo6bWljcm9Gb2N1c0Nvb3JkaW5hdGVzKCkKICAgICBRQ09NUEFSRShp bml0aWFsTWljcm9Gb2N1cy50b1JlY3QoKS50cmFuc2xhdGVkKFFQb2ludCgwLC01MCkpLCBjdXJy ZW50TWljcm9Gb2N1cy50b1JlY3QoKSk7CiB9CiAKK3ZvaWQgdHN0X1FXZWJWaWV3Ojpkb21haW5T cGVjaWZpY0tleUV2ZW50KCkKK3sKKyAgICBRV2ViVmlldyB3ZWJWaWV3OworICAgIHdlYlZpZXcu c2hvdygpOworICAgIFFUZXN0OjpxV2FpdEZvcldpbmRvd0V4cG9zZWQoJndlYlZpZXcpOworCisg ICAgd2ViVmlldy5zZXRIdG1sKFFMYXRpbjFTdHJpbmcoIjxodG1sPjxoZWFkPiIKKyAgICAgICAg IjxzY3JpcHQ+IgorICAgICAgICAidmFyIHJlY2VpdmVkS2V5QXJyYXkgPSBuZXcgQXJyYXkoKTsi CisgICAgICAgICJmdW5jdGlvbiBrZXlFdmVudChlKSB7IgorICAgICAgICAicmVjZWl2ZWRLZXlB cnJheS5wdXNoKGUudHlwZSsnOicrZS5rZXlDb2RlKyc6JytlLmNoYXJDb2RlKTsiCisgICAgICAg ICJ9OyIKKyAgICAgICAgIndpbmRvdy5vbmtleXVwID0ga2V5RXZlbnQ7IHdpbmRvdy5vbmtleXBy ZXNzID0ga2V5RXZlbnQ7IHdpbmRvdy5vbmtleWRvd24gPSBrZXlFdmVudDsiCisgICAgICAgICI8 L3NjcmlwdD48L2hlYWQ+PGJvZHk+dGVzdDwvYm9keT48L2h0bWw+IikpOworCisgICAgLy8gRW5h YmxlIHNldHRpbmdzIHRvIHVzZSBuYXRpdmVWaXJ0dWFsS2V5IGFzIERPTSBrZXkgdmFsdWUuCisg ICAgd2ViVmlldy5zZXR0aW5ncygpLT5zZXRBdHRyaWJ1dGUoUVdlYlNldHRpbmdzOjpVc2VOYXRp dmVWaXJ0dWFsS2V5QXNET01LZXksIHRydWUpOworICAgIC8vIFNpbXVsYXRlIGRvbWFpbiBzcGVj aWZpYyBrZXlldmVudCB0byBXZWJLaXQgYnkgcGFzc2luZyBpdCBhcyBuYXRpdmVWaXJ0dWFsS2V5 IGluIFFLZXlFdmVudC4KKyAgICAvLyBRdDo6S2V5X1BhdXNlIC0tPiAweDUxCisgICAgUUtleUV2 ZW50IGtleUV2ZW50KFFFdmVudDo6S2V5UHJlc3MsIFF0OjpLZXlfUGF1c2UsIFF0OjpOb01vZGlm aWVyLCAwLCA4MSwgMCk7CisgICAgUUFwcGxpY2F0aW9uOjpzZW5kRXZlbnQoJndlYlZpZXcsICZr ZXlFdmVudCk7CisgICAga2V5RXZlbnQgPSBRS2V5RXZlbnQoUUV2ZW50OjpLZXlSZWxlYXNlLCBR dDo6S2V5X1BhdXNlLCBRdDo6Tm9Nb2RpZmllciwgMCwgODEsIDApOworICAgIFFBcHBsaWNhdGlv bjo6c2VuZEV2ZW50KCZ3ZWJWaWV3LCAma2V5RXZlbnQpOworICAgIGNvbnN0IFFMYXRpbjFTdHJp bmcgZXhwZWN0ZWRSZWNlaXZlZEtleUFycmF5MSgia2V5ZG93bjo4MTowLGtleXVwOjgxOjAiKTsK KyAgICBRU3RyaW5nIHJlY2VpdmVkS2V5QXJyYXkgPSB3ZWJWaWV3LnBhZ2UoKS0+bWFpbkZyYW1l KCktPmV2YWx1YXRlSmF2YVNjcmlwdChRTGF0aW4xU3RyaW5nKCJyZWNlaXZlZEtleUFycmF5Iikp LnRvU3RyaW5nTGlzdCgpLmpvaW4oIiwiKTsKKyAgICBRVkVSSUZZKHJlY2VpdmVkS2V5QXJyYXkg PT0gZXhwZWN0ZWRSZWNlaXZlZEtleUFycmF5MSk7CisKKyAgICAvLyBOb3JtYWwgUEMga2V5Ym9h cmQga2V5IGNvbnZlcnN0aW9uIGZsb3cgc2hvdWxkbid0IGJlIGFmZmVjdGVkIHdoZW4gc2VuZGlu ZyBuYXRpdmVWaXJ0dWFsIGtleSBhcyAwLgorICAgIC8vIFF0OjpLZXlfUGF1c2UgLS0+IFZLX1BB VVNFKDB4MTMpCisgICAgd2ViVmlldy5wYWdlKCktPm1haW5GcmFtZSgpLT5ldmFsdWF0ZUphdmFT Y3JpcHQoUUxhdGluMVN0cmluZygicmVjZWl2ZWRLZXlBcnJheSA9IG5ldyBBcnJheSgpIikpOyAv LyBSZXNldAorICAgIGtleUV2ZW50ID0gUUtleUV2ZW50KFFFdmVudDo6S2V5UHJlc3MsIFF0OjpL ZXlfUGF1c2UsIFF0OjpOb01vZGlmaWVyLCAwLCAwLCAwKTsKKyAgICBRQXBwbGljYXRpb246OnNl bmRFdmVudCgmd2ViVmlldywgJmtleUV2ZW50KTsKKyAgICBrZXlFdmVudCA9IFFLZXlFdmVudChR RXZlbnQ6OktleVJlbGVhc2UsIFF0OjpLZXlfUGF1c2UsIFF0OjpOb01vZGlmaWVyLCAwLCAwLCAw KTsKKyAgICBRQXBwbGljYXRpb246OnNlbmRFdmVudCgmd2ViVmlldywgJmtleUV2ZW50KTsKKyAg ICBjb25zdCBRTGF0aW4xU3RyaW5nIGV4cGVjdGVkUmVjZWl2ZWRLZXlBcnJheTIoImtleWRvd246 MTk6MCxrZXl1cDoxOTowIik7CisgICAgcmVjZWl2ZWRLZXlBcnJheSA9IHdlYlZpZXcucGFnZSgp LT5tYWluRnJhbWUoKS0+ZXZhbHVhdGVKYXZhU2NyaXB0KFFMYXRpbjFTdHJpbmcoInJlY2VpdmVk S2V5QXJyYXkiKSkudG9TdHJpbmdMaXN0KCkuam9pbigiLCIpOworICAgIFFWRVJJRlkocmVjZWl2 ZWRLZXlBcnJheSA9PSBleHBlY3RlZFJlY2VpdmVkS2V5QXJyYXkyKTsKKworICAgIC8vIE5lZ2F0 aXZlIGNhc2UuCisgICAgLy8gRGlzYWJsZSBzZXR0aW5ncyB0byB1c2UgbmF0aXZlVmlydHVhbEtl eSBhcyBET00ga2V5IHZhbHVlLgorICAgIC8vIFF0OjpLZXlfUGF1c2UgLS0+IFZLX1BBVVNFKDB4 MTMpCisgICAgd2ViVmlldy5wYWdlKCktPm1haW5GcmFtZSgpLT5ldmFsdWF0ZUphdmFTY3JpcHQo UUxhdGluMVN0cmluZygicmVjZWl2ZWRLZXlBcnJheSA9IG5ldyBBcnJheSgpIikpOyAvLyBSZXNl dAorICAgIHdlYlZpZXcuc2V0dGluZ3MoKS0+c2V0QXR0cmlidXRlKFFXZWJTZXR0aW5nczo6VXNl TmF0aXZlVmlydHVhbEtleUFzRE9NS2V5LCBmYWxzZSk7CisgICAga2V5RXZlbnQgPSBRS2V5RXZl bnQoUUV2ZW50OjpLZXlQcmVzcywgUXQ6OktleV9QYXVzZSwgUXQ6Ok5vTW9kaWZpZXIsIDAsIDgx LCAwKTsKKyAgICBRQXBwbGljYXRpb246OnNlbmRFdmVudCgmd2ViVmlldywgJmtleUV2ZW50KTsK KyAgICBrZXlFdmVudCA9IFFLZXlFdmVudChRRXZlbnQ6OktleVJlbGVhc2UsIFF0OjpLZXlfUGF1 c2UsIFF0OjpOb01vZGlmaWVyLCAwLCA4MSwgMCk7CisgICAgUUFwcGxpY2F0aW9uOjpzZW5kRXZl bnQoJndlYlZpZXcsICZrZXlFdmVudCk7CisgICAgY29uc3QgUUxhdGluMVN0cmluZyBleHBlY3Rl ZFJlY2VpdmVkS2V5QXJyYXkzKCJrZXlkb3duOjE5OjAsa2V5dXA6MTk6MCIpOworICAgIHJlY2Vp dmVkS2V5QXJyYXkgPSB3ZWJWaWV3LnBhZ2UoKS0+bWFpbkZyYW1lKCktPmV2YWx1YXRlSmF2YVNj cmlwdChRTGF0aW4xU3RyaW5nKCJyZWNlaXZlZEtleUFycmF5IikpLnRvU3RyaW5nTGlzdCgpLmpv aW4oIiwiKTsKKyAgICBRVkVSSUZZKHJlY2VpdmVkS2V5QXJyYXkgPT0gZXhwZWN0ZWRSZWNlaXZl ZEtleUFycmF5Myk7Cit9CisKIHZvaWQgdHN0X1FXZWJWaWV3Ojpmb2N1c0lucHV0VHlwZXMoKQog ewogICAgIFFXZWJWaWV3IHdlYlZpZXc7Cg== 208130 2013-08-05 09:52:56 -0700 2013-08-09 00:31:13 -0700 Patch bug-118445-20130805222239.patch text/plain 12670 arurajku U3VidmVyc2lvbiBSZXZpc2lvbjogMTUyOTQ5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMDkyNGY2ZWRkMDNkYjc3 ZDU4M2I0NmQ5MGRhYjM5ZTdkZDY3MWY4My4uOTQ4ZjVjZmIyNmM4OWJhMjAxOWJjODBhM2FmYzBl MGEyYzE4ZDIxNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDEzLTA3LTI2ICBBcnVu cHJhc2FkIFJhamt1bWFyICA8YXJ1cmFqa3VAY2lzY28uY29tPgorCisgICAgICAgIFtRdF0gUXRX ZWJLaXQgc2hvdWxkIGFsbG93IHNlbmRpbmcgZG9tYWluIHNwZWNpZmljIGtleWNvZGUgdG8gSFRN TCBhcHBsaWNhdGlvbnMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTExODQ0NQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIE5vIG5ldyB0ZXN0IHJlcXVpcmVkLCBpdCBpcyBjb3ZlcmVkIGJ5IFF0V2ViS2l0IEFQ SSB0ZXN0LgorCisgICAgICAgIFRoaXMgZml4IGFsbG93cyBzZW5kaW5nIGN1c3RvbSBrZXkgdmFs dWUgdG8gSFRNTCBhcHBsaWNhdGlvbnMuIFByaW9yIHRoaXMgZml4LCBRdFdlYktpdCB3b3VsZCBh bGxvdworICAgICAgICBvbmx5IGtleSB2YWx1ZXMgd2hpY2ggcHJlc2VudCBpcyBpbiBQQyBrZXli b2FyZC4KKworICAgICAgICAqIHBsYXRmb3JtL1BsYXRmb3JtS2V5Ym9hcmRFdmVudC5oOgorICAg ICAgICAqIHBsYXRmb3JtL3F0L1BsYXRmb3JtS2V5Ym9hcmRFdmVudFF0LmNwcDoKKyAgICAgICAg KFdlYkNvcmU6OlBsYXRmb3JtS2V5Ym9hcmRFdmVudDo6UGxhdGZvcm1LZXlib2FyZEV2ZW50KToK KwogMjAxMy0wNy0yMCAgQmVuamFtaW4gUG91bGFpbiAgPGJlbmphbWluQHdlYmtpdC5vcmc+CiAK ICAgICAgICAgQWRkIEFTQ0lJTGl0ZXJhbCgpIG9uIHN0cmluZ3MgYWxsb2NhdGVkIG9mdGVuIGVu b3VnaCB0byBhcHBlYXIgaW4gbXkgSW5zdHJ1bWVudHMKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQvcXQvQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9xdC9DaGFuZ2VMb2cKaW5kZXggMjIzYzEx YWRjMjYxYThlZmUxMDA2YjYzNDU0ZWZhOTBhZjA1NDY3Ni4uMTQxNzc4OWVhOTM5YmZhMDVmOWE5 NDM0MzBhNTc3Mzk2MzdkM2Y5NSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9xdC9DaGFuZ2VM b2cKKysrIGIvU291cmNlL1dlYktpdC9xdC9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMSBAQAorMjAx My0wNy0yNiAgQXJ1bnByYXNhZCBSYWprdW1hciAgPGFydXJhamt1QGNpc2NvLmNvbT4KKworICAg ICAgICBbUXRdIFF0V2ViS2l0IHNob3VsZCBhbGxvdyBzZW5kaW5nIGRvbWFpbiBzcGVjaWZpYyBr ZXljb2RlIHRvIEhUTUwgYXBwbGljYXRpb25zCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xMTg0NDUKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBBZGRlZCBBUEkgdGVzdC4KKworICAgICAgICAqIEFwaS9xd2Vi c2V0dGluZ3MuY3BwOgorICAgICAgICAoUVdlYlNldHRpbmdzUHJpdmF0ZTo6YXBwbHkpOgorICAg ICAgICAoUVdlYlNldHRpbmdzOjpRV2ViU2V0dGluZ3MpOgorICAgICAgICAqIEFwaS9xd2Vic2V0 dGluZ3MuaDoKKyAgICAgICAgKiBXZWJDb3JlU3VwcG9ydC9RV2ViUGFnZUFkYXB0ZXIuY3BwOgor ICAgICAgICAoUVdlYlBhZ2VBZGFwdGVyOjpoYW5kbGVLZXlFdmVudCk6CisgICAgICAgICogdGVz dHMvcXdlYnZpZXcvdHN0X3F3ZWJ2aWV3LmNwcDoKKyAgICAgICAgKHRzdF9RV2ViVmlldzo6ZG9t YWluU3BlY2lmaWNLZXlFdmVudCk6CisKIDIwMTMtMDctMTggIEdhYm9yIEFicmFoYW0gIDxhYnJo bUBpbmYudS1zemVnZWQuaHU+CiAKICAgICAgICAgW1F0XVtXSzFdIE1hcmsgZmFpbGluZyBBUEkg dGVzdHMgYXMgWEZBSUwKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1BsYXRm b3JtS2V5Ym9hcmRFdmVudC5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vUGxhdGZvcm1LZXli b2FyZEV2ZW50LmgKaW5kZXggYWMzMmFlNDAxODQ3ZGJlYWNkMTY5Yjg2NzY2MDM4MDljYzA4Y2Ex ZC4uNzhhMDU2ZDE4NmQxYTQwZjI4MWJhMzcyZTYzYzYyY2I4OWY1YzlmOSAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vUGxhdGZvcm1LZXlib2FyZEV2ZW50LmgKKysrIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vUGxhdGZvcm1LZXlib2FyZEV2ZW50LmgKQEAgLTgzLDYgKzgz LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogI2VuZGlmCiAjaWYgUExBVEZPUk0oUVQpCiAgICAg ICAgICAgICAsIG1fcXRFdmVudCgwKQorICAgICAgICAgICAgLCBtX2FsbG93TmF0aXZlVmlydHVh bEtleUFzRE9NS2V5KGZhbHNlKQogI2VuZGlmCiAgICAgICAgIHsKICAgICAgICAgfQpAQCAtMTU3 LDcgKzE1OCw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICNlbmRpZgogCiAjaWYgUExBVEZPUk0o UVQpCi0gICAgICAgIFBsYXRmb3JtS2V5Ym9hcmRFdmVudChRS2V5RXZlbnQqKTsKKyAgICAgICAg UGxhdGZvcm1LZXlib2FyZEV2ZW50KFFLZXlFdmVudCosIGJvb2wpOwogICAgICAgICBRS2V5RXZl bnQqIHF0RXZlbnQoKSBjb25zdCB7IHJldHVybiBtX3F0RXZlbnQ7IH0KICAgICAgICAgdWludDMy X3QgbmF0aXZlTW9kaWZpZXJzKCkgY29uc3Q7CiAgICAgICAgIHVpbnQzMl90IG5hdGl2ZVNjYW5D b2RlKCkgY29uc3Q7CkBAIC0xOTYsNiArMTk3LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogI2Vu ZGlmCiAjaWYgUExBVEZPUk0oUVQpCiAgICAgICAgIFFLZXlFdmVudCogbV9xdEV2ZW50OworICAg ICAgICBib29sIG1fYWxsb3dOYXRpdmVWaXJ0dWFsS2V5QXNET01LZXk7CiAjZW5kaWYKICAgICB9 OwogICAgIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vcXQvUGxhdGZvcm1L ZXlib2FyZEV2ZW50UXQuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vcXQvUGxhdGZvcm1L ZXlib2FyZEV2ZW50UXQuY3BwCmluZGV4IGZjNGI3MjZmZDA4OWNjNjU1YjgwMTI4NjZmYzJlNDZj NTEyYmQzOTAuLjFhNGM3ZTY5MjE5NDU0ZTkyNWY5ZmIxYjMwYjMwODRiMTUxMTY1NTkgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3F0L1BsYXRmb3JtS2V5Ym9hcmRFdmVudFF0 LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9xdC9QbGF0Zm9ybUtleWJvYXJkRXZl bnRRdC5jcHAKQEAgLTYxMCw3ICs2MTAsNyBAQCBzdGF0aWMgU3RyaW5nIGtleVRleHRGb3JLZXlF dmVudChjb25zdCBRS2V5RXZlbnQqIGV2ZW50KQogICAgIHJldHVybiBldmVudC0+dGV4dCgpOwog fQogCi1QbGF0Zm9ybUtleWJvYXJkRXZlbnQ6OlBsYXRmb3JtS2V5Ym9hcmRFdmVudChRS2V5RXZl bnQqIGV2ZW50KQorUGxhdGZvcm1LZXlib2FyZEV2ZW50OjpQbGF0Zm9ybUtleWJvYXJkRXZlbnQo UUtleUV2ZW50KiBldmVudCwgYm9vbCBhbGxvd05hdGl2ZVZpcnR1YWxLZXlBc0RPTUtleSkKIHsK ICAgICBjb25zdCBpbnQgc3RhdGUgPSBldmVudC0+bW9kaWZpZXJzKCk7CiAgICAgbV90eXBlID0g KGV2ZW50LT50eXBlKCkgPT0gUUV2ZW50OjpLZXlSZWxlYXNlKSA/IFBsYXRmb3JtRXZlbnQ6Oktl eVVwIDogUGxhdGZvcm1FdmVudDo6S2V5RG93bjsKQEAgLTYyNSwxNCArNjI1LDIyIEBAIFBsYXRm b3JtS2V5Ym9hcmRFdmVudDo6UGxhdGZvcm1LZXlib2FyZEV2ZW50KFFLZXlFdmVudCogZXZlbnQp CiAgICAgaWYgKHN0YXRlICYgUXQ6Ok1ldGFNb2RpZmllcikKICAgICAgICAgbV9tb2RpZmllcnMg fD0gTWV0YUtleTsKIAorICAgIG1fYWxsb3dOYXRpdmVWaXJ0dWFsS2V5QXNET01LZXkgPSBhbGxv d05hdGl2ZVZpcnR1YWxLZXlBc0RPTUtleTsKICAgICBtX3RleHQgPSBrZXlUZXh0Rm9yS2V5RXZl bnQoZXZlbnQpOwogICAgIG1fdW5tb2RpZmllZFRleHQgPSBtX3RleHQ7IC8vIEZJWE1FOiBub3Qg Y29ycmVjdAogICAgIG1fa2V5SWRlbnRpZmllciA9IGtleUlkZW50aWZpZXJGb3JRdEtleUNvZGUo ZXZlbnQtPmtleSgpKTsKICAgICBtX2F1dG9SZXBlYXQgPSBldmVudC0+aXNBdXRvUmVwZWF0KCk7 CiAgICAgbV9pc0tleXBhZCA9IChzdGF0ZSAmIFF0OjpLZXlwYWRNb2RpZmllcik7CiAgICAgbV9p c1N5c3RlbUtleSA9IGZhbHNlOwotICAgIG1fd2luZG93c1ZpcnR1YWxLZXlDb2RlID0gd2luZG93 c0tleUNvZGVGb3JLZXlFdmVudChldmVudC0+a2V5KCksIG1faXNLZXlwYWQpOwogICAgIG1fbmF0 aXZlVmlydHVhbEtleUNvZGUgPSBldmVudC0+bmF0aXZlVmlydHVhbEtleSgpOworICAgIC8vIElm IFFLZXlFdmVudDo6bmF0aXZlVmlydHVhbEtleSgpIGlzIHZhbGlkICghPTApIGFuZCBhbGxvd05h dGl2ZVZpcnR1YWxLZXlBc0RPTUtleSBpcyBzZXQsCisgICAgLy8gdGhlbiBpdCBpcyBhIHNwZWNp YWwgY2FzZSBkZXNpcmVkIGJ5IFF0V2ViS2l0IGVtYmVkZGVyIHRvIHNlbmQgZG9tYWluIHNwZWNp ZmljIGtleXMKKyAgICAvLyB0byBXZWIgQXBwbGljYXRpb25zIGludGVudGVkIGZvciBwbGF0Zm9y bXMgbGlrZSBIYmJUVixDRS1IVE1MLE9JUEYsLi5ldGMuCisgICAgaWYgKGFsbG93TmF0aXZlVmly dHVhbEtleUFzRE9NS2V5ICYmIG1fbmF0aXZlVmlydHVhbEtleUNvZGUpCisgICAgICAgIG1fd2lu ZG93c1ZpcnR1YWxLZXlDb2RlID0gbV9uYXRpdmVWaXJ0dWFsS2V5Q29kZTsKKyAgICBlbHNlCisg ICAgICAgIG1fd2luZG93c1ZpcnR1YWxLZXlDb2RlID0gd2luZG93c0tleUNvZGVGb3JLZXlFdmVu dChldmVudC0+a2V5KCksIG1faXNLZXlwYWQpOworCiAgICAgbV9tYWNDaGFyQ29kZSA9IDA7CiAg ICAgbV9xdEV2ZW50ID0gZXZlbnQ7CiAgICAgbV90aW1lc3RhbXAgPSBXVEY6OmN1cnJlbnRUaW1l KCk7CkBAIC02NTQsNyArNjYyLDcgQEAgdm9pZCBQbGF0Zm9ybUtleWJvYXJkRXZlbnQ6OmRpc2Ft YmlndWF0ZUtleURvd25FdmVudChUeXBlIHR5cGUsIGJvb2wpCiAgICAgICAgICAgICB3ZSB0cnkg dG8gZGV0ZWN0IHRoaXMgc2l0dWF0aW9uIGFuZCBzdGlsbCBzZXQgdGhlIHRleHQsIHRvIGVuc3Vy ZSB0aGF0IHRoZQogICAgICAgICAgICAgZ2VuZXJhbCBldmVudCBoYW5kbGluZyBzZW5kcyBhIGtl eSBwcmVzcyBldmVudCBhZnRlciB0aGlzIGRpc2FtYmlndWF0aW9uLgogICAgICAgICAqLwotICAg ICAgICBpZiAobV90ZXh0LmlzRW1wdHkoKSAmJiBtX3dpbmRvd3NWaXJ0dWFsS2V5Q29kZSAmJiBp c1ZpcnR1YWxLZXlDb2RlUmVwcmVzZW50aW5nQ2hhcmFjdGVyKG1fd2luZG93c1ZpcnR1YWxLZXlD b2RlKSkKKyAgICAgICAgaWYgKCFtX2FsbG93TmF0aXZlVmlydHVhbEtleUFzRE9NS2V5ICYmIG1f dGV4dC5pc0VtcHR5KCkgJiYgbV93aW5kb3dzVmlydHVhbEtleUNvZGUgJiYgaXNWaXJ0dWFsS2V5 Q29kZVJlcHJlc2VudGluZ0NoYXJhY3RlcihtX3dpbmRvd3NWaXJ0dWFsS2V5Q29kZSkpCiAgICAg ICAgICAgICBtX3RleHQuYXBwZW5kKFVDaGFyKG1fd2luZG93c1ZpcnR1YWxLZXlDb2RlKSk7CiAK ICAgICAgICAgbV9rZXlJZGVudGlmaWVyID0gU3RyaW5nKCk7CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0L3F0L0FwaS9xd2Vic2V0dGluZ3MuY3BwIGIvU291cmNlL1dlYktpdC9xdC9BcGkvcXdl YnNldHRpbmdzLmNwcAppbmRleCA3MzQ0YmFlNTk3MGFkNDFjZDAyMzdlZTFkYjY4MTRiMTJmNTZh YzBhLi4xN2EyMmM4NTBhNTEzMjhkNTY5N2MyODM0ODdmYTJmZTIyNjVhNzhjIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViS2l0L3F0L0FwaS9xd2Vic2V0dGluZ3MuY3BwCisrKyBiL1NvdXJjZS9XZWJL aXQvcXQvQXBpL3F3ZWJzZXR0aW5ncy5jcHAKQEAgLTI5Nyw2ICsyOTcsOSBAQCB2b2lkIFFXZWJT ZXR0aW5nc1ByaXZhdGU6OmFwcGx5KCkKICAgICAgICAgc2V0dGluZ3MtPnNldE5lZWRzU2l0ZVNw ZWNpZmljUXVpcmtzKHZhbHVlKTsKIAogICAgICAgICBzZXR0aW5ncy0+c2V0VXNlc1BhZ2VDYWNo ZShXZWJDb3JlOjpwYWdlQ2FjaGUoKS0+Y2FwYWNpdHkoKSk7CisKKyAgICAgICAgYXR0cmlidXRl cy52YWx1ZShRV2ViU2V0dGluZ3M6OlVzZU5hdGl2ZVZpcnR1YWxLZXlBc0RPTUtleSwKKyAgICAg ICAgICAgIGdsb2JhbC0+YXR0cmlidXRlcy52YWx1ZShRV2ViU2V0dGluZ3M6OlVzZU5hdGl2ZVZp cnR1YWxLZXlBc0RPTUtleSkpOwogICAgIH0gZWxzZSB7CiAgICAgICAgIFFMaXN0PFFXZWJTZXR0 aW5nc1ByaXZhdGUqPiBzZXR0aW5ncyA9ICo6OmFsbFNldHRpbmdzKCk7CiAgICAgICAgIGZvciAo aW50IGkgPSAwOyBpIDwgc2V0dGluZ3MuY291bnQoKTsgKytpKQpAQCAtNTA4LDYgKzUxMSw5IEBA IFFXZWJTZXR0aW5ncyogUVdlYlNldHRpbmdzOjpnbG9iYWxTZXR0aW5ncygpCiAgICAgXHZhbHVl IENhcmV0QnJvd3NpbmdFbmFibGVkIFRoaXMgc2V0dGluZyBlbmFibGVzIGNhcmV0IGJyb3dzaW5n LiBJdCBpcyBkaXNhYmxlZCBieSBkZWZhdWx0LgogICAgIFx2YWx1ZSBOb3RpZmljYXRpb25zRW5h YmxlZCBTcGVjaWZpZXMgd2hldGhlciBzdXBwb3J0IGZvciB0aGUgSFRNTCA1IHdlYiBub3RpZmlj YXRpb25zIGlzIGVuYWJsZWQKICAgICAgICAgb3Igbm90LiBUaGlzIGlzIGVuYWJsZWQgYnkgZGVm YXVsdC4KKyAgICBcdmFsdWUgVXNlTmF0aXZlVmlydHVhbEtleUFzRE9NS2V5IFNwZWNpZmllcyB3 aGV0aGVyIHRvIHVzZSBRS2V5RXZlbnQ6Om5hdGl2ZVZpcnR1YWxLZXkgYXMKKyAgICAgICAgdGhl IERPTSBLZXlib2FyZEV2ZW50IGtleUNvZGUgdmFsdWUgaW5zdGVhZCBvZiBXaW5kb3dzIHZpcnR1 YWwga2V5IGNvZGVzLgorICAgICAgICBUaGlzIGNhbiBiZSB1c2VkIHRvIHNlbmQgZG9tYWluIHNw ZWNpZmljIGtleSB2YWx1ZXMgdG8gYSBXZWIgQXBwbGljYXRpb24uIFRoaXMgaXMgZGlzYWJsZWQg YnkgZGVmYXVsdC4KICovCiAKIC8qIQpAQCAtNTY0LDYgKzU3MCw3IEBAIFFXZWJTZXR0aW5nczo6 UVdlYlNldHRpbmdzKCkKICAgICBkLT5hdHRyaWJ1dGVzLmluc2VydChRV2ViU2V0dGluZ3M6OlNj cm9sbEFuaW1hdG9yRW5hYmxlZCwgZmFsc2UpOwogICAgIGQtPmF0dHJpYnV0ZXMuaW5zZXJ0KFFX ZWJTZXR0aW5nczo6Q2FyZXRCcm93c2luZ0VuYWJsZWQsIGZhbHNlKTsKICAgICBkLT5hdHRyaWJ1 dGVzLmluc2VydChRV2ViU2V0dGluZ3M6Ok5vdGlmaWNhdGlvbnNFbmFibGVkLCB0cnVlKTsKKyAg ICBkLT5hdHRyaWJ1dGVzLmluc2VydChRV2ViU2V0dGluZ3M6OlVzZU5hdGl2ZVZpcnR1YWxLZXlB c0RPTUtleSwgZmFsc2UpOwogICAgIGQtPm9mZmxpbmVTdG9yYWdlRGVmYXVsdFF1b3RhID0gNSAq IDEwMjQgKiAxMDI0OwogICAgIGQtPmRlZmF1bHRUZXh0RW5jb2RpbmcgPSBRTGF0aW4xU3RyaW5n KCJpc28tODg1OS0xIik7CiAgICAgZC0+dGhpcmRQYXJ0eUNvb2tpZVBvbGljeSA9IEFsd2F5c0Fs bG93VGhpcmRQYXJ0eUNvb2tpZXM7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L3F0L0FwaS9x d2Vic2V0dGluZ3MuaCBiL1NvdXJjZS9XZWJLaXQvcXQvQXBpL3F3ZWJzZXR0aW5ncy5oCmluZGV4 IDYxZmY5MzBjODBjNzg0YjAxMmQzMjUzY2JkNjE4OWMxM2Q4ZmI1YmYuLjlhZjQ1Y2U0MWM5Mjdm NDQwYjMzZmMyMDM1NjNjOTQyODJjNTY3Y2MgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvcXQv QXBpL3F3ZWJzZXR0aW5ncy5oCisrKyBiL1NvdXJjZS9XZWJLaXQvcXQvQXBpL3F3ZWJzZXR0aW5n cy5oCkBAIC04Niw3ICs4Niw4IEBAIHB1YmxpYzoKICAgICAgICAgU2Nyb2xsQW5pbWF0b3JFbmFi bGVkLAogICAgICAgICBDYXJldEJyb3dzaW5nRW5hYmxlZCwKICAgICAgICAgTm90aWZpY2F0aW9u c0VuYWJsZWQsCi0gICAgICAgIFdlYkF1ZGlvRW5hYmxlZAorICAgICAgICBXZWJBdWRpb0VuYWJs ZWQsCisgICAgICAgIFVzZU5hdGl2ZVZpcnR1YWxLZXlBc0RPTUtleQogICAgIH07CiAgICAgZW51 bSBXZWJHcmFwaGljIHsKICAgICAgICAgTWlzc2luZ0ltYWdlR3JhcGhpYywKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvUVdlYlBhZ2VBZGFwdGVyLmNwcCBiL1Nv dXJjZS9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvUVdlYlBhZ2VBZGFwdGVyLmNwcAppbmRleCAy MTBlYTQxZjNmNDY5YzNmOTYzNDM5N2YyMGFlN2ViMjkwYmI0Y2M0Li4yMDg2Y2IzNWIwNDdiMzhm YjNkYzMxZTdkOWFhMzNhZmEzNjU4NjJjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L3F0L1dl YkNvcmVTdXBwb3J0L1FXZWJQYWdlQWRhcHRlci5jcHAKKysrIGIvU291cmNlL1dlYktpdC9xdC9X ZWJDb3JlU3VwcG9ydC9RV2ViUGFnZUFkYXB0ZXIuY3BwCkBAIC0xMjQxLDcgKzEyNDEsNyBAQCBR V2ViUGFnZUFkYXB0ZXI6OlZpZXdwb3J0QXR0cmlidXRlcyBRV2ViUGFnZUFkYXB0ZXI6OnZpZXdw b3J0QXR0cmlidXRlc0ZvclNpemUoYwogYm9vbCBRV2ViUGFnZUFkYXB0ZXI6OmhhbmRsZUtleUV2 ZW50KFFLZXlFdmVudCAqZXYpCiB7CiAgICAgRnJhbWUqIGZyYW1lID0gcGFnZS0+Zm9jdXNDb250 cm9sbGVyKCktPmZvY3VzZWRPck1haW5GcmFtZSgpOwotICAgIHJldHVybiBmcmFtZS0+ZXZlbnRI YW5kbGVyKCktPmtleUV2ZW50KGV2KTsKKyAgICByZXR1cm4gZnJhbWUtPmV2ZW50SGFuZGxlcigp LT5rZXlFdmVudChQbGF0Zm9ybUtleWJvYXJkRXZlbnQoZXYsIHNldHRpbmdzLT50ZXN0QXR0cmli dXRlKFFXZWJTZXR0aW5nczo6VXNlTmF0aXZlVmlydHVhbEtleUFzRE9NS2V5KSkpOwogfQogCiBi b29sIFFXZWJQYWdlQWRhcHRlcjo6aGFuZGxlU2Nyb2xsaW5nKFFLZXlFdmVudCAqZXYpCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0L3F0L3Rlc3RzL3F3ZWJ2aWV3L3RzdF9xd2Vidmlldy5jcHAg Yi9Tb3VyY2UvV2ViS2l0L3F0L3Rlc3RzL3F3ZWJ2aWV3L3RzdF9xd2Vidmlldy5jcHAKaW5kZXgg YTk5MGFkMGYyNGYzNTY4NWUyY2NjNjBkZjE2NmRlYTcwOWUwNDY3YS4uZmZjMmM5YzQ3OWM3NzMx N2ZiMzJkNTAyMDAyNjBlMGIzNjFlYmMzMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9xdC90 ZXN0cy9xd2Vidmlldy90c3RfcXdlYnZpZXcuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvcXQvdGVz dHMvcXdlYnZpZXcvdHN0X3F3ZWJ2aWV3LmNwcApAQCAtNTEsNiArNTEsNyBAQCBwcml2YXRlIFFf U0xPVFM6CiAgICAgdm9pZCByZXVzZVBhZ2VfZGF0YSgpOwogICAgIHZvaWQgcmV1c2VQYWdlKCk7 CiAgICAgdm9pZCBtaWNyb0ZvY3VzQ29vcmRpbmF0ZXMoKTsKKyAgICB2b2lkIGRvbWFpblNwZWNp ZmljS2V5RXZlbnQoKTsKICAgICB2b2lkIGZvY3VzSW5wdXRUeXBlcygpOwogICAgIHZvaWQgaG9y aXpvbnRhbFNjcm9sbGJhclRlc3QoKTsKIApAQCAtMjMwLDYgKzIzMSw1OCBAQCB2b2lkIHRzdF9R V2ViVmlldzo6bWljcm9Gb2N1c0Nvb3JkaW5hdGVzKCkKICAgICBRQ09NUEFSRShpbml0aWFsTWlj cm9Gb2N1cy50b1JlY3QoKS50cmFuc2xhdGVkKFFQb2ludCgwLC01MCkpLCBjdXJyZW50TWljcm9G b2N1cy50b1JlY3QoKSk7CiB9CiAKK3ZvaWQgdHN0X1FXZWJWaWV3Ojpkb21haW5TcGVjaWZpY0tl eUV2ZW50KCkKK3sKKyAgICBRV2ViVmlldyB3ZWJWaWV3OworICAgIHdlYlZpZXcuc2hvdygpOwor ICAgIFFUZXN0OjpxV2FpdEZvcldpbmRvd0V4cG9zZWQoJndlYlZpZXcpOworCisgICAgd2ViVmll dy5zZXRIdG1sKFFMYXRpbjFTdHJpbmcoIjxodG1sPjxoZWFkPiIKKyAgICAgICAgIjxzY3JpcHQ+ IgorICAgICAgICAidmFyIHJlY2VpdmVkS2V5QXJyYXkgPSBuZXcgQXJyYXkoKTsiCisgICAgICAg ICJmdW5jdGlvbiBrZXlFdmVudChlKSB7IgorICAgICAgICAicmVjZWl2ZWRLZXlBcnJheS5wdXNo KGUudHlwZSsnOicrZS5rZXlDb2RlKyc6JytlLmNoYXJDb2RlKTsiCisgICAgICAgICJ9OyIKKyAg ICAgICAgIndpbmRvdy5vbmtleXVwID0ga2V5RXZlbnQ7IHdpbmRvdy5vbmtleXByZXNzID0ga2V5 RXZlbnQ7IHdpbmRvdy5vbmtleWRvd24gPSBrZXlFdmVudDsiCisgICAgICAgICI8L3NjcmlwdD48 L2hlYWQ+PGJvZHk+dGVzdDwvYm9keT48L2h0bWw+IikpOworCisgICAgLy8gRW5hYmxlIHNldHRp bmdzIHRvIHVzZSBuYXRpdmVWaXJ0dWFsS2V5IGFzIERPTSBrZXkgdmFsdWUuCisgICAgd2ViVmll dy5zZXR0aW5ncygpLT5zZXRBdHRyaWJ1dGUoUVdlYlNldHRpbmdzOjpVc2VOYXRpdmVWaXJ0dWFs S2V5QXNET01LZXksIHRydWUpOworICAgIC8vIFNpbXVsYXRlIGRvbWFpbiBzcGVjaWZpYyBrZXll dmVudCB0byBXZWJLaXQgYnkgcGFzc2luZyBpdCBhcyBuYXRpdmVWaXJ0dWFsS2V5IGluIFFLZXlF dmVudC4KKyAgICAvLyBRdDo6S2V5X1BhdXNlIC0tPiAweDUxCisgICAgUUtleUV2ZW50IGtleUV2 ZW50KFFFdmVudDo6S2V5UHJlc3MsIFF0OjpLZXlfUGF1c2UsIFF0OjpOb01vZGlmaWVyLCAwLCA4 MSwgMCk7CisgICAgUUFwcGxpY2F0aW9uOjpzZW5kRXZlbnQoJndlYlZpZXcsICZrZXlFdmVudCk7 CisgICAga2V5RXZlbnQgPSBRS2V5RXZlbnQoUUV2ZW50OjpLZXlSZWxlYXNlLCBRdDo6S2V5X1Bh dXNlLCBRdDo6Tm9Nb2RpZmllciwgMCwgODEsIDApOworICAgIFFBcHBsaWNhdGlvbjo6c2VuZEV2 ZW50KCZ3ZWJWaWV3LCAma2V5RXZlbnQpOworICAgIGNvbnN0IFFMYXRpbjFTdHJpbmcgZXhwZWN0 ZWRSZWNlaXZlZEtleUFycmF5MSgia2V5ZG93bjo4MTowLGtleXVwOjgxOjAiKTsKKyAgICBRU3Ry aW5nIHJlY2VpdmVkS2V5QXJyYXkgPSB3ZWJWaWV3LnBhZ2UoKS0+bWFpbkZyYW1lKCktPmV2YWx1 YXRlSmF2YVNjcmlwdChRTGF0aW4xU3RyaW5nKCJyZWNlaXZlZEtleUFycmF5IikpLnRvU3RyaW5n TGlzdCgpLmpvaW4oIiwiKTsKKyAgICBRVkVSSUZZKHJlY2VpdmVkS2V5QXJyYXkgPT0gZXhwZWN0 ZWRSZWNlaXZlZEtleUFycmF5MSk7CisKKyAgICAvLyBOb3JtYWwgUEMga2V5Ym9hcmQga2V5IGNv bnZlcnN0aW9uIGZsb3cgc2hvdWxkbid0IGJlIGFmZmVjdGVkIHdoZW4gc2VuZGluZyBuYXRpdmVW aXJ0dWFsIGtleSBhcyAwLgorICAgIC8vIFF0OjpLZXlfUGF1c2UgLS0+IFZLX1BBVVNFKDB4MTMp CisgICAgd2ViVmlldy5wYWdlKCktPm1haW5GcmFtZSgpLT5ldmFsdWF0ZUphdmFTY3JpcHQoUUxh dGluMVN0cmluZygicmVjZWl2ZWRLZXlBcnJheSA9IG5ldyBBcnJheSgpIikpOyAvLyBSZXNldAor ICAgIGtleUV2ZW50ID0gUUtleUV2ZW50KFFFdmVudDo6S2V5UHJlc3MsIFF0OjpLZXlfUGF1c2Us IFF0OjpOb01vZGlmaWVyLCAwLCAwLCAwKTsKKyAgICBRQXBwbGljYXRpb246OnNlbmRFdmVudCgm d2ViVmlldywgJmtleUV2ZW50KTsKKyAgICBrZXlFdmVudCA9IFFLZXlFdmVudChRRXZlbnQ6Oktl eVJlbGVhc2UsIFF0OjpLZXlfUGF1c2UsIFF0OjpOb01vZGlmaWVyLCAwLCAwLCAwKTsKKyAgICBR QXBwbGljYXRpb246OnNlbmRFdmVudCgmd2ViVmlldywgJmtleUV2ZW50KTsKKyAgICBjb25zdCBR TGF0aW4xU3RyaW5nIGV4cGVjdGVkUmVjZWl2ZWRLZXlBcnJheTIoImtleWRvd246MTk6MCxrZXl1 cDoxOTowIik7CisgICAgcmVjZWl2ZWRLZXlBcnJheSA9IHdlYlZpZXcucGFnZSgpLT5tYWluRnJh bWUoKS0+ZXZhbHVhdGVKYXZhU2NyaXB0KFFMYXRpbjFTdHJpbmcoInJlY2VpdmVkS2V5QXJyYXki KSkudG9TdHJpbmdMaXN0KCkuam9pbigiLCIpOworICAgIFFWRVJJRlkocmVjZWl2ZWRLZXlBcnJh eSA9PSBleHBlY3RlZFJlY2VpdmVkS2V5QXJyYXkyKTsKKworICAgIC8vIE5lZ2F0aXZlIGNhc2Uu CisgICAgLy8gRGlzYWJsZSBzZXR0aW5ncyB0byB1c2UgbmF0aXZlVmlydHVhbEtleSBhcyBET00g a2V5IHZhbHVlLgorICAgIC8vIFF0OjpLZXlfUGF1c2UgLS0+IFZLX1BBVVNFKDB4MTMpCisgICAg d2ViVmlldy5wYWdlKCktPm1haW5GcmFtZSgpLT5ldmFsdWF0ZUphdmFTY3JpcHQoUUxhdGluMVN0 cmluZygicmVjZWl2ZWRLZXlBcnJheSA9IG5ldyBBcnJheSgpIikpOyAvLyBSZXNldAorICAgIHdl YlZpZXcuc2V0dGluZ3MoKS0+c2V0QXR0cmlidXRlKFFXZWJTZXR0aW5nczo6VXNlTmF0aXZlVmly dHVhbEtleUFzRE9NS2V5LCBmYWxzZSk7CisgICAga2V5RXZlbnQgPSBRS2V5RXZlbnQoUUV2ZW50 OjpLZXlQcmVzcywgUXQ6OktleV9QYXVzZSwgUXQ6Ok5vTW9kaWZpZXIsIDAsIDgxLCAwKTsKKyAg ICBRQXBwbGljYXRpb246OnNlbmRFdmVudCgmd2ViVmlldywgJmtleUV2ZW50KTsKKyAgICBrZXlF dmVudCA9IFFLZXlFdmVudChRRXZlbnQ6OktleVJlbGVhc2UsIFF0OjpLZXlfUGF1c2UsIFF0OjpO b01vZGlmaWVyLCAwLCA4MSwgMCk7CisgICAgUUFwcGxpY2F0aW9uOjpzZW5kRXZlbnQoJndlYlZp ZXcsICZrZXlFdmVudCk7CisgICAgY29uc3QgUUxhdGluMVN0cmluZyBleHBlY3RlZFJlY2VpdmVk S2V5QXJyYXkzKCJrZXlkb3duOjE5OjAsa2V5dXA6MTk6MCIpOworICAgIHJlY2VpdmVkS2V5QXJy YXkgPSB3ZWJWaWV3LnBhZ2UoKS0+bWFpbkZyYW1lKCktPmV2YWx1YXRlSmF2YVNjcmlwdChRTGF0 aW4xU3RyaW5nKCJyZWNlaXZlZEtleUFycmF5IikpLnRvU3RyaW5nTGlzdCgpLmpvaW4oIiwiKTsK KyAgICBRVkVSSUZZKHJlY2VpdmVkS2V5QXJyYXkgPT0gZXhwZWN0ZWRSZWNlaXZlZEtleUFycmF5 Myk7Cit9CisKIHZvaWQgdHN0X1FXZWJWaWV3Ojpmb2N1c0lucHV0VHlwZXMoKQogewogICAgIFFX ZWJWaWV3IHdlYlZpZXc7Cg== 208401 2013-08-09 00:31:26 -0700 2013-08-09 05:10:08 -0700 Patch bug-118445-20130809130109.patch text/plain 11715 arurajku U3VidmVyc2lvbiBSZXZpc2lvbjogMTUyOTQ5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMDkyNGY2ZWRkMDNkYjc3 ZDU4M2I0NmQ5MGRhYjM5ZTdkZDY3MWY4My4uMDZjZTNmNzE2MTdlYjY4YmI5ZDBjY2JjMTdhYzlk ZmM4NGY3Y2M5NSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIyIEBACisyMDEzLTA4LTA5ICBBcnVu cHJhc2FkIFJhamt1bWFyICA8YXJ1cmFqa3VAY2lzY28uY29tPgorCisgICAgICAgIFtRdF0gUXRX ZWJLaXQgc2hvdWxkIGFsbG93IHNlbmRpbmcgZG9tYWluIHNwZWNpZmljIGtleWNvZGUgdG8gSFRN TCBhcHBsaWNhdGlvbnMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTExODQ0NQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIE5vIG5ldyB0ZXN0IHJlcXVpcmVkLCBpdCBpcyBjb3ZlcmVkIGJ5IFF0V2ViS2l0IEFQ SSB0ZXN0LgorCisgICAgICAgIFRoaXMgZml4IGFsbG93cyBzZW5kaW5nIFFLZXlFdmVudDo6bmF0 aXZlVmlydHVhbEtleSBhcyB0aGUgRE9NIEtleWJvYXJkRXZlbnQga2V5Q29kZSB2YWx1ZSBpbnN0 ZWFkCisgICAgICAgIG9mIFdpbmRvd3MgdmlydHVhbCBrZXkgY29kZS4gSXQgY2FuIGJlIGVuYWJs ZWQvZGlzYWJsZWQgdXNpbmcgIl9xX3VzZU5hdGl2ZVZpcnR1YWxLZXlBc0RPTUtleSIKKyAgICAg ICAgZHluYW1pYyBwcm9wZXJ0eSBwcmVzZW50IGluIFFXZWJQYWdlLgorCisgICAgICAgICogcGxh dGZvcm0vUGxhdGZvcm1LZXlib2FyZEV2ZW50Lmg6CisgICAgICAgIChXZWJDb3JlOjpQbGF0Zm9y bUtleWJvYXJkRXZlbnQ6OlBsYXRmb3JtS2V5Ym9hcmRFdmVudCk6CisgICAgICAgICogcGxhdGZv cm0vcXQvUGxhdGZvcm1LZXlib2FyZEV2ZW50UXQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UGxh dGZvcm1LZXlib2FyZEV2ZW50OjpQbGF0Zm9ybUtleWJvYXJkRXZlbnQpOgorICAgICAgICAoV2Vi Q29yZTo6UGxhdGZvcm1LZXlib2FyZEV2ZW50OjpkaXNhbWJpZ3VhdGVLZXlEb3duRXZlbnQpOgor CiAyMDEzLTA3LTIwICBCZW5qYW1pbiBQb3VsYWluICA8YmVuamFtaW5Ad2Via2l0Lm9yZz4KIAog ICAgICAgICBBZGQgQVNDSUlMaXRlcmFsKCkgb24gc3RyaW5ncyBhbGxvY2F0ZWQgb2Z0ZW4gZW5v dWdoIHRvIGFwcGVhciBpbiBteSBJbnN0cnVtZW50cwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dC9xdC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L3F0L0NoYW5nZUxvZwppbmRleCAyMjNjMTFh ZGMyNjFhOGVmZTEwMDZiNjM0NTRlZmE5MGFmMDU0Njc2Li40MjU2NTIwZWY2OTkzZmY2NzlkYWYz M2NkNmFjNGIyNWNjOTMyYjRlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L3F0L0NoYW5nZUxv ZworKysgYi9Tb3VyY2UvV2ViS2l0L3F0L0NoYW5nZUxvZwpAQCAtMSwzICsxLDIwIEBACisyMDEz LTA4LTA5ICBBcnVucHJhc2FkIFJhamt1bWFyICA8YXJ1cmFqa3VAY2lzY28uY29tPgorCisgICAg ICAgIFtRdF0gUXRXZWJLaXQgc2hvdWxkIGFsbG93IHNlbmRpbmcgZG9tYWluIHNwZWNpZmljIGtl eWNvZGUgdG8gSFRNTCBhcHBsaWNhdGlvbnMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTExODQ0NQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIEFkZGVkIEFQSSB0ZXN0LgorCisgICAgICAgICogV2ViQ29yZVN1 cHBvcnQvUVdlYlBhZ2VBZGFwdGVyLmNwcDoKKyAgICAgICAgKFFXZWJQYWdlQWRhcHRlcjo6UVdl YlBhZ2VBZGFwdGVyKToKKyAgICAgICAgKFFXZWJQYWdlQWRhcHRlcjo6ZHluYW1pY1Byb3BlcnR5 Q2hhbmdlRXZlbnQpOgorICAgICAgICAoUVdlYlBhZ2VBZGFwdGVyOjpoYW5kbGVLZXlFdmVudCk6 CisgICAgICAgICogV2ViQ29yZVN1cHBvcnQvUVdlYlBhZ2VBZGFwdGVyLmg6CisgICAgICAgICog dGVzdHMvcXdlYnBhZ2UvdHN0X3F3ZWJwYWdlLmNwcDoKKyAgICAgICAgKHRzdF9RV2ViUGFnZTo6 ZG9tYWluU3BlY2lmaWNLZXlFdmVudCk6CisKIDIwMTMtMDctMTggIEdhYm9yIEFicmFoYW0gIDxh YnJobUBpbmYudS1zemVnZWQuaHU+CiAKICAgICAgICAgW1F0XVtXSzFdIE1hcmsgZmFpbGluZyBB UEkgdGVzdHMgYXMgWEZBSUwKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Bs YXRmb3JtS2V5Ym9hcmRFdmVudC5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vUGxhdGZvcm1L ZXlib2FyZEV2ZW50LmgKaW5kZXggYWMzMmFlNDAxODQ3ZGJlYWNkMTY5Yjg2NzY2MDM4MDljYzA4 Y2ExZC4uNmE0YTJjMmEzMjgzMzllMDlmNDA0NzA1MzlhOTk3ZDJiYjFiN2VhNCAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vUGxhdGZvcm1LZXlib2FyZEV2ZW50LmgKKysrIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vUGxhdGZvcm1LZXlib2FyZEV2ZW50LmgKQEAgLTgzLDYg KzgzLDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogI2VuZGlmCiAjaWYgUExBVEZPUk0oUVQpCiAg ICAgICAgICAgICAsIG1fcXRFdmVudCgwKQorICAgICAgICAgICAgLCBtX3VzZU5hdGl2ZVZpcnR1 YWxLZXlBc0RPTUtleShmYWxzZSkKICNlbmRpZgogICAgICAgICB7CiAgICAgICAgIH0KQEAgLTE1 Nyw3ICsxNTgsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAjZW5kaWYKIAogI2lmIFBMQVRGT1JN KFFUKQotICAgICAgICBQbGF0Zm9ybUtleWJvYXJkRXZlbnQoUUtleUV2ZW50Kik7CisgICAgICAg IFBsYXRmb3JtS2V5Ym9hcmRFdmVudChRS2V5RXZlbnQqLCBib29sKTsKICAgICAgICAgUUtleUV2 ZW50KiBxdEV2ZW50KCkgY29uc3QgeyByZXR1cm4gbV9xdEV2ZW50OyB9CiAgICAgICAgIHVpbnQz Ml90IG5hdGl2ZU1vZGlmaWVycygpIGNvbnN0OwogICAgICAgICB1aW50MzJfdCBuYXRpdmVTY2Fu Q29kZSgpIGNvbnN0OwpAQCAtMTk2LDYgKzE5Nyw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICNl bmRpZgogI2lmIFBMQVRGT1JNKFFUKQogICAgICAgICBRS2V5RXZlbnQqIG1fcXRFdmVudDsKKyAg ICAgICAgYm9vbCBtX3VzZU5hdGl2ZVZpcnR1YWxLZXlBc0RPTUtleTsKICNlbmRpZgogICAgIH07 CiAgICAgCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9xdC9QbGF0Zm9ybUtl eWJvYXJkRXZlbnRRdC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9xdC9QbGF0Zm9ybUtl eWJvYXJkRXZlbnRRdC5jcHAKaW5kZXggZmM0YjcyNmZkMDg5Y2M2NTViODAxMjg2NmZjMmU0NmM1 MTJiZDM5MC4uYjU3YTFkMTZjNzdkM2E1YjBhOTk1ODJhYzUzY2VhMmJiNjQ3ZWFlYiAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vcXQvUGxhdGZvcm1LZXlib2FyZEV2ZW50UXQu Y3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3F0L1BsYXRmb3JtS2V5Ym9hcmRFdmVu dFF0LmNwcApAQCAtNjEwLDcgKzYxMCw3IEBAIHN0YXRpYyBTdHJpbmcga2V5VGV4dEZvcktleUV2 ZW50KGNvbnN0IFFLZXlFdmVudCogZXZlbnQpCiAgICAgcmV0dXJuIGV2ZW50LT50ZXh0KCk7CiB9 CiAKLVBsYXRmb3JtS2V5Ym9hcmRFdmVudDo6UGxhdGZvcm1LZXlib2FyZEV2ZW50KFFLZXlFdmVu dCogZXZlbnQpCitQbGF0Zm9ybUtleWJvYXJkRXZlbnQ6OlBsYXRmb3JtS2V5Ym9hcmRFdmVudChR S2V5RXZlbnQqIGV2ZW50LCBib29sIHVzZU5hdGl2ZVZpcnR1YWxLZXlBc0RPTUtleSkKIHsKICAg ICBjb25zdCBpbnQgc3RhdGUgPSBldmVudC0+bW9kaWZpZXJzKCk7CiAgICAgbV90eXBlID0gKGV2 ZW50LT50eXBlKCkgPT0gUUV2ZW50OjpLZXlSZWxlYXNlKSA/IFBsYXRmb3JtRXZlbnQ6OktleVVw IDogUGxhdGZvcm1FdmVudDo6S2V5RG93bjsKQEAgLTYyNSwxNCArNjI1LDIyIEBAIFBsYXRmb3Jt S2V5Ym9hcmRFdmVudDo6UGxhdGZvcm1LZXlib2FyZEV2ZW50KFFLZXlFdmVudCogZXZlbnQpCiAg ICAgaWYgKHN0YXRlICYgUXQ6Ok1ldGFNb2RpZmllcikKICAgICAgICAgbV9tb2RpZmllcnMgfD0g TWV0YUtleTsKIAorICAgIG1fdXNlTmF0aXZlVmlydHVhbEtleUFzRE9NS2V5ID0gdXNlTmF0aXZl VmlydHVhbEtleUFzRE9NS2V5OwogICAgIG1fdGV4dCA9IGtleVRleHRGb3JLZXlFdmVudChldmVu dCk7CiAgICAgbV91bm1vZGlmaWVkVGV4dCA9IG1fdGV4dDsgLy8gRklYTUU6IG5vdCBjb3JyZWN0 CiAgICAgbV9rZXlJZGVudGlmaWVyID0ga2V5SWRlbnRpZmllckZvclF0S2V5Q29kZShldmVudC0+ a2V5KCkpOwogICAgIG1fYXV0b1JlcGVhdCA9IGV2ZW50LT5pc0F1dG9SZXBlYXQoKTsKICAgICBt X2lzS2V5cGFkID0gKHN0YXRlICYgUXQ6OktleXBhZE1vZGlmaWVyKTsKICAgICBtX2lzU3lzdGVt S2V5ID0gZmFsc2U7Ci0gICAgbV93aW5kb3dzVmlydHVhbEtleUNvZGUgPSB3aW5kb3dzS2V5Q29k ZUZvcktleUV2ZW50KGV2ZW50LT5rZXkoKSwgbV9pc0tleXBhZCk7CiAgICAgbV9uYXRpdmVWaXJ0 dWFsS2V5Q29kZSA9IGV2ZW50LT5uYXRpdmVWaXJ0dWFsS2V5KCk7CisgICAgLy8gSWYgUUtleUV2 ZW50OjpuYXRpdmVWaXJ0dWFsS2V5KCkgaXMgdmFsaWQgKCE9MCkgYW5kIHVzZU5hdGl2ZVZpcnR1 YWxLZXlBc0RPTUtleSBpcyBzZXQsCisgICAgLy8gdGhlbiBpdCBpcyBhIHNwZWNpYWwgY2FzZSBk ZXNpcmVkIGJ5IFF0V2ViS2l0IGVtYmVkZGVyIHRvIHNlbmQgZG9tYWluIHNwZWNpZmljIGtleXMK KyAgICAvLyB0byBXZWIgQXBwbGljYXRpb25zIGludGVudGVkIGZvciBwbGF0Zm9ybXMgbGlrZSBI YmJUVixDRS1IVE1MLE9JUEYsLi5ldGMuCisgICAgaWYgKHVzZU5hdGl2ZVZpcnR1YWxLZXlBc0RP TUtleSAmJiBtX25hdGl2ZVZpcnR1YWxLZXlDb2RlKQorICAgICAgICBtX3dpbmRvd3NWaXJ0dWFs S2V5Q29kZSA9IG1fbmF0aXZlVmlydHVhbEtleUNvZGU7CisgICAgZWxzZQorICAgICAgICBtX3dp bmRvd3NWaXJ0dWFsS2V5Q29kZSA9IHdpbmRvd3NLZXlDb2RlRm9yS2V5RXZlbnQoZXZlbnQtPmtl eSgpLCBtX2lzS2V5cGFkKTsKKwogICAgIG1fbWFjQ2hhckNvZGUgPSAwOwogICAgIG1fcXRFdmVu dCA9IGV2ZW50OwogICAgIG1fdGltZXN0YW1wID0gV1RGOjpjdXJyZW50VGltZSgpOwpAQCAtNjU0 LDcgKzY2Miw3IEBAIHZvaWQgUGxhdGZvcm1LZXlib2FyZEV2ZW50OjpkaXNhbWJpZ3VhdGVLZXlE b3duRXZlbnQoVHlwZSB0eXBlLCBib29sKQogICAgICAgICAgICAgd2UgdHJ5IHRvIGRldGVjdCB0 aGlzIHNpdHVhdGlvbiBhbmQgc3RpbGwgc2V0IHRoZSB0ZXh0LCB0byBlbnN1cmUgdGhhdCB0aGUK ICAgICAgICAgICAgIGdlbmVyYWwgZXZlbnQgaGFuZGxpbmcgc2VuZHMgYSBrZXkgcHJlc3MgZXZl bnQgYWZ0ZXIgdGhpcyBkaXNhbWJpZ3VhdGlvbi4KICAgICAgICAgKi8KLSAgICAgICAgaWYgKG1f dGV4dC5pc0VtcHR5KCkgJiYgbV93aW5kb3dzVmlydHVhbEtleUNvZGUgJiYgaXNWaXJ0dWFsS2V5 Q29kZVJlcHJlc2VudGluZ0NoYXJhY3RlcihtX3dpbmRvd3NWaXJ0dWFsS2V5Q29kZSkpCisgICAg ICAgIGlmICghbV91c2VOYXRpdmVWaXJ0dWFsS2V5QXNET01LZXkgJiYgbV90ZXh0LmlzRW1wdHko KSAmJiBtX3dpbmRvd3NWaXJ0dWFsS2V5Q29kZSAmJiBpc1ZpcnR1YWxLZXlDb2RlUmVwcmVzZW50 aW5nQ2hhcmFjdGVyKG1fd2luZG93c1ZpcnR1YWxLZXlDb2RlKSkKICAgICAgICAgICAgIG1fdGV4 dC5hcHBlbmQoVUNoYXIobV93aW5kb3dzVmlydHVhbEtleUNvZGUpKTsKIAogICAgICAgICBtX2tl eUlkZW50aWZpZXIgPSBTdHJpbmcoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvcXQvV2Vi Q29yZVN1cHBvcnQvUVdlYlBhZ2VBZGFwdGVyLmNwcCBiL1NvdXJjZS9XZWJLaXQvcXQvV2ViQ29y ZVN1cHBvcnQvUVdlYlBhZ2VBZGFwdGVyLmNwcAppbmRleCAyMTBlYTQxZjNmNDY5YzNmOTYzNDM5 N2YyMGFlN2ViMjkwYmI0Y2M0Li44M2FhMjRlNGYyYzNmODliOGUzOTJiMTAyNDk3ZjhmNzA0YmZj M2JhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L1FXZWJQYWdl QWRhcHRlci5jcHAKKysrIGIvU291cmNlL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9RV2ViUGFn ZUFkYXB0ZXIuY3BwCkBAIC0xNzUsNiArMTc1LDcgQEAgUVdlYlBhZ2VBZGFwdGVyOjpRV2ViUGFn ZUFkYXB0ZXIoKQogICAgICwgZm9yd2FyZFVuc3VwcG9ydGVkQ29udGVudChmYWxzZSkKICAgICAs IGluc2lkZU9wZW5DYWxsKGZhbHNlKQogICAgICwgY2xpY2tDYXVzZWRGb2N1cyhmYWxzZSkKKyAg ICAsIG1fdXNlTmF0aXZlVmlydHVhbEtleUFzRE9NS2V5KGZhbHNlKQogICAgICwgbV90b3RhbEJ5 dGVzKDApCiAgICAgLCBtX2J5dGVzUmVjZWl2ZWQoKQogICAgICwgbmV0d29ya01hbmFnZXIoMCkK QEAgLTc4NCw2ICs3ODUsOCBAQCB2b2lkIFFXZWJQYWdlQWRhcHRlcjo6ZHluYW1pY1Byb3BlcnR5 Q2hhbmdlRXZlbnQoUU9iamVjdCogb2JqLCBRRHluYW1pY1Byb3BlcnR5QwogICAgIH0gZWxzZSBp ZiAoZXZlbnQtPnByb3BlcnR5TmFtZSgpID09ICJfcV9kZWFkRGVjb2RlZERhdGFEZWxldGlvbklu dGVydmFsIikgewogICAgICAgICBkb3VibGUgaW50ZXJ2YWwgPSBvYmotPnByb3BlcnR5KCJfcV9k ZWFkRGVjb2RlZERhdGFEZWxldGlvbkludGVydmFsIikudG9Eb3VibGUoKTsKICAgICAgICAgbWVt b3J5Q2FjaGUoKS0+c2V0RGVhZERlY29kZWREYXRhRGVsZXRpb25JbnRlcnZhbChpbnRlcnZhbCk7 CisgICAgfSAgZWxzZSBpZiAoZXZlbnQtPnByb3BlcnR5TmFtZSgpID09ICJfcV91c2VOYXRpdmVW aXJ0dWFsS2V5QXNET01LZXkiKSB7CisgICAgICAgIG1fdXNlTmF0aXZlVmlydHVhbEtleUFzRE9N S2V5ID0gb2JqLT5wcm9wZXJ0eSgiX3FfdXNlTmF0aXZlVmlydHVhbEtleUFzRE9NS2V5IikudG9C b29sKCk7CiAgICAgfQogfQogCkBAIC0xMjQxLDcgKzEyNDQsNyBAQCBRV2ViUGFnZUFkYXB0ZXI6 OlZpZXdwb3J0QXR0cmlidXRlcyBRV2ViUGFnZUFkYXB0ZXI6OnZpZXdwb3J0QXR0cmlidXRlc0Zv clNpemUoYwogYm9vbCBRV2ViUGFnZUFkYXB0ZXI6OmhhbmRsZUtleUV2ZW50KFFLZXlFdmVudCAq ZXYpCiB7CiAgICAgRnJhbWUqIGZyYW1lID0gcGFnZS0+Zm9jdXNDb250cm9sbGVyKCktPmZvY3Vz ZWRPck1haW5GcmFtZSgpOwotICAgIHJldHVybiBmcmFtZS0+ZXZlbnRIYW5kbGVyKCktPmtleUV2 ZW50KGV2KTsKKyAgICByZXR1cm4gZnJhbWUtPmV2ZW50SGFuZGxlcigpLT5rZXlFdmVudChQbGF0 Zm9ybUtleWJvYXJkRXZlbnQoZXYsIG1fdXNlTmF0aXZlVmlydHVhbEtleUFzRE9NS2V5KSk7CiB9 CiAKIGJvb2wgUVdlYlBhZ2VBZGFwdGVyOjpoYW5kbGVTY3JvbGxpbmcoUUtleUV2ZW50ICpldikK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvUVdlYlBhZ2VBZGFw dGVyLmggYi9Tb3VyY2UvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L1FXZWJQYWdlQWRhcHRlci5o CmluZGV4IDk5NzRkMWU0ZDgwMmUyMzFiZGZiMWE5NTlkM2RjODZkNzMwM2ZiYjMuLjU1Mzk2ZDA1 NDlhMjM0MzhlZGYzNDM1OGYyMzI5YmQ1YWNlNjhlNDIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJL aXQvcXQvV2ViQ29yZVN1cHBvcnQvUVdlYlBhZ2VBZGFwdGVyLmgKKysrIGIvU291cmNlL1dlYktp dC9xdC9XZWJDb3JlU3VwcG9ydC9RV2ViUGFnZUFkYXB0ZXIuaApAQCAtMzQ4LDYgKzM0OCw3IEBA IHB1YmxpYzoKICAgICBRQmFzaWNUaW1lciB0cmlwbGVDbGlja1RpbWVyOwogCiAgICAgYm9vbCBj bGlja0NhdXNlZEZvY3VzOworICAgIGJvb2wgbV91c2VOYXRpdmVWaXJ0dWFsS2V5QXNET01LZXk7 CiAgICAgcXVpbnQ2NCBtX3RvdGFsQnl0ZXM7CiAgICAgcXVpbnQ2NCBtX2J5dGVzUmVjZWl2ZWQ7 CiAgICAgUVdlYkhpc3RvcnkgaGlzdG9yeTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvcXQv dGVzdHMvcXdlYnBhZ2UvdHN0X3F3ZWJwYWdlLmNwcCBiL1NvdXJjZS9XZWJLaXQvcXQvdGVzdHMv cXdlYnBhZ2UvdHN0X3F3ZWJwYWdlLmNwcAppbmRleCA4ZWI3NGE3MzY0Y2M5NTRlY2JiODZkNTEw M2ZlYzI1Yzg3NjcyNDUxLi44NmE4MTBmYzQxOGQ3NGRjNWEyNWVjZmEwMjI4MTViZTdlY2I3NWJl IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L3F0L3Rlc3RzL3F3ZWJwYWdlL3RzdF9xd2VicGFn ZS5jcHAKKysrIGIvU291cmNlL1dlYktpdC9xdC90ZXN0cy9xd2VicGFnZS90c3RfcXdlYnBhZ2Uu Y3BwCkBAIC0xMTQsNiArMTE0LDcgQEAgcHJpdmF0ZSBRX1NMT1RTOgogICAgIHZvaWQgY29udGV4 dE1lbnVDb3B5KCk7CiAgICAgdm9pZCBjb250ZXh0TWVudVBvcHVsYXRlZE9uY2UoKTsKICAgICB2 b2lkIGFjY2VwdE5hdmlnYXRpb25SZXF1ZXN0KCk7CisgICAgdm9pZCBkb21haW5TcGVjaWZpY0tl eUV2ZW50KCk7CiAgICAgdm9pZCBnZW9sb2NhdGlvblJlcXVlc3RKUygpOwogICAgIHZvaWQgbG9h ZEZpbmlzaGVkKCk7CiAgICAgdm9pZCBhY3Rpb25TdGF0ZXMoKTsKQEAgLTI4MSw2ICsyODIsNTgg QEAgdm9pZCB0c3RfUVdlYlBhZ2U6OmFjY2VwdE5hdmlnYXRpb25SZXF1ZXN0KCkKICAgICBtX3Zp ZXctPnNldFBhZ2UoMCk7CiB9CiAKK3ZvaWQgdHN0X1FXZWJQYWdlOjpkb21haW5TcGVjaWZpY0tl eUV2ZW50KCkKK3sKKyAgICBRV2ViVmlldyB3ZWJWaWV3OworICAgIHdlYlZpZXcuc2hvdygpOwor ICAgIFFUZXN0OjpxV2FpdEZvcldpbmRvd0V4cG9zZWQoJndlYlZpZXcpOworCisgICAgd2ViVmll dy5zZXRIdG1sKFFMYXRpbjFTdHJpbmcoIjxodG1sPjxoZWFkPiIKKyAgICAgICAgIjxzY3JpcHQ+ IgorICAgICAgICAidmFyIHJlY2VpdmVkS2V5QXJyYXkgPSBuZXcgQXJyYXkoKTsiCisgICAgICAg ICJmdW5jdGlvbiBrZXlFdmVudChlKSB7IgorICAgICAgICAicmVjZWl2ZWRLZXlBcnJheS5wdXNo KGUudHlwZSsnOicrZS5rZXlDb2RlKyc6JytlLmNoYXJDb2RlKTsiCisgICAgICAgICJ9OyIKKyAg ICAgICAgIndpbmRvdy5vbmtleXVwID0ga2V5RXZlbnQ7IHdpbmRvdy5vbmtleXByZXNzID0ga2V5 RXZlbnQ7IHdpbmRvdy5vbmtleWRvd24gPSBrZXlFdmVudDsiCisgICAgICAgICI8L3NjcmlwdD48 L2hlYWQ+PGJvZHk+dGVzdDwvYm9keT48L2h0bWw+IikpOworCisgICAgLy8gRW5hYmxlIHNldHRp bmdzIHRvIHVzZSBuYXRpdmVWaXJ0dWFsS2V5IGFzIERPTSBrZXkgdmFsdWUuCisgICAgd2ViVmll dy5wYWdlKCktPnNldFByb3BlcnR5KCJfcV91c2VOYXRpdmVWaXJ0dWFsS2V5QXNET01LZXkiLCB0 cnVlKTsKKyAgICAvLyBTaW11bGF0ZSBkb21haW4gc3BlY2lmaWMga2V5ZXZlbnQgdG8gV2ViS2l0 IGJ5IHBhc3NpbmcgaXQgYXMgbmF0aXZlVmlydHVhbEtleSBpbiBRS2V5RXZlbnQuCisgICAgLy8g UXQ6OktleV9QYXVzZSAtLT4gMHg1MQorICAgIFFLZXlFdmVudCBrZXlFdmVudChRRXZlbnQ6Oktl eVByZXNzLCBRdDo6S2V5X1BhdXNlLCBRdDo6Tm9Nb2RpZmllciwgMCwgODEsIDApOworICAgIFFB cHBsaWNhdGlvbjo6c2VuZEV2ZW50KCZ3ZWJWaWV3LCAma2V5RXZlbnQpOworICAgIGtleUV2ZW50 ID0gUUtleUV2ZW50KFFFdmVudDo6S2V5UmVsZWFzZSwgUXQ6OktleV9QYXVzZSwgUXQ6Ok5vTW9k aWZpZXIsIDAsIDgxLCAwKTsKKyAgICBRQXBwbGljYXRpb246OnNlbmRFdmVudCgmd2ViVmlldywg JmtleUV2ZW50KTsKKyAgICBjb25zdCBRTGF0aW4xU3RyaW5nIGV4cGVjdGVkUmVjZWl2ZWRLZXlB cnJheTEoImtleWRvd246ODE6MCxrZXl1cDo4MTowIik7CisgICAgUVN0cmluZyByZWNlaXZlZEtl eUFycmF5ID0gd2ViVmlldy5wYWdlKCktPm1haW5GcmFtZSgpLT5ldmFsdWF0ZUphdmFTY3JpcHQo UUxhdGluMVN0cmluZygicmVjZWl2ZWRLZXlBcnJheSIpKS50b1N0cmluZ0xpc3QoKS5qb2luKCIs Iik7CisgICAgUVZFUklGWShyZWNlaXZlZEtleUFycmF5ID09IGV4cGVjdGVkUmVjZWl2ZWRLZXlB cnJheTEpOworCisgICAgLy8gTm9ybWFsIFBDIGtleWJvYXJkIGtleSBjb252ZXJzdGlvbiBmbG93 IHNob3VsZG4ndCBiZSBhZmZlY3RlZCB3aGVuIHNlbmRpbmcgbmF0aXZlVmlydHVhbCBrZXkgYXMg MC4KKyAgICAvLyBRdDo6S2V5X1BhdXNlIC0tPiBWS19QQVVTRSgweDEzKQorICAgIHdlYlZpZXcu cGFnZSgpLT5tYWluRnJhbWUoKS0+ZXZhbHVhdGVKYXZhU2NyaXB0KFFMYXRpbjFTdHJpbmcoInJl Y2VpdmVkS2V5QXJyYXkgPSBuZXcgQXJyYXkoKSIpKTsgLy8gUmVzZXQKKyAgICBrZXlFdmVudCA9 IFFLZXlFdmVudChRRXZlbnQ6OktleVByZXNzLCBRdDo6S2V5X1BhdXNlLCBRdDo6Tm9Nb2RpZmll ciwgMCwgMCwgMCk7CisgICAgUUFwcGxpY2F0aW9uOjpzZW5kRXZlbnQoJndlYlZpZXcsICZrZXlF dmVudCk7CisgICAga2V5RXZlbnQgPSBRS2V5RXZlbnQoUUV2ZW50OjpLZXlSZWxlYXNlLCBRdDo6 S2V5X1BhdXNlLCBRdDo6Tm9Nb2RpZmllciwgMCwgMCwgMCk7CisgICAgUUFwcGxpY2F0aW9uOjpz ZW5kRXZlbnQoJndlYlZpZXcsICZrZXlFdmVudCk7CisgICAgY29uc3QgUUxhdGluMVN0cmluZyBl eHBlY3RlZFJlY2VpdmVkS2V5QXJyYXkyKCJrZXlkb3duOjE5OjAsa2V5dXA6MTk6MCIpOworICAg IHJlY2VpdmVkS2V5QXJyYXkgPSB3ZWJWaWV3LnBhZ2UoKS0+bWFpbkZyYW1lKCktPmV2YWx1YXRl SmF2YVNjcmlwdChRTGF0aW4xU3RyaW5nKCJyZWNlaXZlZEtleUFycmF5IikpLnRvU3RyaW5nTGlz dCgpLmpvaW4oIiwiKTsKKyAgICBRVkVSSUZZKHJlY2VpdmVkS2V5QXJyYXkgPT0gZXhwZWN0ZWRS ZWNlaXZlZEtleUFycmF5Mik7CisKKyAgICAvLyBOZWdhdGl2ZSBjYXNlLgorICAgIC8vIERpc2Fi bGUgc2V0dGluZ3MgdG8gdXNlIG5hdGl2ZVZpcnR1YWxLZXkgYXMgRE9NIGtleSB2YWx1ZS4KKyAg ICB3ZWJWaWV3LnBhZ2UoKS0+c2V0UHJvcGVydHkoIl9xX3VzZU5hdGl2ZVZpcnR1YWxLZXlBc0RP TUtleSIsIGZhbHNlKTsKKyAgICAvLyBRdDo6S2V5X1BhdXNlIC0tPiBWS19QQVVTRSgweDEzKQor ICAgIHdlYlZpZXcucGFnZSgpLT5tYWluRnJhbWUoKS0+ZXZhbHVhdGVKYXZhU2NyaXB0KFFMYXRp bjFTdHJpbmcoInJlY2VpdmVkS2V5QXJyYXkgPSBuZXcgQXJyYXkoKSIpKTsgLy8gUmVzZXQKKyAg ICBrZXlFdmVudCA9IFFLZXlFdmVudChRRXZlbnQ6OktleVByZXNzLCBRdDo6S2V5X1BhdXNlLCBR dDo6Tm9Nb2RpZmllciwgMCwgODEsIDApOworICAgIFFBcHBsaWNhdGlvbjo6c2VuZEV2ZW50KCZ3 ZWJWaWV3LCAma2V5RXZlbnQpOworICAgIGtleUV2ZW50ID0gUUtleUV2ZW50KFFFdmVudDo6S2V5 UmVsZWFzZSwgUXQ6OktleV9QYXVzZSwgUXQ6Ok5vTW9kaWZpZXIsIDAsIDgxLCAwKTsKKyAgICBR QXBwbGljYXRpb246OnNlbmRFdmVudCgmd2ViVmlldywgJmtleUV2ZW50KTsKKyAgICBjb25zdCBR TGF0aW4xU3RyaW5nIGV4cGVjdGVkUmVjZWl2ZWRLZXlBcnJheTMoImtleWRvd246MTk6MCxrZXl1 cDoxOTowIik7CisgICAgcmVjZWl2ZWRLZXlBcnJheSA9IHdlYlZpZXcucGFnZSgpLT5tYWluRnJh bWUoKS0+ZXZhbHVhdGVKYXZhU2NyaXB0KFFMYXRpbjFTdHJpbmcoInJlY2VpdmVkS2V5QXJyYXki KSkudG9TdHJpbmdMaXN0KCkuam9pbigiLCIpOworICAgIFFWRVJJRlkocmVjZWl2ZWRLZXlBcnJh eSA9PSBleHBlY3RlZFJlY2VpdmVkS2V5QXJyYXkzKTsKK30KKwogY2xhc3MgSlNUZXN0UGFnZSA6 IHB1YmxpYyBRV2ViUGFnZQogewogUV9PQkpFQ1QK