From nobody Wed Nov 5 16:59:15 2025 Delivered-To: importer@patchew.org Received-SPF: pass (zoho.com: domain of gnu.org designates 208.118.235.17 as permitted sender) client-ip=208.118.235.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Authentication-Results: mx.zohomail.com; dkim=fail; spf=pass (zoho.com: domain of gnu.org designates 208.118.235.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org Return-Path: Received: from lists.gnu.org (208.118.235.17 [208.118.235.17]) by mx.zohomail.com with SMTPS id 1535992423737721.4346374652399; Mon, 3 Sep 2018 09:33:43 -0700 (PDT) Received: from localhost ([::1]:46065 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1fwrn8-0002zA-Mf for importer@patchew.org; Mon, 03 Sep 2018 12:33:30 -0400 Received: from eggs.gnu.org ([2001:4830:134:3::10]:49033) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1fwrm7-0001DC-Nz for qemu-devel@nongnu.org; Mon, 03 Sep 2018 12:32:29 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1fwrm2-0006E0-Fs for qemu-devel@nongnu.org; Mon, 03 Sep 2018 12:32:27 -0400 Received: from mail-40136.protonmail.ch ([185.70.40.136]:13756) by eggs.gnu.org with esmtps (TLS1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.71) (envelope-from ) id 1fwrm1-0006Bh-Nf for qemu-devel@nongnu.org; Mon, 03 Sep 2018 12:32:22 -0400 Date: Mon, 03 Sep 2018 16:32:10 +0000 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=protonmail.com; s=default; t=1535992334; bh=uxme8ZSTwregqr2WEKiC7R+0PXqUUq3aMl7EWUxo0vA=; h=Date:To:From:Reply-To:Subject:Feedback-ID:From; b=jsQRdSdS3NuNfm+ztxbreVZmoWOqoq9LaFvzZQikRDBQT7n0ZGB0l/bLJsMACHd8k RjAAhqCP3OKKtyh+Ltb8QuFSPRZaK95eqK/TiY+Gcs7Jgw/U5UjfXcHX2T4+07mwCZ SDrNRTVIRTbSwAue11+PdGiTsSwUWodlbVfG3Tf8= To: "qemu-devel@nongnu.org" , Gerd Hoffmann Message-ID: <45OPfGmaK-Sz9ZGzbGSmlE0AgSRiVp3mCkNrkJC2k6s4c9wOOcegenAJ6muFQwlGl1gBTMordKEgVU2tv9dThhXMDKaJPSZ6tNTMclo_n1E=@protonmail.com> Feedback-ID: bQ1YSMeFIHAUAn-uQLnVQcD6sUw_KdWbXPbLTy5DSY-qJoKk-ALPWbW_iVWAtXYm4PkoUPhIOhNDcF8xb3qjMA==:Ext:ProtonMail MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="b1_bb6f4ae9194fd87cb913f05e40e3403d" X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.2.x-3.x [generic] X-Received-From: 185.70.40.136 X-Content-Filtered-By: Mailman/MimeDel 2.1.21 Subject: [Qemu-devel] [PATCH] input-linux: customizable grab toggle keys v3 X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , From: Ryan El Kochta via Qemu-devel Reply-To: Ryan El Kochta Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-Zoho-Virus-Status: 1 X-ZohoMail-DKIM: fail (Header signature does not verify) X-ZohoMail: RDKM_2 RSF_0 Z_629925259 SPT_0 This is a multi-part message in MIME format. --b1_bb6f4ae9194fd87cb913f05e40e3403d Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" This patch adds a new option to the input-linux object: grab_toggle=3Dkey-key-key These keys can be one of the following: * lctrl * rctrl * lalt * ralt * lshift * rshift * backtick * scrolllock The user can pick any combination of these keys. The VM's grab of the evdev device will be toggled when all of the selected keys are pressed at the same time. If grab_toggle is not specified or malformed, the current default of lctrl+rctrl will be used. If scrolllock is selected as one of the grab_toggle keys, it will be entirely disabled and not passed to the guest at all. This is to prevent enabling it while attempting to leave or enter the VM. On the host, scrolllock can be disabled using xmodmap. First, find the modifier that Scroll_Lock is bound to: $ xmodmap -pm Then, remove Scroll_Lock from it, replacing modX with the modifier: $ xmodmap -e 'remove modX =3D Scroll_Lock' If Scroll_Lock is not bound to any modifier, it is already disabled. To save the changes, add them to your xinitrc. I have also attached the patch contained in the body of this email since my mail client does not seem to behave well with patches. If this is a problem, please let me know. Signed-off-by: Ryan El Kochta --- ui/input-linux.c | 156 ++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 153 insertions(+), 3 deletions(-) diff --git a/ui/input-linux.c b/ui/input-linux.c index 9720333b2c..2cbc877667 100644 --- a/ui/input-linux.c +++ b/ui/input-linux.c @@ -12,6 +12,7 @@ #include "sysemu/sysemu.h" #include "ui/input.h" #include "qom/object_interfaces.h" +#include "include/qemu/cutils.h" #include #include "standard-headers/linux/input.h" @@ -63,6 +64,11 @@ struct InputLinux { struct input_event event; int read_offset; + char *grab_toggle; + int grab_toggle_len; + int *grab_toggle_list; + bool skip_scrolllock; + QTAILQ_ENTRY(InputLinux) next; }; @@ -98,6 +104,25 @@ static void input_linux_toggle_grab(InputLinux *il) } } +static bool input_linux_check_grab_toggle(InputLinux *il) +{ + for (unsigned i =3D 0; i < il->grab_toggle_len; i++) { + if (!il->keydown[il->grab_toggle_list[i]]) { + return false; + } + } + return true; +} + +static bool input_linux_check_skip_scrolllock(InputLinux *il, + struct input_event *event) +{ + if (il->skip_scrolllock && event->code =3D=3D KEY_SCROLLLOCK) { + return true; + } + return false; +} + static void input_linux_handle_keyboard(InputLinux *il, struct input_event *event) { @@ -128,14 +153,13 @@ static void input_linux_handle_keyboard(InputLinux *i= l, } /* send event to guest when grab is active */ - if (il->grab_active) { + if (il->grab_active && !input_linux_check_skip_scrolllock(il, even= t)) { int qcode =3D qemu_input_linux_to_qcode(event->code); qemu_input_event_send_key_qcode(NULL, qcode, event->value); } /* hotkey -> record switch request ... */ - if (il->keydown[KEY_LEFTCTRL] && - il->keydown[KEY_RIGHTCTRL]) { + if (input_linux_check_grab_toggle(il)) { il->grab_request =3D true; } @@ -274,6 +298,15 @@ static void input_linux_complete(UserCreatable *uc, Er= ror **errp) return; } + if(!il->grab_toggle || !il->grab_toggle_len || !il->grab_toggle_list) { + il->skip_scrolllock =3D false; + il->grab_toggle =3D NULL; + il->grab_toggle_len =3D 2; + il->grab_toggle_list =3D g_new(int, 2); + il->grab_toggle_list[0] =3D KEY_LEFTCTRL; + il->grab_toggle_list[1] =3D KEY_RIGHTCTRL; + } + il->fd =3D open(il->evdev, O_RDWR); if (il->fd < 0) { error_setg_file_open(errp, errno, il->evdev); @@ -410,11 +443,128 @@ static void input_linux_set_repeat(Object *obj, bool= value, il->repeat =3D value; } +static void input_linux_populate_grab_toggle(InputLinux *il) +{ + char *orig, *saveptr, *token; + unsigned cntr =3D 0; + + /* + * If no grab_toggle string was provided, return. + * This will be cleaned up in the input_linux_complete() + * function and reset to both Ctrl keys. + */ + if (!il->grab_toggle) { + return; + } + + il->skip_scrolllock =3D false; + + /* Create a new string for strtok_r */ + orig =3D g_strdup(il->grab_toggle); + + /* + * Iterate through each token in the string, + * separated by dashes, and add it to the il->grab_toggle_list + * array. + * + * Unfortunately this must be done twice in order to + * determine how much memory will be allocated later on. + */ + + /* First iteration */ + il->grab_toggle_len =3D 0; + saveptr =3D orig; + while (strtok_r(saveptr, "-", &saveptr)) { + il->grab_toggle_len++; + /* If this overflows, use the default */ + if (il->grab_toggle_len < 0) { + il->grab_toggle_len =3D 0; + break; + } + } + + /* + * If the count found zero tokens, return an empty list. + * Again, this will be cleaned up in input_linux_complete(). + */ + if (!il->grab_toggle_len) { + g_free(orig); + return; + } + + /* Second scan */ + il->grab_toggle_list =3D g_new(int, il->grab_toggle_len); + strcpy(orig, il->grab_toggle); + saveptr =3D orig; + + /* Add each token's key to the list */ + while ((token =3D strtok_r(saveptr, "-", &saveptr))) { + if (!strcmp(token, "lctrl")) { + il->grab_toggle_list[cntr] =3D KEY_LEFTCTRL; + } else if (!strcmp(token, "rctrl")) { + il->grab_toggle_list[cntr] =3D KEY_RIGHTCTRL; + } else if (!strcmp(token, "lalt")) { + il->grab_toggle_list[cntr] =3D KEY_LEFTALT; + } else if (!strcmp(token, "ralt")) { + il->grab_toggle_list[cntr] =3D KEY_RIGHTALT; + } else if (!strcmp(token, "lshift")) { + il->grab_toggle_list[cntr] =3D KEY_LEFTSHIFT; + } else if (!strcmp(token, "rshift")) { + il->grab_toggle_list[cntr] =3D KEY_RIGHTSHIFT; + } else if (!strcmp(token, "backtick")) { + il->grab_toggle_list[cntr] =3D KEY_GRAVE; + } else if (!strcmp(token, "scrolllock")) { + il->grab_toggle_list[cntr] =3D KEY_SCROLLLOCK; + il->skip_scrolllock =3D true; + } else { + /* + * If any of the parameters are invalid, + * stick to the default of LCtrl+RCtrl. + * + * We could just skip that parameter, but + * that means if you input only invalid parameters, + * there would be no way to escape the VM. + */ + il->grab_toggle_len =3D 0; + g_free(orig); + g_free(il->grab_toggle_list); + return; + } + + cntr++; + } + g_free(orig); +} + +static char *input_linux_get_grab_toggle(Object *obj, Error **errp) +{ + InputLinux *il =3D INPUT_LINUX(obj); + + return g_strdup(il->grab_toggle); +} + +static void input_linux_set_grab_toggle(Object *obj, const char *value, + Error **errp) +{ + InputLinux *il =3D INPUT_LINUX(obj); + + if (il->grab_toggle) { + error_setg(errp, "grab_toggle property already set"); + return; + } + il->grab_toggle =3D g_strdup(value); + + input_linux_populate_grab_toggle(il); +} + static void input_linux_instance_init(Object *obj) { object_property_add_str(obj, "evdev", input_linux_get_evdev, input_linux_set_evdev, NULL); + object_property_add_str(obj, "grab_toggle", + input_linux_get_grab_toggle, + input_linux_set_grab_toggle, NULL); object_property_add_bool(obj, "grab_all", input_linux_get_grab_all, input_linux_set_grab_all, NULL); -- 2.18.0 --b1_bb6f4ae9194fd87cb913f05e40e3403d Content-Type: text/x-patch; name="0001-input-linux-customizable-grab-toggle-keys-v3.patch" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename=0001-input-linux-customizable-grab-toggle-keys-v3.patch RnJvbSBmOWYxM2I5MTU5Mjg3N2JjYTFlMjAxY2IyMDg3N2I3ODc2ZDVjZjA0IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBSeWFuIEVsIEtvY2h0YSA8bGlnaHRuMW5nc3RyMWtlQHByb3Rv bm1haWwuY29tPgpEYXRlOiBNb24sIDMgU2VwIDIwMTggMTI6MTk6NTEgLTA0MDAKU3ViamVjdDog W1BBVENIXSBpbnB1dC1saW51eDogY3VzdG9taXphYmxlIGdyYWIgdG9nZ2xlIGtleXMgdjMKClRo aXMgcGF0Y2ggYWRkcyBhIG5ldyBvcHRpb24gdG8gdGhlIGlucHV0LWxpbnV4IG9iamVjdDoKCmdy YWJfdG9nZ2xlPWtleS1rZXkta2V5CgpUaGVzZSBrZXlzIGNhbiBiZSBvbmUgb2YgdGhlIGZvbGxv d2luZzoKCiogbGN0cmwKKiByY3RybAoqIGxhbHQKKiByYWx0CiogbHNoaWZ0CiogcnNoaWZ0Ciog YmFja3RpY2sKKiBzY3JvbGxsb2NrCgpUaGUgdXNlciBjYW4gcGljayBhbnkgY29tYmluYXRpb24g b2YgdGhlc2Uga2V5cy4gVGhlIFZNJ3MgZ3JhYgpvZiB0aGUgZXZkZXYgZGV2aWNlIHdpbGwgYmUg dG9nZ2xlZCB3aGVuIGFsbCBvZiB0aGUgc2VsZWN0ZWQKa2V5cyBhcmUgcHJlc3NlZCBhdCB0aGUg c2FtZSB0aW1lLiBJZiBncmFiX3RvZ2dsZSBpcyBub3Qgc3BlY2lmaWVkCm9yIG1hbGZvcm1lZCwg dGhlIGN1cnJlbnQgZGVmYXVsdCBvZiBsY3RybCtyY3RybCB3aWxsIGJlIHVzZWQuCgpJZiBzY3Jv bGxsb2NrIGlzIHNlbGVjdGVkIGFzIG9uZSBvZiB0aGUgZ3JhYl90b2dnbGUga2V5cywgaXQKd2ls bCBiZSBlbnRpcmVseSBkaXNhYmxlZCBhbmQgbm90IHBhc3NlZCB0byB0aGUgZ3Vlc3QgYXQgYWxs LgpUaGlzIGlzIHRvIHByZXZlbnQgZW5hYmxpbmcgaXQgd2hpbGUgYXR0ZW1wdGluZyB0byBsZWF2 ZSBvciBlbnRlcgp0aGUgVk0uIE9uIHRoZSBob3N0LCBzY3JvbGxsb2NrIGNhbiBiZSBkaXNhYmxl ZCB1c2luZyB4bW9kbWFwLgoKRmlyc3QsIGZpbmQgdGhlIG1vZGlmaWVyIHRoYXQgU2Nyb2xsX0xv Y2sgaXMgYm91bmQgdG86Cgp4bW9kbWFwIC1wbQoKVGhlbiwgcmVtb3ZlIFNjcm9sbF9Mb2NrIGZy b20gaXQsIHJlcGxhY2luZyBtb2RYIHdpdGggdGhlIG1vZGlmaWVyOgoKeG1vZG1hcCAtZSAncmVt b3ZlIG1vZFggPSBTY3JvbGxfTG9jaycKCklmIFNjcm9sbF9Mb2NrIGlzIG5vdCBib3VuZCB0byBh bnkgbW9kaWZpZXIsIGl0IGlzIGFscmVhZHkgZGlzYWJsZWQuCgpUbyBzYXZlIHRoZSBjaGFuZ2Vz LCBhZGQgdGhlbSB0byB5b3VyIHhpbml0cmMuCgpTaWduZWQtb2ZmLWJ5OiBSeWFuIEVsIEtvY2h0 YSA8bGlnaHRuMW5nc3RyMWtlQHByb3Rvbm1haWwuY29tPgotLS0KIHVpL2lucHV0LWxpbnV4LmMg fCAxNTYgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0KIDEg ZmlsZSBjaGFuZ2VkLCAxNTMgaW5zZXJ0aW9ucygrKSwgMyBkZWxldGlvbnMoLSkKCmRpZmYgLS1n aXQgYS91aS9pbnB1dC1saW51eC5jIGIvdWkvaW5wdXQtbGludXguYwppbmRleCA5NzIwMzMzYjJj Li4yY2JjODc3NjY3IDEwMDY0NAotLS0gYS91aS9pbnB1dC1saW51eC5jCisrKyBiL3VpL2lucHV0 LWxpbnV4LmMKQEAgLTEyLDYgKzEyLDcgQEAKICNpbmNsdWRlICJzeXNlbXUvc3lzZW11LmgiCiAj aW5jbHVkZSAidWkvaW5wdXQuaCIKICNpbmNsdWRlICJxb20vb2JqZWN0X2ludGVyZmFjZXMuaCIK KyNpbmNsdWRlICJpbmNsdWRlL3FlbXUvY3V0aWxzLmgiCiAKICNpbmNsdWRlIDxzeXMvaW9jdGwu aD4KICNpbmNsdWRlICJzdGFuZGFyZC1oZWFkZXJzL2xpbnV4L2lucHV0LmgiCkBAIC02Myw2ICs2 NCwxMSBAQCBzdHJ1Y3QgSW5wdXRMaW51eCB7CiAgICAgc3RydWN0IGlucHV0X2V2ZW50IGV2ZW50 OwogICAgIGludCAgICAgICAgIHJlYWRfb2Zmc2V0OwogCisgICAgY2hhciAgICAgICAgKmdyYWJf dG9nZ2xlOworICAgIGludCAgICAgICAgIGdyYWJfdG9nZ2xlX2xlbjsKKyAgICBpbnQgICAgICAg ICAqZ3JhYl90b2dnbGVfbGlzdDsKKyAgICBib29sICAgICAgICBza2lwX3Njcm9sbGxvY2s7CisK ICAgICBRVEFJTFFfRU5UUlkoSW5wdXRMaW51eCkgbmV4dDsKIH07CiAKQEAgLTk4LDYgKzEwNCwy NSBAQCBzdGF0aWMgdm9pZCBpbnB1dF9saW51eF90b2dnbGVfZ3JhYihJbnB1dExpbnV4ICppbCkK ICAgICB9CiB9CiAKK3N0YXRpYyBib29sIGlucHV0X2xpbnV4X2NoZWNrX2dyYWJfdG9nZ2xlKElu cHV0TGludXggKmlsKQoreworICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBpbC0+Z3JhYl90 b2dnbGVfbGVuOyBpKyspIHsKKyAgICAgICAgaWYgKCFpbC0+a2V5ZG93bltpbC0+Z3JhYl90b2dn bGVfbGlzdFtpXV0pIHsKKyAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICAgICAgfQorICAg IH0KKyAgICByZXR1cm4gdHJ1ZTsKK30KKworc3RhdGljIGJvb2wgaW5wdXRfbGludXhfY2hlY2tf c2tpcF9zY3JvbGxsb2NrKElucHV0TGludXggKmlsLAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgc3RydWN0IGlucHV0X2V2ZW50ICpldmVudCkKK3sKKyAgICBpZiAoaWwt PnNraXBfc2Nyb2xsbG9jayAmJiBldmVudC0+Y29kZSA9PSBLRVlfU0NST0xMTE9DSykgeworICAg ICAgICByZXR1cm4gdHJ1ZTsKKyAgICB9CisgICAgcmV0dXJuIGZhbHNlOworfQorCiBzdGF0aWMg dm9pZCBpbnB1dF9saW51eF9oYW5kbGVfa2V5Ym9hcmQoSW5wdXRMaW51eCAqaWwsCiAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3RydWN0IGlucHV0X2V2ZW50ICpldmVu dCkKIHsKQEAgLTEyOCwxNCArMTUzLDEzIEBAIHN0YXRpYyB2b2lkIGlucHV0X2xpbnV4X2hhbmRs ZV9rZXlib2FyZChJbnB1dExpbnV4ICppbCwKICAgICAgICAgfQogCiAgICAgICAgIC8qIHNlbmQg ZXZlbnQgdG8gZ3Vlc3Qgd2hlbiBncmFiIGlzIGFjdGl2ZSAqLwotICAgICAgICBpZiAoaWwtPmdy YWJfYWN0aXZlKSB7CisgICAgICAgIGlmIChpbC0+Z3JhYl9hY3RpdmUgJiYgIWlucHV0X2xpbnV4 X2NoZWNrX3NraXBfc2Nyb2xsbG9jayhpbCwgZXZlbnQpKSB7CiAgICAgICAgICAgICBpbnQgcWNv ZGUgPSBxZW11X2lucHV0X2xpbnV4X3RvX3Fjb2RlKGV2ZW50LT5jb2RlKTsKICAgICAgICAgICAg IHFlbXVfaW5wdXRfZXZlbnRfc2VuZF9rZXlfcWNvZGUoTlVMTCwgcWNvZGUsIGV2ZW50LT52YWx1 ZSk7CiAgICAgICAgIH0KIAogICAgICAgICAvKiBob3RrZXkgLT4gcmVjb3JkIHN3aXRjaCByZXF1 ZXN0IC4uLiAqLwotICAgICAgICBpZiAoaWwtPmtleWRvd25bS0VZX0xFRlRDVFJMXSAmJgotICAg ICAgICAgICAgaWwtPmtleWRvd25bS0VZX1JJR0hUQ1RSTF0pIHsKKyAgICAgICAgaWYgKGlucHV0 X2xpbnV4X2NoZWNrX2dyYWJfdG9nZ2xlKGlsKSkgewogICAgICAgICAgICAgaWwtPmdyYWJfcmVx dWVzdCA9IHRydWU7CiAgICAgICAgIH0KIApAQCAtMjc0LDYgKzI5OCwxNSBAQCBzdGF0aWMgdm9p ZCBpbnB1dF9saW51eF9jb21wbGV0ZShVc2VyQ3JlYXRhYmxlICp1YywgRXJyb3IgKiplcnJwKQog ICAgICAgICByZXR1cm47CiAgICAgfQogCisgICAgaWYoIWlsLT5ncmFiX3RvZ2dsZSB8fCAhaWwt PmdyYWJfdG9nZ2xlX2xlbiB8fCAhaWwtPmdyYWJfdG9nZ2xlX2xpc3QpIHsKKyAgICAgICAgaWwt PnNraXBfc2Nyb2xsbG9jayA9IGZhbHNlOworICAgICAgICBpbC0+Z3JhYl90b2dnbGUgPSBOVUxM OworICAgICAgICBpbC0+Z3JhYl90b2dnbGVfbGVuID0gMjsKKyAgICAgICAgaWwtPmdyYWJfdG9n Z2xlX2xpc3QgPSBnX25ldyhpbnQsIDIpOworICAgICAgICBpbC0+Z3JhYl90b2dnbGVfbGlzdFsw XSA9IEtFWV9MRUZUQ1RSTDsKKyAgICAgICAgaWwtPmdyYWJfdG9nZ2xlX2xpc3RbMV0gPSBLRVlf UklHSFRDVFJMOworICAgIH0KKwogICAgIGlsLT5mZCA9IG9wZW4oaWwtPmV2ZGV2LCBPX1JEV1Ip OwogICAgIGlmIChpbC0+ZmQgPCAwKSAgewogICAgICAgICBlcnJvcl9zZXRnX2ZpbGVfb3Blbihl cnJwLCBlcnJubywgaWwtPmV2ZGV2KTsKQEAgLTQxMCwxMSArNDQzLDEyOCBAQCBzdGF0aWMgdm9p ZCBpbnB1dF9saW51eF9zZXRfcmVwZWF0KE9iamVjdCAqb2JqLCBib29sIHZhbHVlLAogICAgIGls LT5yZXBlYXQgPSB2YWx1ZTsKIH0KIAorc3RhdGljIHZvaWQgaW5wdXRfbGludXhfcG9wdWxhdGVf Z3JhYl90b2dnbGUoSW5wdXRMaW51eCAqaWwpCit7CisgICAgY2hhciAqb3JpZywgKnNhdmVwdHIs ICp0b2tlbjsKKyAgICB1bnNpZ25lZCBjbnRyID0gMDsKKworICAgIC8qCisgICAgICogSWYgbm8g Z3JhYl90b2dnbGUgc3RyaW5nIHdhcyBwcm92aWRlZCwgcmV0dXJuLgorICAgICAqIFRoaXMgd2ls bCBiZSBjbGVhbmVkIHVwIGluIHRoZSBpbnB1dF9saW51eF9jb21wbGV0ZSgpCisgICAgICogZnVu Y3Rpb24gYW5kIHJlc2V0IHRvIGJvdGggQ3RybCBrZXlzLgorICAgICAqLworICAgIGlmICghaWwt PmdyYWJfdG9nZ2xlKSB7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBpbC0+c2tpcF9z Y3JvbGxsb2NrID0gZmFsc2U7CisKKyAgICAvKiBDcmVhdGUgYSBuZXcgc3RyaW5nIGZvciBzdHJ0 b2tfciAqLworICAgIG9yaWcgPSBnX3N0cmR1cChpbC0+Z3JhYl90b2dnbGUpOworCisgICAgLyoK KyAgICAgKiBJdGVyYXRlIHRocm91Z2ggZWFjaCB0b2tlbiBpbiB0aGUgc3RyaW5nLAorICAgICAq IHNlcGFyYXRlZCBieSBkYXNoZXMsIGFuZCBhZGQgaXQgdG8gdGhlIGlsLT5ncmFiX3RvZ2dsZV9s aXN0CisgICAgICogYXJyYXkuCisgICAgICoKKyAgICAgKiBVbmZvcnR1bmF0ZWx5IHRoaXMgbXVz dCBiZSBkb25lIHR3aWNlIGluIG9yZGVyIHRvCisgICAgICogZGV0ZXJtaW5lIGhvdyBtdWNoIG1l bW9yeSB3aWxsIGJlIGFsbG9jYXRlZCBsYXRlciBvbi4KKyAgICAgKi8KKworICAgIC8qIEZpcnN0 IGl0ZXJhdGlvbiAqLworICAgIGlsLT5ncmFiX3RvZ2dsZV9sZW4gPSAwOworICAgIHNhdmVwdHIg PSBvcmlnOworICAgIHdoaWxlIChzdHJ0b2tfcihzYXZlcHRyLCAiLSIsICZzYXZlcHRyKSkgewor ICAgICAgICBpbC0+Z3JhYl90b2dnbGVfbGVuKys7CisgICAgICAgIC8qIElmIHRoaXMgb3ZlcmZs b3dzLCB1c2UgdGhlIGRlZmF1bHQgKi8KKyAgICAgICAgaWYgKGlsLT5ncmFiX3RvZ2dsZV9sZW4g PCAwKSB7CisgICAgICAgICAgICBpbC0+Z3JhYl90b2dnbGVfbGVuID0gMDsKKyAgICAgICAgICAg IGJyZWFrOworICAgICAgICB9CisgICAgfQorCisgICAgLyoKKyAgICAgKiBJZiB0aGUgY291bnQg Zm91bmQgemVybyB0b2tlbnMsIHJldHVybiBhbiBlbXB0eSBsaXN0LgorICAgICAqIEFnYWluLCB0 aGlzIHdpbGwgYmUgY2xlYW5lZCB1cCBpbiBpbnB1dF9saW51eF9jb21wbGV0ZSgpLgorICAgICAq LworICAgIGlmICghaWwtPmdyYWJfdG9nZ2xlX2xlbikgeworICAgICAgICBnX2ZyZWUob3JpZyk7 CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICAvKiBTZWNvbmQgc2NhbiAqLworICAgIGls LT5ncmFiX3RvZ2dsZV9saXN0ID0gZ19uZXcoaW50LCBpbC0+Z3JhYl90b2dnbGVfbGVuKTsKKyAg ICBzdHJjcHkob3JpZywgaWwtPmdyYWJfdG9nZ2xlKTsKKyAgICBzYXZlcHRyID0gb3JpZzsKKwor ICAgIC8qIEFkZCBlYWNoIHRva2VuJ3Mga2V5IHRvIHRoZSBsaXN0ICovCisgICAgd2hpbGUgKCh0 b2tlbiA9IHN0cnRva19yKHNhdmVwdHIsICItIiwgJnNhdmVwdHIpKSkgeworICAgICAgICBpZiAo IXN0cmNtcCh0b2tlbiwgImxjdHJsIikpIHsKKyAgICAgICAgICAgIGlsLT5ncmFiX3RvZ2dsZV9s aXN0W2NudHJdID0gS0VZX0xFRlRDVFJMOworICAgICAgICB9IGVsc2UgaWYgKCFzdHJjbXAodG9r ZW4sICJyY3RybCIpKSB7CisgICAgICAgICAgICBpbC0+Z3JhYl90b2dnbGVfbGlzdFtjbnRyXSA9 IEtFWV9SSUdIVENUUkw7CisgICAgICAgIH0gZWxzZSBpZiAoIXN0cmNtcCh0b2tlbiwgImxhbHQi KSkgeworICAgICAgICAgICAgaWwtPmdyYWJfdG9nZ2xlX2xpc3RbY250cl0gPSBLRVlfTEVGVEFM VDsKKyAgICAgICAgfSBlbHNlIGlmICghc3RyY21wKHRva2VuLCAicmFsdCIpKSB7CisgICAgICAg ICAgICBpbC0+Z3JhYl90b2dnbGVfbGlzdFtjbnRyXSA9IEtFWV9SSUdIVEFMVDsKKyAgICAgICAg fSBlbHNlIGlmICghc3RyY21wKHRva2VuLCAibHNoaWZ0IikpIHsKKyAgICAgICAgICAgIGlsLT5n cmFiX3RvZ2dsZV9saXN0W2NudHJdID0gS0VZX0xFRlRTSElGVDsKKyAgICAgICAgfSBlbHNlIGlm ICghc3RyY21wKHRva2VuLCAicnNoaWZ0IikpIHsKKyAgICAgICAgICAgIGlsLT5ncmFiX3RvZ2ds ZV9saXN0W2NudHJdID0gS0VZX1JJR0hUU0hJRlQ7CisgICAgICAgIH0gZWxzZSBpZiAoIXN0cmNt cCh0b2tlbiwgImJhY2t0aWNrIikpIHsKKyAgICAgICAgICAgIGlsLT5ncmFiX3RvZ2dsZV9saXN0 W2NudHJdID0gS0VZX0dSQVZFOworICAgICAgICB9IGVsc2UgaWYgKCFzdHJjbXAodG9rZW4sICJz Y3JvbGxsb2NrIikpIHsKKyAgICAgICAgICAgIGlsLT5ncmFiX3RvZ2dsZV9saXN0W2NudHJdID0g S0VZX1NDUk9MTExPQ0s7CisgICAgICAgICAgICBpbC0+c2tpcF9zY3JvbGxsb2NrID0gdHJ1ZTsK KyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgIC8qCisgICAgICAgICAgICAqIElmIGFueSBv ZiB0aGUgcGFyYW1ldGVycyBhcmUgaW52YWxpZCwKKyAgICAgICAgICAgICogc3RpY2sgdG8gdGhl IGRlZmF1bHQgb2YgTEN0cmwrUkN0cmwuCisgICAgICAgICAgICAqCisgICAgICAgICAgICAqIFdl IGNvdWxkIGp1c3Qgc2tpcCB0aGF0IHBhcmFtZXRlciwgYnV0CisgICAgICAgICAgICAqIHRoYXQg bWVhbnMgaWYgeW91IGlucHV0IG9ubHkgaW52YWxpZCBwYXJhbWV0ZXJzLAorICAgICAgICAgICAg KiB0aGVyZSB3b3VsZCBiZSBubyB3YXkgdG8gZXNjYXBlIHRoZSBWTS4KKyAgICAgICAgICAgICov CisgICAgICAgICAgICBpbC0+Z3JhYl90b2dnbGVfbGVuID0gMDsKKyAgICAgICAgICAgIGdfZnJl ZShvcmlnKTsKKyAgICAgICAgICAgIGdfZnJlZShpbC0+Z3JhYl90b2dnbGVfbGlzdCk7CisgICAg ICAgICAgICByZXR1cm47CisgICAgICAgIH0KKworICAgICAgICBjbnRyKys7CisgICAgfQorICAg IGdfZnJlZShvcmlnKTsKK30KKworc3RhdGljIGNoYXIgKmlucHV0X2xpbnV4X2dldF9ncmFiX3Rv Z2dsZShPYmplY3QgKm9iaiwgRXJyb3IgKiplcnJwKQoreworICAgIElucHV0TGludXggKmlsID0g SU5QVVRfTElOVVgob2JqKTsKKworICAgIHJldHVybiBnX3N0cmR1cChpbC0+Z3JhYl90b2dnbGUp OworfQorCitzdGF0aWMgdm9pZCBpbnB1dF9saW51eF9zZXRfZ3JhYl90b2dnbGUoT2JqZWN0ICpv YmosIGNvbnN0IGNoYXIgKnZhbHVlLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIEVycm9yICoqZXJycCkKK3sKKyAgICBJbnB1dExpbnV4ICppbCA9IElOUFVUX0xJTlVY KG9iaik7CisKKyAgICBpZiAoaWwtPmdyYWJfdG9nZ2xlKSB7CisgICAgICAgIGVycm9yX3NldGco ZXJycCwgImdyYWJfdG9nZ2xlIHByb3BlcnR5IGFscmVhZHkgc2V0Iik7CisgICAgICAgIHJldHVy bjsKKyAgICB9CisgICAgaWwtPmdyYWJfdG9nZ2xlID0gZ19zdHJkdXAodmFsdWUpOworCisgICAg aW5wdXRfbGludXhfcG9wdWxhdGVfZ3JhYl90b2dnbGUoaWwpOworfQorCiBzdGF0aWMgdm9pZCBp bnB1dF9saW51eF9pbnN0YW5jZV9pbml0KE9iamVjdCAqb2JqKQogewogICAgIG9iamVjdF9wcm9w ZXJ0eV9hZGRfc3RyKG9iaiwgImV2ZGV2IiwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBp bnB1dF9saW51eF9nZXRfZXZkZXYsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaW5wdXRf bGludXhfc2V0X2V2ZGV2LCBOVUxMKTsKKyAgICBvYmplY3RfcHJvcGVydHlfYWRkX3N0cihvYmos ICJncmFiX3RvZ2dsZSIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgaW5wdXRfbGludXhf Z2V0X2dyYWJfdG9nZ2xlLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlucHV0X2xpbnV4 X3NldF9ncmFiX3RvZ2dsZSwgTlVMTCk7CiAgICAgb2JqZWN0X3Byb3BlcnR5X2FkZF9ib29sKG9i aiwgImdyYWJfYWxsIiwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaW5wdXRfbGludXhf Z2V0X2dyYWJfYWxsLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpbnB1dF9saW51eF9z ZXRfZ3JhYl9hbGwsIE5VTEwpOwotLSAKMi4xOC4wCgo= --b1_bb6f4ae9194fd87cb913f05e40e3403d--